LegacyConsoleArchive/4jcraft
1
0
Fork 0
mirror of https://git.huckle.dev/Huckles-Minecraft-Archive/4jcraft.git synced 2026-09-24 20:20:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: unglob std::shared_ptr

Browse Source
This commit is contained in:
Tropical
2026-03-06 11:20:45 -06:00
parent 0dd1654dec
commit 67ceccf2d4
1065 changed files with 5754 additions and 5749 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Minecraft.Client/Rendering/Camera.cpp
+4 -4
View File
@@ -21,7 +21,7 @@ float Camera::za = 0.0f;
float Camera::xa2 = 0.0f;
float Camera::za2 = 0.0f;
void Camera::prepare(shared_ptr<Player> player, bool mirror)
void Camera::prepare(std::shared_ptr<Player> player, bool mirror)
{
glGetFloat(GL_MODELVIEW_MATRIX, modelview);
glGetFloat(GL_PROJECTION_MATRIX, projection);
@@ -88,12 +88,12 @@ void Camera::prepare(shared_ptr<Player> player, bool mirror)
ya = cosf(xRot * PI / 180.0f);
}
TilePos *Camera::getCameraTilePos(shared_ptr<Mob> player, double alpha)
TilePos *Camera::getCameraTilePos(std::shared_ptr<Mob> player, double alpha)
{
return new TilePos(getCameraPos(player, alpha));
}
Vec3 *Camera::getCameraPos(shared_ptr<Mob> player, double alpha)
Vec3 *Camera::getCameraPos(std::shared_ptr<Mob> player, double alpha)
{
double xx = player->xo + (player->x - player->xo) * alpha;
double yy = player->yo + (player->y - player->yo) * alpha + player->getHeadHeight();
@@ -106,7 +106,7 @@ Vec3 *Camera::getCameraPos(shared_ptr<Mob> player, double alpha)
return Vec3::newTemp(xt, yt, zt);
}
int Camera::getBlockAt(Level *level, shared_ptr<Mob> player, float alpha)
int Camera::getBlockAt(Level *level, std::shared_ptr<Mob> player, float alpha)
{
Vec3 *p = Camera::getCameraPos(player, alpha);
TilePos tp = TilePos(p);
Minecraft.Client/Rendering/Camera.h
+4 -4
View File
@@ -24,9 +24,9 @@ private:
public:
static float xa, ya, za, xa2, za2;
static void prepare(shared_ptr<Player> player, bool mirror);
static void prepare(std::shared_ptr<Player> player, bool mirror);
static TilePos *getCameraTilePos(shared_ptr<Mob> player, double alpha);
static Vec3 *getCameraPos(shared_ptr<Mob> player, double alpha);
static int getBlockAt(Level *level, shared_ptr<Mob> player, float alpha);
static TilePos *getCameraTilePos(std::shared_ptr<Mob> player, double alpha);
static Vec3 *getCameraPos(std::shared_ptr<Mob> player, double alpha);
static int getBlockAt(Level *level, std::shared_ptr<Mob> player, float alpha);
};
Minecraft.Client/Rendering/Chunk.cpp
+18 -18
View File
@@ -204,10 +204,10 @@ void Chunk::rebuild()
LevelChunk::touchedSky = false;
// unordered_set<shared_ptr<TileEntity> > oldTileEntities(renderableTileEntities.begin(),renderableTileEntities.end()); // 4J removed this & next line
// unordered_set<std::shared_ptr<TileEntity> > oldTileEntities(renderableTileEntities.begin(),renderableTileEntities.end()); // 4J removed this & next line
// renderableTileEntities.clear();
vector<shared_ptr<TileEntity> > renderableTileEntities; // 4J - added
vector<std::shared_ptr<TileEntity> > renderableTileEntities; // 4J - added
int r = 1;
@@ -402,7 +402,7 @@ void Chunk::rebuild()
Tile *tile = Tile::tiles[tileId];
if (currentLayer == 0 && tile->isEntityTile())
{
shared_ptr<TileEntity> et = region->getTileEntity(x, y, z);
std::shared_ptr<TileEntity> et = region->getTileEntity(x, y, z);
if (TileEntityRenderDispatcher::instance->hasRenderer(et))
{
renderableTileEntities.push_back(et);
@@ -554,10 +554,10 @@ void Chunk::rebuild()
*/
unordered_set<shared_ptr<TileEntity> > newTileEntities(renderableTileEntities.begin(),renderableTileEntities.end());
unordered_set<std::shared_ptr<TileEntity> > newTileEntities(renderableTileEntities.begin(),renderableTileEntities.end());
AUTO_VAR(endIt, oldTileEntities.end());
for( unordered_set<shared_ptr<TileEntity> >::iterator it = oldTileEntities.begin(); it != endIt; it++ )
for( unordered_set<std::shared_ptr<TileEntity> >::iterator it = oldTileEntities.begin(); it != endIt; it++ )
{
newTileEntities.erase(*it);
}
@@ -566,7 +566,7 @@ void Chunk::rebuild()
EnterCriticalSection(globalRenderableTileEntities_cs);
endIt = newTileEntities.end();
for( unordered_set<shared_ptr<TileEntity> >::iterator it = newTileEntities.begin(); it != endIt; it++ )
for( unordered_set<std::shared_ptr<TileEntity> >::iterator it = newTileEntities.begin(); it != endIt; it++ )
{
globalRenderableTileEntities->push_back(*it);
}
@@ -574,12 +574,12 @@ void Chunk::rebuild()
// 4J - All these new things added to globalRenderableTileEntities
AUTO_VAR(endItRTE, renderableTileEntities.end());
for( vector<shared_ptr<TileEntity> >::iterator it = renderableTileEntities.begin(); it != endItRTE; it++ )
for( vector<std::shared_ptr<TileEntity> >::iterator it = renderableTileEntities.begin(); it != endItRTE; it++ )
{
oldTileEntities.erase(*it);
}
// 4J - oldTileEntities is now the removed items
vector<shared_ptr<TileEntity> >::iterator it = globalRenderableTileEntities->begin();
vector<std::shared_ptr<TileEntity> >::iterator it = globalRenderableTileEntities->begin();
while( it != globalRenderableTileEntities->end() )
{
if( oldTileEntities.find(*it) != oldTileEntities.end() )
@@ -656,10 +656,10 @@ void Chunk::rebuild_SPU()
LevelChunk::touchedSky = false;
// unordered_set<shared_ptr<TileEntity> > oldTileEntities(renderableTileEntities.begin(),renderableTileEntities.end()); // 4J removed this & next line
// unordered_set<std::shared_ptr<TileEntity> > oldTileEntities(renderableTileEntities.begin(),renderableTileEntities.end()); // 4J removed this & next line
// renderableTileEntities.clear();
vector<shared_ptr<TileEntity> > renderableTileEntities; // 4J - added
vector<std::shared_ptr<TileEntity> > renderableTileEntities; // 4J - added
// List<TileEntity> newTileEntities = new ArrayList<TileEntity>();
// newTileEntities.clear();
@@ -750,7 +750,7 @@ void Chunk::rebuild_SPU()
{
if (currentLayer == 0 && Tile::tiles[tileId]->isEntityTile())
{
shared_ptr<TileEntity> et = region.getTileEntity(x, y, z);
std::shared_ptr<TileEntity> et = region.getTileEntity(x, y, z);
if (TileEntityRenderDispatcher::instance->hasRenderer(et))
{
renderableTileEntities.push_back(et);
@@ -883,10 +883,10 @@ void Chunk::rebuild_SPU()
*/
unordered_set<shared_ptr<TileEntity> > newTileEntities(renderableTileEntities.begin(),renderableTileEntities.end());
unordered_set<std::shared_ptr<TileEntity> > newTileEntities(renderableTileEntities.begin(),renderableTileEntities.end());
AUTO_VAR(endIt, oldTileEntities.end());
for( unordered_set<shared_ptr<TileEntity> >::iterator it = oldTileEntities.begin(); it != endIt; it++ )
for( unordered_set<std::shared_ptr<TileEntity> >::iterator it = oldTileEntities.begin(); it != endIt; it++ )
{
newTileEntities.erase(*it);
}
@@ -895,7 +895,7 @@ void Chunk::rebuild_SPU()
EnterCriticalSection(globalRenderableTileEntities_cs);
endIt = newTileEntities.end();
for( unordered_set<shared_ptr<TileEntity> >::iterator it = newTileEntities.begin(); it != endIt; it++ )
for( unordered_set<std::shared_ptr<TileEntity> >::iterator it = newTileEntities.begin(); it != endIt; it++ )
{
globalRenderableTileEntities.push_back(*it);
}
@@ -903,12 +903,12 @@ void Chunk::rebuild_SPU()
// 4J - All these new things added to globalRenderableTileEntities
AUTO_VAR(endItRTE, renderableTileEntities.end());
for( vector<shared_ptr<TileEntity> >::iterator it = renderableTileEntities.begin(); it != endItRTE; it++ )
for( vector<std::shared_ptr<TileEntity> >::iterator it = renderableTileEntities.begin(); it != endItRTE; it++ )
{
oldTileEntities.erase(*it);
}
// 4J - oldTileEntities is now the removed items
vector<shared_ptr<TileEntity> >::iterator it = globalRenderableTileEntities->begin();
vector<std::shared_ptr<TileEntity> >::iterator it = globalRenderableTileEntities->begin();
while( it != globalRenderableTileEntities->end() )
{
if( oldTileEntities.find(*it) != oldTileEntities.end() )
@@ -941,7 +941,7 @@ void Chunk::rebuild_SPU()
#endif // _PS3_
float Chunk::distanceToSqr(shared_ptr<Entity> player) const
float Chunk::distanceToSqr(std::shared_ptr<Entity> player) const
{
float xd = (float) (player->x - xm);
float yd = (float) (player->y - ym);
@@ -949,7 +949,7 @@ float Chunk::distanceToSqr(shared_ptr<Entity> player) const
return xd * xd + yd * yd + zd * zd;
}
float Chunk::squishedDistanceToSqr(shared_ptr<Entity> player)
float Chunk::squishedDistanceToSqr(std::shared_ptr<Entity> player)
{
float xd = (float) (player->x - xm);
float yd = (float) (player->y - ym) * 2;
Minecraft.Client/Rendering/Chunk.h
+3 -3
View File
@@ -52,7 +52,7 @@ public:
int id;
//public:
// vector<shared_ptr<TileEntity> > renderableTileEntities; // 4J - removed
// vector<std::shared_ptr<TileEntity> > renderableTileEntities; // 4J - removed
private:
LevelRenderer::rteMap *globalRenderableTileEntities;
@@ -71,8 +71,8 @@ public:
#ifdef __PS3__
void rebuild_SPU();
#endif // __PS3__
float distanceToSqr(shared_ptr<Entity> player) const;
float squishedDistanceToSqr(shared_ptr<Entity> player);
float distanceToSqr(std::shared_ptr<Entity> player) const;
float squishedDistanceToSqr(std::shared_ptr<Entity> player);
void reset();
void _delete();
Minecraft.Client/Rendering/Culling/DirtyChunkSorter.cpp
+1 -1
View File
@@ -3,7 +3,7 @@
#include "../../../Minecraft.World/Headers/net.minecraft.world.entity.player.h"
#include "../Chunk.h"
DirtyChunkSorter::DirtyChunkSorter(shared_ptr<Mob> cameraEntity, int playerIndex) // 4J - added player index
DirtyChunkSorter::DirtyChunkSorter(std::shared_ptr<Mob> cameraEntity, int playerIndex) // 4J - added player index
{
this->cameraEntity = cameraEntity;
this->playerIndex = playerIndex;
Minecraft.Client/Rendering/Culling/DirtyChunkSorter.h
+2 -2
View File
@@ -5,10 +5,10 @@ class Mob;
class DirtyChunkSorter : public std::binary_function<const Chunk *,const Chunk *,bool>
{
private:
shared_ptr<Mob> cameraEntity;
std::shared_ptr<Mob> cameraEntity;
int playerIndex; // 4J added
public:
DirtyChunkSorter(shared_ptr<Mob> cameraEntity, int playerIndex); // 4J - added player index
DirtyChunkSorter(std::shared_ptr<Mob> cameraEntity, int playerIndex); // 4J - added player index
bool operator()(const Chunk *a, const Chunk *b) const;
};
Minecraft.Client/Rendering/Culling/DistanceChunkSorter.cpp
+1 -1
View File
@@ -3,7 +3,7 @@
#include "../../../Minecraft.World/Headers/net.minecraft.world.entity.player.h"
#include "../Chunk.h"
DistanceChunkSorter::DistanceChunkSorter(shared_ptr<Entity> player)
DistanceChunkSorter::DistanceChunkSorter(std::shared_ptr<Entity> player)
{
ix = -player->x;
iy = -player->y;
Minecraft.Client/Rendering/Culling/DistanceChunkSorter.h
+1 -1
View File
@@ -8,6 +8,6 @@ private:
double ix, iy, iz;
public:
DistanceChunkSorter(shared_ptr<Entity> player);
DistanceChunkSorter(std::shared_ptr<Entity> player);
bool operator()(const Chunk *a, const Chunk *b) const;
};
Minecraft.Client/Rendering/Culling/ViewportCuller.cpp
+1 -1
View File
@@ -49,7 +49,7 @@ bool ViewportCuller::Face::fullyInFront(double x0, double y0, double z0, double
return true;
}
ViewportCuller::ViewportCuller(shared_ptr<Mob> mob, double fogDistance, float a)
ViewportCuller::ViewportCuller(std::shared_ptr<Mob> mob, double fogDistance, float a)
{
float yRot = mob->yRotO+(mob->yRot-mob->yRotO)*a;
float xRot = mob->xRotO+(mob->xRot-mob->xRotO)*a;
Minecraft.Client/Rendering/Culling/ViewportCuller.h
+1 -1
View File
@@ -24,7 +24,7 @@ private:
Face faces[6];
double xOff, yOff, zOff;
public:
ViewportCuller(shared_ptr<Mob> mob, double fogDistance, float a);
ViewportCuller(std::shared_ptr<Mob> mob, double fogDistance, float a);
virtual bool isVisible(AABB bb);
virtual bool cubeInFrustum(double x0, double y0, double z0, double x1, double y1, double z1);
virtual bool cubeFullyInFrustum(double x0, double y0, double z0, double x1, double y1, double z1);
Minecraft.Client/Rendering/EntityRenderers/ArrowRenderer.cpp
+3 -3
View File
@@ -3,11 +3,11 @@
#include "../../../Minecraft.World/Headers/net.minecraft.world.entity.projectile.h"
#include "../../../Minecraft.World/Util/Mth.h"
void ArrowRenderer::render(shared_ptr<Entity> _arrow, double x, double y, double z, float rot, float a)
void ArrowRenderer::render(std::shared_ptr<Entity> _arrow, double x, double y, double z, float rot, float a)
{
// 4J - original version used generics and thus had an input parameter of type Arrow rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type Arrow rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(_arrow);
std::shared_ptr<Arrow> arrow = dynamic_pointer_cast<Arrow>(_arrow);
bindTexture(TN_ITEM_ARROWS); // 4J - was L"/item/arrows.png"
glPushMatrix();
Minecraft.Client/Rendering/EntityRenderers/ArrowRenderer.h
+1 -1
View File
@@ -4,5 +4,5 @@
class ArrowRenderer : public EntityRenderer
{
public:
virtual void render(shared_ptr<Entity> _arrow, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _arrow, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/BlazeRenderer.cpp
+3 -3
View File
@@ -8,11 +8,11 @@ BlazeRenderer::BlazeRenderer() : MobRenderer(new BlazeModel(), 0.5f)
this->modelVersion = ((BlazeModel *) model)->modelVersion();
}
void BlazeRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void BlazeRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
// 4J - original version used generics and thus had an input parameter of type Blaze rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<Blaze> mob = dynamic_pointer_cast<Blaze>(_mob);
std::shared_ptr<Blaze> mob = dynamic_pointer_cast<Blaze>(_mob);
int modelVersion = ((BlazeModel *) model)->modelVersion();
if (modelVersion != this->modelVersion)
Minecraft.Client/Rendering/EntityRenderers/BlazeRenderer.h
+1 -1
View File
@@ -10,5 +10,5 @@ private:
public:
BlazeRenderer();
virtual void render(shared_ptr<Entity> mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> mob, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/BoatRenderer.cpp
+3 -3
View File
@@ -10,11 +10,11 @@ BoatRenderer::BoatRenderer() : EntityRenderer()
model = new BoatModel();
}
void BoatRenderer::render(shared_ptr<Entity> _boat, double x, double y, double z, float rot, float a)
void BoatRenderer::render(std::shared_ptr<Entity> _boat, double x, double y, double z, float rot, float a)
{
// 4J - original version used generics and thus had an input parameter of type Boat rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<Boat> boat = dynamic_pointer_cast<Boat>(_boat);
std::shared_ptr<Boat> boat = dynamic_pointer_cast<Boat>(_boat);
glPushMatrix();
Minecraft.Client/Rendering/EntityRenderers/BoatRenderer.h
+1 -1
View File
@@ -9,5 +9,5 @@ protected:
public:
BoatRenderer();
virtual void render(shared_ptr<Entity> boat, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> boat, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/ChestRenderer.cpp
+2 -2
View File
@@ -18,10 +18,10 @@ ChestRenderer::~ChestRenderer()
delete largeChestModel;
}
void ChestRenderer::render(shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
void ChestRenderer::render(std::shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
{
// 4J Convert as we aren't using a templated class
shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(_chest);
std::shared_ptr<ChestTileEntity> chest = dynamic_pointer_cast<ChestTileEntity>(_chest);
int data;
Minecraft.Client/Rendering/EntityRenderers/ChestRenderer.h
+1 -1
View File
@@ -14,5 +14,5 @@ public:
ChestRenderer();
~ChestRenderer();
void render(shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
void render(std::shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
};
Minecraft.Client/Rendering/EntityRenderers/ChickenRenderer.cpp
+3 -3
View File
@@ -7,15 +7,15 @@ ChickenRenderer::ChickenRenderer(Model *model, float shadow) : MobRenderer(model
{
}
void ChickenRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void ChickenRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
MobRenderer::render(_mob, x, y, z, rot, a);
}
float ChickenRenderer::getBob(shared_ptr<Mob> _mob, float a)
float ChickenRenderer::getBob(std::shared_ptr<Mob> _mob, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Chicken> mob = dynamic_pointer_cast<Chicken>(_mob);
std::shared_ptr<Chicken> mob = dynamic_pointer_cast<Chicken>(_mob);
float flap = mob->oFlap+(mob->flap-mob->oFlap)*a;
float flapSpeed = mob->oFlapSpeed+(mob->flapSpeed-mob->oFlapSpeed)*a;
Minecraft.Client/Rendering/EntityRenderers/ChickenRenderer.h
+2 -2
View File
@@ -5,7 +5,7 @@ class ChickenRenderer : public MobRenderer
{
public:
ChickenRenderer(Model *model, float shadow);
virtual void render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
protected:
virtual float getBob(shared_ptr<Mob> _mob, float a);
virtual float getBob(std::shared_ptr<Mob> _mob, float a);
};
Minecraft.Client/Rendering/EntityRenderers/CowRenderer.cpp
+1 -1
View File
@@ -5,7 +5,7 @@ CowRenderer::CowRenderer(Model *model, float shadow) : MobRenderer(model, shadow
{
}
void CowRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void CowRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
MobRenderer::render(_mob, x, y, z, rot, a);
}
Minecraft.Client/Rendering/EntityRenderers/CowRenderer.h
+1 -1
View File
@@ -5,5 +5,5 @@ class CowRenderer : public MobRenderer
{
public:
CowRenderer(Model *model, float shadow);
virtual void render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/CreeperRenderer.cpp
+7 -7
View File
@@ -9,9 +9,9 @@ CreeperRenderer::CreeperRenderer() : MobRenderer( new CreeperModel(), 0.5f )
armorModel = new CreeperModel(2);
}
void CreeperRenderer::scale(shared_ptr<Mob> mob, float a)
void CreeperRenderer::scale(std::shared_ptr<Mob> mob, float a)
{
shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob);
std::shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob);
float g = creeper->getSwelling(a);
@@ -25,9 +25,9 @@ void CreeperRenderer::scale(shared_ptr<Mob> mob, float a)
glScalef(s, hs, s);
}
int CreeperRenderer::getOverlayColor(shared_ptr<Mob> mob, float br, float a)
int CreeperRenderer::getOverlayColor(std::shared_ptr<Mob> mob, float br, float a)
{
shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob);
std::shared_ptr<Creeper> creeper = dynamic_pointer_cast<Creeper>(mob);
float step = creeper->getSwelling(a);
@@ -44,10 +44,10 @@ int CreeperRenderer::getOverlayColor(shared_ptr<Mob> mob, float br, float a)
return (_a << 24) | (r << 16) | (g << 8) | b;
}
int CreeperRenderer::prepareArmor(shared_ptr<Mob> _mob, int layer, float a)
int CreeperRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Creeper> mob = dynamic_pointer_cast<Creeper>(_mob);
std::shared_ptr<Creeper> mob = dynamic_pointer_cast<Creeper>(_mob);
if (mob->isPowered())
{
if (mob->isInvisible()) glDepthMask(false);
@@ -84,7 +84,7 @@ int CreeperRenderer::prepareArmor(shared_ptr<Mob> _mob, int layer, float a)
}
int CreeperRenderer::prepareArmorOverlay(shared_ptr<Mob> mob, int layer, float a)
int CreeperRenderer::prepareArmorOverlay(std::shared_ptr<Mob> mob, int layer, float a)
{
return -1;
}
Minecraft.Client/Rendering/EntityRenderers/CreeperRenderer.h
+4 -4
View File
@@ -9,8 +9,8 @@ private:
public:
CreeperRenderer();
protected:
virtual void scale(shared_ptr<Mob> _mob, float a);
virtual int getOverlayColor(shared_ptr<Mob> mob, float br, float a);
virtual int prepareArmor(shared_ptr<Mob> mob, int layer, float a);
virtual int prepareArmorOverlay(shared_ptr<Mob> _mob, int layer, float a);
virtual void scale(std::shared_ptr<Mob> _mob, float a);
virtual int getOverlayColor(std::shared_ptr<Mob> mob, float br, float a);
virtual int prepareArmor(std::shared_ptr<Mob> mob, int layer, float a);
virtual int prepareArmorOverlay(std::shared_ptr<Mob> _mob, int layer, float a);
};
Minecraft.Client/Rendering/EntityRenderers/DefaultRenderer.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
#include "DefaultRenderer.h"
#include "../../../Minecraft.World/Headers/net.minecraft.world.entity.h"
void DefaultRenderer::render(shared_ptr<Entity> entity, double x, double y, double z, float rot, float a)
void DefaultRenderer::render(std::shared_ptr<Entity> entity, double x, double y, double z, float rot, float a)
{
glPushMatrix();
// 4J - removed following line as doesn't really make any sense
Minecraft.Client/Rendering/EntityRenderers/DefaultRenderer.h
+1 -1
View File
@@ -4,5 +4,5 @@
class DefaultRenderer : public EntityRenderer
{
public:
virtual void render(shared_ptr<Entity> entity, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> entity, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/EnchantTableRenderer.cpp
+2 -2
View File
@@ -14,10 +14,10 @@ EnchantTableRenderer::~EnchantTableRenderer()
delete bookModel;
}
void EnchantTableRenderer::render(shared_ptr<TileEntity> _table, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
void EnchantTableRenderer::render(std::shared_ptr<TileEntity> _table, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
{
// 4J Convert as we aren't using a templated class
shared_ptr<EnchantmentTableEntity> table = dynamic_pointer_cast<EnchantmentTableEntity>(_table);
std::shared_ptr<EnchantmentTableEntity> table = dynamic_pointer_cast<EnchantmentTableEntity>(_table);
#ifdef __PSVITA__
// AP - the book pages are made with 0 depth so the front and back polys are at the same location. This can cause z-fighting if culling is disabled which can sometimes happen
Minecraft.Client/Rendering/EntityRenderers/EnchantTableRenderer.h
+1 -1
View File
@@ -15,5 +15,5 @@ public:
EnchantTableRenderer();
~EnchantTableRenderer();
virtual void render(shared_ptr<TileEntity> _table, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true);
virtual void render(std::shared_ptr<TileEntity> _table, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true);
};
Minecraft.Client/Rendering/EntityRenderers/EnderChestRenderer.cpp
+2 -2
View File
@@ -3,10 +3,10 @@
#include "../Models/ModelPart.h"
#include "EnderChestRenderer.h"
void EnderChestRenderer::render(shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
void EnderChestRenderer::render(std::shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
{
// 4J Convert as we aren't using a templated class
shared_ptr<EnderChestTileEntity> chest = dynamic_pointer_cast<EnderChestTileEntity>(_chest);
std::shared_ptr<EnderChestTileEntity> chest = dynamic_pointer_cast<EnderChestTileEntity>(_chest);
int data = 0;
Minecraft.Client/Rendering/EntityRenderers/EnderChestRenderer.h
+1 -1
View File
@@ -9,5 +9,5 @@ private:
ChestModel chestModel;
public:
void render(shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
void render(std::shared_ptr<TileEntity> _chest, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
};
Minecraft.Client/Rendering/EntityRenderers/EnderCrystalRenderer.cpp
+3 -3
View File
@@ -9,11 +9,11 @@ EnderCrystalRenderer::EnderCrystalRenderer()
this->shadowRadius = 0.5f;
}
void EnderCrystalRenderer::render(shared_ptr<Entity> _crystal, double x, double y, double z, float rot, float a)
void EnderCrystalRenderer::render(std::shared_ptr<Entity> _crystal, double x, double y, double z, float rot, float a)
{
// 4J - original version used generics and thus had an input parameter of type EnderCrystal rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type EnderCrystal rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<EnderCrystal> crystal = dynamic_pointer_cast<EnderCrystal>(_crystal);
std::shared_ptr<EnderCrystal> crystal = dynamic_pointer_cast<EnderCrystal>(_crystal);
if (currentModel != EnderCrystalModel::MODEL_ID)
{
model = new EnderCrystalModel(0);
Minecraft.Client/Rendering/EntityRenderers/EnderCrystalRenderer.h
+1 -1
View File
@@ -13,5 +13,5 @@ private:
public:
EnderCrystalRenderer();
virtual void render(shared_ptr<Entity> _crystal, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _crystal, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/EnderDragonRenderer.cpp
+11 -11
View File
@@ -5,7 +5,7 @@
#include "../Lighting.h"
#include "EnderDragonRenderer.h"
shared_ptr<EnderDragon> EnderDragonRenderer::bossInstance;
std::shared_ptr<EnderDragon> EnderDragonRenderer::bossInstance;
int EnderDragonRenderer::currentModel;
EnderDragonRenderer::EnderDragonRenderer() : MobRenderer(new DragonModel(0), 0.5f)
@@ -15,10 +15,10 @@ EnderDragonRenderer::EnderDragonRenderer() : MobRenderer(new DragonModel(0), 0.5
this->setArmor(model);
}
void EnderDragonRenderer::setupRotations(shared_ptr<Mob> _mob, float bob, float bodyRot, float a)
void EnderDragonRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
// 4J - reorganised a bit so we can free allocations
double lpComponents[3];
@@ -46,10 +46,10 @@ void EnderDragonRenderer::setupRotations(shared_ptr<Mob> _mob, float bob, float
}
}
void EnderDragonRenderer::renderModel(shared_ptr<Entity> _mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale)
void EnderDragonRenderer::renderModel(std::shared_ptr<Entity> _mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
if (mob->dragonDeathTime > 0)
{
@@ -87,10 +87,10 @@ void EnderDragonRenderer::renderModel(shared_ptr<Entity> _mob, float wp, float w
}
}
void EnderDragonRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void EnderDragonRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
EnderDragonRenderer::bossInstance = mob;
if (currentModel != DragonModel::MODEL_ID)
{
@@ -167,10 +167,10 @@ void EnderDragonRenderer::render(shared_ptr<Entity> _mob, double x, double y, do
}
}
void EnderDragonRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
void EnderDragonRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
MobRenderer::additionalRendering(mob, a);
Tesselator *t = Tesselator::getInstance();
@@ -227,10 +227,10 @@ void EnderDragonRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
}
int EnderDragonRenderer::prepareArmor(shared_ptr<Mob> _mob, int layer, float a)
int EnderDragonRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
std::shared_ptr<EnderDragon> mob = dynamic_pointer_cast<EnderDragon>(_mob);
if (layer == 1)
{
Minecraft.Client/Rendering/EntityRenderers/EnderDragonRenderer.h
+6 -6
View File
@@ -10,7 +10,7 @@ class DragonModel;
class EnderDragonRenderer : public MobRenderer
{
public:
static shared_ptr<EnderDragon> bossInstance;
static std::shared_ptr<EnderDragon> bossInstance;
private:
static int currentModel;
@@ -22,15 +22,15 @@ public:
EnderDragonRenderer();
protected:
virtual void setupRotations(shared_ptr<Mob> _mob, float bob, float bodyRot, float a);
virtual void setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a);
protected:
void renderModel(shared_ptr<Entity> _mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale);
void renderModel(std::shared_ptr<Entity> _mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale);
public:
virtual void render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
protected:
virtual void additionalRendering(shared_ptr<Mob> _mob, float a);
virtual int prepareArmor(shared_ptr<Mob> _mob, int layer, float a);
virtual void additionalRendering(std::shared_ptr<Mob> _mob, float a);
virtual int prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a);
};
Minecraft.Client/Rendering/EntityRenderers/EnderManRenderer.cpp
+9 -9
View File
@@ -10,11 +10,11 @@ EndermanRenderer::EndermanRenderer() : MobRenderer(new EndermanModel(), 0.5f)
this->setArmor(model);
}
void EndermanRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void EndermanRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
// 4J - original version used generics and thus had an input parameter of type Boat rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
model->carrying = mob->getCarryingTile() > 0;
model->creepy = mob->isCreepy();
@@ -29,11 +29,11 @@ void EndermanRenderer::render(shared_ptr<Entity> _mob, double x, double y, doubl
MobRenderer::render(mob, x, y, z, rot, a);
}
void EndermanRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
void EndermanRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
{
// 4J - original version used generics and thus had an input parameter of type Boat rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
MobRenderer::additionalRendering(_mob, a);
@@ -68,11 +68,11 @@ void EndermanRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
}
}
int EndermanRenderer::prepareArmor(shared_ptr<Mob> _mob, int layer, float a)
int EndermanRenderer::prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a)
{
// 4J - original version used generics and thus had an input parameter of type Boat rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type Boat rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
std::shared_ptr<EnderMan> mob = dynamic_pointer_cast<EnderMan>(_mob);
if (layer != 0) return -1;
Minecraft.Client/Rendering/EntityRenderers/EnderManRenderer.h
+3 -3
View File
@@ -14,9 +14,9 @@ private:
public:
EndermanRenderer();
virtual void render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
virtual void additionalRendering(shared_ptr<Mob> _mob, float a);
virtual void render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
virtual void additionalRendering(std::shared_ptr<Mob> _mob, float a);
protected:
virtual int prepareArmor(shared_ptr<Mob> _mob, int layer, float a);
virtual int prepareArmor(std::shared_ptr<Mob> _mob, int layer, float a);
};
Minecraft.Client/Rendering/EntityRenderers/EntityRenderDispatcher.cpp
+5 -5
View File
@@ -168,12 +168,12 @@ EntityRenderer *EntityRenderDispatcher::getRenderer(eINSTANCEOF e)
return it->second;
}
EntityRenderer *EntityRenderDispatcher::getRenderer(shared_ptr<Entity> e)
EntityRenderer *EntityRenderDispatcher::getRenderer(std::shared_ptr<Entity> e)
{
return getRenderer(e->GetType());
}
void EntityRenderDispatcher::prepare(Level *level, Textures *textures, Font *font, shared_ptr<Mob> player, Options *options, float a)
void EntityRenderDispatcher::prepare(Level *level, Textures *textures, Font *font, std::shared_ptr<Mob> player, Options *options, float a)
{
this->level = level;
this->textures = textures;
@@ -197,7 +197,7 @@ void EntityRenderDispatcher::prepare(Level *level, Textures *textures, Font *fon
playerRotX = player->xRotO + (player->xRot - player->xRotO) * a;
}
shared_ptr<Player> pl = dynamic_pointer_cast<Player>(player);
std::shared_ptr<Player> pl = dynamic_pointer_cast<Player>(player);
if (pl->ThirdPersonView() == 2)
{
playerRotY += 180;
@@ -209,7 +209,7 @@ void EntityRenderDispatcher::prepare(Level *level, Textures *textures, Font *fon
}
void EntityRenderDispatcher::render(shared_ptr<Entity> entity, float a)
void EntityRenderDispatcher::render(std::shared_ptr<Entity> entity, float a)
{
double x = entity->xOld + (entity->x - entity->xOld) * a;
double y = entity->yOld + (entity->y - entity->yOld) * a;
@@ -244,7 +244,7 @@ void EntityRenderDispatcher::render(shared_ptr<Entity> entity, float a)
render(entity, x - xOff, y - yOff, z - zOff, r, a);
}
void EntityRenderDispatcher::render(shared_ptr<Entity> entity, double x, double y, double z, float rot, float a, bool bItemFrame, bool bRenderPlayerShadow)
void EntityRenderDispatcher::render(std::shared_ptr<Entity> entity, double x, double y, double z, float rot, float a, bool bItemFrame, bool bRenderPlayerShadow)
{
EntityRenderer *renderer = getRenderer(entity);
if (renderer != NULL)
Minecraft.Client/Rendering/EntityRenderers/EntityRenderDispatcher.h
+5 -5
View File
@@ -26,7 +26,7 @@ public:
Textures *textures;
ItemInHandRenderer *itemInHandRenderer;
Level *level;
shared_ptr<Mob> cameraEntity;
std::shared_ptr<Mob> cameraEntity;
float playerRotY;
float playerRotX;
Options *options;
@@ -38,10 +38,10 @@ private:
EntityRenderDispatcher();
public:
EntityRenderer *getRenderer(eINSTANCEOF e);
EntityRenderer *getRenderer(shared_ptr<Entity> e);
void prepare(Level *level, Textures *textures, Font *font, shared_ptr<Mob> player, Options *options, float a);
void render(shared_ptr<Entity> entity, float a);
void render(shared_ptr<Entity> entity, double x, double y, double z, float rot, float a, bool bItemFrame = false, bool bRenderPlayerShadow = true);
EntityRenderer *getRenderer(std::shared_ptr<Entity> e);
void prepare(Level *level, Textures *textures, Font *font, std::shared_ptr<Mob> player, Options *options, float a);
void render(std::shared_ptr<Entity> entity, float a);
void render(std::shared_ptr<Entity> entity, double x, double y, double z, float rot, float a, bool bItemFrame = false, bool bRenderPlayerShadow = true);
void setLevel(Level *level);
double distanceToSqr(double x, double y, double z);
Font *getFont();
Minecraft.Client/Rendering/EntityRenderers/EntityRenderer.cpp
+6 -6
View File
@@ -78,7 +78,7 @@ bool EntityRenderer::bindTexture(const wstring& urlTexture, const wstring& backu
}
}
void EntityRenderer::renderFlame(shared_ptr<Entity> e, double x, double y, double z, float a)
void EntityRenderer::renderFlame(std::shared_ptr<Entity> e, double x, double y, double z, float a)
{
glDisable(GL_LIGHTING);
@@ -146,7 +146,7 @@ void EntityRenderer::renderFlame(shared_ptr<Entity> e, double x, double y, doubl
glEnable(GL_LIGHTING);
}
void EntityRenderer::renderShadow(shared_ptr<Entity> e, double x, double y, double z, float pow, float a)
void EntityRenderer::renderShadow(std::shared_ptr<Entity> e, double x, double y, double z, float pow, float a)
{
glDisable(GL_LIGHTING);
glEnable(GL_BLEND);
@@ -160,17 +160,17 @@ void EntityRenderer::renderShadow(shared_ptr<Entity> e, double x, double y, doub
glDepthMask(false);
float r = shadowRadius;
shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
bool isLocalPlayer = false;
float fYLocalPlayerShadowOffset=0.0f;
//if (dynamic_pointer_cast<Mob>(e) != NULL)
if (mob != NULL)
{
//shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
//std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
r *= mob->getSizeScale();
shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(mob);
std::shared_ptr<Animal> animal = dynamic_pointer_cast<Animal>(mob);
if (animal != NULL)
{
if (animal->isBaby())
@@ -383,7 +383,7 @@ void EntityRenderer::init(EntityRenderDispatcher *entityRenderDispatcher)
this->entityRenderDispatcher = entityRenderDispatcher;
}
void EntityRenderer::postRender(shared_ptr<Entity> entity, double x, double y, double z, float rot, float a, bool bRenderPlayerShadow)
void EntityRenderer::postRender(std::shared_ptr<Entity> entity, double x, double y, double z, float rot, float a, bool bRenderPlayerShadow)
{
if( !entityRenderDispatcher->isGuiRender ) // 4J - added, don't render shadow in gui as it uses its own blending, and we have globally enabled blending for interface opacity
{
Minecraft.Client/Rendering/EntityRenderers/EntityRenderer.h
+4 -4
View File
@@ -36,7 +36,7 @@ public:
EntityRenderer(); // 4J - added
virtual ~EntityRenderer();
public:
virtual void render(shared_ptr<Entity> entity, double x, double y, double z, float rot, float a) = 0;
virtual void render(std::shared_ptr<Entity> entity, double x, double y, double z, float rot, float a) = 0;
protected:
virtual void bindTexture(int resourceName); // 4J - added
virtual void bindTexture(const wstring& resourceName);
@@ -44,8 +44,8 @@ protected:
virtual bool bindTexture(const wstring& urlTexture, int backupTexture); // 4J added
virtual bool bindTexture(const wstring& urlTexture, const wstring& backupTexture);
private:
virtual void renderFlame(shared_ptr<Entity> e, double x, double y, double z, float a);
virtual void renderShadow(shared_ptr<Entity> e, double x, double y, double z, float pow, float a);
virtual void renderFlame(std::shared_ptr<Entity> e, double x, double y, double z, float a);
virtual void renderShadow(std::shared_ptr<Entity> e, double x, double y, double z, float pow, float a);
virtual Level *getLevel();
virtual void renderTileShadow(Tile *tt, double x, double y, double z, int xt, int yt, int zt, float pow, float r, double xo, double yo, double zo);
@@ -54,7 +54,7 @@ public:
static void renderFlat(AABB *bb);
static void renderFlat(float x0, float y0, float z0, float x1, float y1, float z1);
virtual void init(EntityRenderDispatcher *entityRenderDispatcher);
virtual void postRender(shared_ptr<Entity> entity, double x, double y, double z, float rot, float a, bool bRenderPlayerShadow);
virtual void postRender(std::shared_ptr<Entity> entity, double x, double y, double z, float rot, float a, bool bRenderPlayerShadow);
virtual Font *getFont();
virtual void registerTerrainTextures(IconRegister *iconRegister);
Minecraft.Client/Rendering/EntityRenderers/EntityTileRenderer.cpp
+2 -2
View File
@@ -7,8 +7,8 @@ EntityTileRenderer *EntityTileRenderer::instance = new EntityTileRenderer;
EntityTileRenderer::EntityTileRenderer()
{
chest = shared_ptr<ChestTileEntity>(new ChestTileEntity());
enderChest = shared_ptr<EnderChestTileEntity>(new EnderChestTileEntity());
chest = std::shared_ptr<ChestTileEntity>(new ChestTileEntity());
enderChest = std::shared_ptr<EnderChestTileEntity>(new EnderChestTileEntity());
}
void EntityTileRenderer::render(Tile *tile, int data, float brightness, float alpha, bool setColor, bool useCompiled)
Minecraft.Client/Rendering/EntityRenderers/EntityTileRenderer.h
+2 -2
View File
@@ -10,8 +10,8 @@ class EntityTileRenderer
static EntityTileRenderer *instance;
private:
shared_ptr<ChestTileEntity> chest;
shared_ptr<EnderChestTileEntity> enderChest;
std::shared_ptr<ChestTileEntity> chest;
std::shared_ptr<EnderChestTileEntity> enderChest;
public:
EntityTileRenderer();
Minecraft.Client/Rendering/EntityRenderers/ExperienceOrbRenderer.cpp
+2 -2
View File
@@ -19,9 +19,9 @@ ExperienceOrbRenderer::ExperienceOrbRenderer()
}
void ExperienceOrbRenderer::render(shared_ptr<Entity> _orb, double x, double y, double z, float rot, float a)
void ExperienceOrbRenderer::render(std::shared_ptr<Entity> _orb, double x, double y, double z, float rot, float a)
{
shared_ptr<ExperienceOrb> orb = dynamic_pointer_cast<ExperienceOrb>(_orb);
std::shared_ptr<ExperienceOrb> orb = dynamic_pointer_cast<ExperienceOrb>(_orb);
glPushMatrix();
glTranslatef((float) x, (float) y, (float) z);
Minecraft.Client/Rendering/EntityRenderers/ExperienceOrbRenderer.h
+1 -1
View File
@@ -12,6 +12,6 @@ public:
ExperienceOrbRenderer();
void render(shared_ptr<Entity> _orb, double x, double y, double z, float rot, float a);
void render(std::shared_ptr<Entity> _orb, double x, double y, double z, float rot, float a);
void blit(int x, int y, int sx, int sy, int w, int h);
};
Minecraft.Client/Rendering/EntityRenderers/FallingTileRenderer.cpp
+2 -2
View File
@@ -12,10 +12,10 @@ FallingTileRenderer::FallingTileRenderer() : EntityRenderer()
this->shadowRadius = 0.5f;
}
void FallingTileRenderer::render(shared_ptr<Entity> _tile, double x, double y, double z, float rot, float a)
void FallingTileRenderer::render(std::shared_ptr<Entity> _tile, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<FallingTile> tile = dynamic_pointer_cast<FallingTile>(_tile);
std::shared_ptr<FallingTile> tile = dynamic_pointer_cast<FallingTile>(_tile);
glPushMatrix();
glTranslatef((float) x, (float) y, (float) z);
Minecraft.Client/Rendering/EntityRenderers/FallingTileRenderer.h
+1 -1
View File
@@ -10,5 +10,5 @@ private:
public:
FallingTileRenderer();
virtual void render(shared_ptr<Entity> _tile, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _tile, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/FireballRenderer.cpp
+3 -3
View File
@@ -12,10 +12,10 @@ FireballRenderer::FireballRenderer(float scale)
this->scale = scale;
}
void FireballRenderer::render(shared_ptr<Entity> _fireball, double x, double y, double z, float rot, float a)
void FireballRenderer::render(std::shared_ptr<Entity> _fireball, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Fireball> fireball = dynamic_pointer_cast<Fireball>(_fireball);
std::shared_ptr<Fireball> fireball = dynamic_pointer_cast<Fireball>(_fireball);
glPushMatrix();
@@ -54,7 +54,7 @@ void FireballRenderer::render(shared_ptr<Entity> _fireball, double x, double y,
}
// 4J Added override. Based on EntityRenderer::renderFlame
void FireballRenderer::renderFlame(shared_ptr<Entity> e, double x, double y, double z, float a)
void FireballRenderer::renderFlame(std::shared_ptr<Entity> e, double x, double y, double z, float a)
{
glDisable(GL_LIGHTING);
Icon *tex = Tile::fire->getTextureLayer(0);
Minecraft.Client/Rendering/EntityRenderers/FireballRenderer.h
+2 -2
View File
@@ -9,9 +9,9 @@ private:
public:
FireballRenderer(float scale);
virtual void render(shared_ptr<Entity> _fireball, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _fireball, double x, double y, double z, float rot, float a);
private:
// 4J Added override
virtual void renderFlame(shared_ptr<Entity> e, double x, double y, double z, float a);
virtual void renderFlame(std::shared_ptr<Entity> e, double x, double y, double z, float a);
};
Minecraft.Client/Rendering/EntityRenderers/FishingHookRenderer.cpp
+2 -2
View File
@@ -8,10 +8,10 @@
#include "../../../Minecraft.World/Util/Mth.h"
#include "../../Player/MultiPlayerLocalPlayer.h"
void FishingHookRenderer::render(shared_ptr<Entity> _hook, double x, double y, double z, float rot, float a)
void FishingHookRenderer::render(std::shared_ptr<Entity> _hook, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<FishingHook> hook = dynamic_pointer_cast<FishingHook>(_hook);
std::shared_ptr<FishingHook> hook = dynamic_pointer_cast<FishingHook>(_hook);
glPushMatrix();
Minecraft.Client/Rendering/EntityRenderers/FishingHookRenderer.h
+1 -1
View File
@@ -4,5 +4,5 @@
class FishingHookRenderer : public EntityRenderer
{
public:
virtual void render(shared_ptr<Entity> _hook, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _hook, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/GhastRenderer.cpp
+2 -2
View File
@@ -7,9 +7,9 @@ GhastRenderer::GhastRenderer() : MobRenderer(new GhastModel(), 0.5f)
{
}
void GhastRenderer::scale(shared_ptr<Mob> mob, float a)
void GhastRenderer::scale(std::shared_ptr<Mob> mob, float a)
{
shared_ptr<Ghast> ghast = dynamic_pointer_cast<Ghast>(mob);
std::shared_ptr<Ghast> ghast = dynamic_pointer_cast<Ghast>(mob);
float ss = (ghast->oCharge+(ghast->charge-ghast->oCharge)*a)/20.0f;
if (ss<0) ss = 0;
Minecraft.Client/Rendering/EntityRenderers/GhastRenderer.h
+1 -1
View File
@@ -7,5 +7,5 @@ public:
GhastRenderer();
protected:
virtual void scale(shared_ptr<Mob> mob, float a);
virtual void scale(std::shared_ptr<Mob> mob, float a);
};
Minecraft.Client/Rendering/EntityRenderers/GiantMobRenderer.cpp
+1 -1
View File
@@ -6,7 +6,7 @@ GiantMobRenderer::GiantMobRenderer(Model *model, float shadow, float _scale) : M
this->_scale = _scale;
}
void GiantMobRenderer::scale(shared_ptr<Mob> mob, float a)
void GiantMobRenderer::scale(std::shared_ptr<Mob> mob, float a)
{
glScalef(_scale, _scale, _scale);
}
Minecraft.Client/Rendering/EntityRenderers/GiantMobRenderer.h
+1 -1
View File
@@ -10,5 +10,5 @@ public:
GiantMobRenderer(Model *model, float shadow, float scale);
protected:
virtual void scale(shared_ptr<Mob> mob, float a);
virtual void scale(std::shared_ptr<Mob> mob, float a);
};
Minecraft.Client/Rendering/EntityRenderers/HumanoidMobRenderer.cpp
+4 -4
View File
@@ -36,12 +36,12 @@ void HumanoidMobRenderer::createArmorParts()
armorParts2 = new HumanoidModel(0.5f);
}
void HumanoidMobRenderer::additionalRendering(shared_ptr<Mob> mob, float a)
void HumanoidMobRenderer::additionalRendering(std::shared_ptr<Mob> mob, float a)
{
float brightness = SharedConstants::TEXTURE_LIGHTING ? 1 : mob->getBrightness(a);
glColor3f(brightness, brightness, brightness);
shared_ptr<ItemInstance> item = mob->getCarriedItem();
shared_ptr<ItemInstance> headGear = mob->getArmor(3);
std::shared_ptr<ItemInstance> item = mob->getCarriedItem();
std::shared_ptr<ItemInstance> headGear = mob->getArmor(3);
if (headGear != NULL)
{
@@ -144,7 +144,7 @@ void HumanoidMobRenderer::additionalRendering(shared_ptr<Mob> mob, float a)
}
void HumanoidMobRenderer::scale(shared_ptr<Mob> mob, float a)
void HumanoidMobRenderer::scale(std::shared_ptr<Mob> mob, float a)
{
glScalef(_scale, _scale, _scale);
}
Minecraft.Client/Rendering/EntityRenderers/HumanoidMobRenderer.h
+2 -2
View File
@@ -17,6 +17,6 @@ public:
HumanoidMobRenderer(HumanoidModel *humanoidModel, float shadow, float scale);
protected:
virtual void createArmorParts();
virtual void additionalRendering(shared_ptr<Mob> mob, float a);
void scale(shared_ptr<Mob> mob, float a);
virtual void additionalRendering(std::shared_ptr<Mob> mob, float a);
void scale(std::shared_ptr<Mob> mob, float a);
};
Minecraft.Client/Rendering/EntityRenderers/ItemFrameRenderer.cpp
+8 -8
View File
@@ -23,11 +23,11 @@ void ItemFrameRenderer::registerTerrainTextures(IconRegister *iconRegister)
backTexture = iconRegister->registerIcon(L"itemframe_back");
}
void ItemFrameRenderer::render(shared_ptr<Entity> _itemframe, double x, double y, double z, float rot, float a)
void ItemFrameRenderer::render(std::shared_ptr<Entity> _itemframe, double x, double y, double z, float rot, float a)
{
// 4J - original version used generics and thus had an input parameter of type EnderCrystal rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type EnderCrystal rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<ItemFrame> itemFrame = dynamic_pointer_cast<ItemFrame>(_itemframe);
std::shared_ptr<ItemFrame> itemFrame = dynamic_pointer_cast<ItemFrame>(_itemframe);
glPushMatrix();
float xOffs = (float) (itemFrame->x - x) - 0.5f;
@@ -47,7 +47,7 @@ void ItemFrameRenderer::render(shared_ptr<Entity> _itemframe, double x, double
}
void ItemFrameRenderer::drawFrame(shared_ptr<ItemFrame> itemFrame)
void ItemFrameRenderer::drawFrame(std::shared_ptr<ItemFrame> itemFrame)
{
Minecraft *pMinecraft=Minecraft::GetInstance();
@@ -102,14 +102,14 @@ void ItemFrameRenderer::drawFrame(shared_ptr<ItemFrame> itemFrame)
glPopMatrix();
}
void ItemFrameRenderer::drawItem(shared_ptr<ItemFrame> entity)
void ItemFrameRenderer::drawItem(std::shared_ptr<ItemFrame> entity)
{
Minecraft *pMinecraft=Minecraft::GetInstance();
shared_ptr<ItemInstance> instance = entity->getItem();
std::shared_ptr<ItemInstance> instance = entity->getItem();
if (instance == NULL) return;
shared_ptr<ItemEntity> itemEntity = shared_ptr<ItemEntity>(new ItemEntity(entity->level, 0, 0, 0, instance));
std::shared_ptr<ItemEntity> itemEntity = std::shared_ptr<ItemEntity>(new ItemEntity(entity->level, 0, 0, 0, instance));
itemEntity->getItem()->count = 1;
itemEntity->bobOffs = 0;
@@ -150,7 +150,7 @@ void ItemFrameRenderer::drawItem(shared_ptr<ItemFrame> entity)
t->vertexUV(0 - vo, 0 - vo, 0, 0, 0);
t->end();
shared_ptr<MapItemSavedData> data = Item::map->getSavedData(itemEntity->getItem(), entity->level);
std::shared_ptr<MapItemSavedData> data = Item::map->getSavedData(itemEntity->getItem(), entity->level);
if (data != NULL)
{
entityRenderDispatcher->itemInHandRenderer->minimap->render(nullptr, entityRenderDispatcher->textures, data, entity->entityId);
Minecraft.Client/Rendering/EntityRenderers/ItemFrameRenderer.h
+3 -3
View File
@@ -9,9 +9,9 @@ private:
//@Override
public:
void registerTerrainTextures(IconRegister *iconRegister);
virtual void render(shared_ptr<Entity> _itemframe, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _itemframe, double x, double y, double z, float rot, float a);
private:
void drawFrame(shared_ptr<ItemFrame> itemFrame);
void drawItem(shared_ptr<ItemFrame> entity);
void drawFrame(std::shared_ptr<ItemFrame> itemFrame);
void drawItem(std::shared_ptr<ItemFrame> entity);
};
Minecraft.Client/Rendering/EntityRenderers/ItemInHandRenderer.cpp
+9 -9
View File
@@ -158,7 +158,7 @@ ItemInHandRenderer::ItemInHandRenderer(Minecraft *mc, bool optimisedMinimap)
}
void ItemInHandRenderer::renderItem(shared_ptr<Mob> mob, shared_ptr<ItemInstance> item, int layer, bool setColor/* = true*/)
void ItemInHandRenderer::renderItem(std::shared_ptr<Mob> mob, std::shared_ptr<ItemInstance> item, int layer, bool setColor/* = true*/)
{
// 4J - code borrowed from render method below, although not factoring in brightness as that should already be being taken into account
// by texture lighting. This is for colourising things held in 3rd person view.
@@ -312,14 +312,14 @@ void ItemInHandRenderer::renderItem3D(Tesselator *t, float u0, float v0, float u
void ItemInHandRenderer::render(float a)
{
float h = oHeight + (height - oHeight) * a;
shared_ptr<Player> player = mc->player;
std::shared_ptr<Player> player = mc->player;
// 4J - added so we can adjust the position of the hands for horizontal & vertical split screens
float fudgeX = 0.0f;
float fudgeY = 0.0f;
float fudgeZ = 0.0f;
bool splitHoriz = false;
shared_ptr<LocalPlayer> localPlayer = dynamic_pointer_cast<LocalPlayer>(player);
std::shared_ptr<LocalPlayer> localPlayer = dynamic_pointer_cast<LocalPlayer>(player);
if( localPlayer )
{
if( localPlayer->m_iScreenSection == C4JRender::VIEWPORT_TYPE_SPLIT_BOTTOM ||
@@ -353,7 +353,7 @@ void ItemInHandRenderer::render(float a)
glRotatef((yr - yrr) * 0.1f, 0, 1, 0);
}
shared_ptr<ItemInstance> item = selectedItem;
std::shared_ptr<ItemInstance> item = selectedItem;
float br = mc->level->getBrightness(Mth::floor(player->x), Mth::floor(player->y), Mth::floor(player->z));
// 4J - change brought forward from 1.8.2
@@ -433,7 +433,7 @@ void ItemInHandRenderer::render(float a)
glScalef(ss, ss, ss);
// Can't turn off the hand if the player is holding a map
shared_ptr<ItemInstance> itemInstance = player->inventory->getSelected();
std::shared_ptr<ItemInstance> itemInstance = player->inventory->getSelected();
if ((itemInstance && (itemInstance->getItem()->id==Item::map_Id)) || app.GetGameSettings(localPlayer->GetXboxPad(),eGameSetting_DisplayHand)!=0 )
{
playerRenderer->renderHand();
@@ -477,7 +477,7 @@ void ItemInHandRenderer::render(float a)
t->vertexUV((float)(0 - vo), (float)( 0 - vo), (float)( 0), (float)( 0), (float)( 0));
t->end();
shared_ptr<MapItemSavedData> data = Item::map->getSavedData(item, mc->level);
std::shared_ptr<MapItemSavedData> data = Item::map->getSavedData(item, mc->level);
PIXBeginNamedEvent(0,"Minimap render");
if(data != NULL) minimap->render(mc->player, mc->textures, data, mc->player->entityId);
PIXEndNamedEvent();
@@ -652,7 +652,7 @@ void ItemInHandRenderer::render(float a)
glScalef(ss, ss, ss);
MemSect(31);
// Can't turn off the hand if the player is holding a map
shared_ptr<ItemInstance> itemInstance = player->inventory->getSelected();
std::shared_ptr<ItemInstance> itemInstance = player->inventory->getSelected();
if ( (itemInstance && (itemInstance->getItem()->id==Item::map_Id)) || app.GetGameSettings(localPlayer->GetXboxPad(),eGameSetting_DisplayHand)!=0 )
{
@@ -837,8 +837,8 @@ void ItemInHandRenderer::tick()
oHeight = height;
shared_ptr<Player> player = mc->player;
shared_ptr<ItemInstance> nextTile = player->inventory->getSelected();
std::shared_ptr<Player> player = mc->player;
std::shared_ptr<ItemInstance> nextTile = player->inventory->getSelected();
bool matches = lastSlot == player->inventory->selected && nextTile == selectedItem;
if (selectedItem == NULL && nextTile == NULL)
Minecraft.Client/Rendering/EntityRenderers/ItemInHandRenderer.h
+2 -2
View File
@@ -11,7 +11,7 @@ class ItemInHandRenderer
{
private:
Minecraft *mc;
shared_ptr<ItemInstance> selectedItem;
std::shared_ptr<ItemInstance> selectedItem;
float height;
float oHeight;
TileRenderer *tileRenderer;
@@ -23,7 +23,7 @@ public:
public:
ItemInHandRenderer(Minecraft *mc, bool optimisedMinimap = true); // 4J Added optimisedMinimap param
void renderItem(shared_ptr<Mob> mob, shared_ptr<ItemInstance> item, int layer, bool setColor = true); // 4J added setColor parameter
void renderItem(std::shared_ptr<Mob> mob, std::shared_ptr<ItemInstance> item, int layer, bool setColor = true); // 4J added setColor parameter
static void renderItem3D(Tesselator *t, float u0, float v0, float u1, float v1, int width, int height, float depth, bool isGlint); // 4J added isGlint parameter
public:
void render(float a);
Minecraft.Client/Rendering/EntityRenderers/ItemRenderer.cpp
+13 -13
View File
@@ -29,13 +29,13 @@ ItemRenderer::~ItemRenderer()
delete random;
}
void ItemRenderer::render(shared_ptr<Entity> _itemEntity, double x, double y, double z, float rot, float a)
void ItemRenderer::render(std::shared_ptr<Entity> _itemEntity, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<ItemEntity> itemEntity = dynamic_pointer_cast<ItemEntity>(_itemEntity);
std::shared_ptr<ItemEntity> itemEntity = dynamic_pointer_cast<ItemEntity>(_itemEntity);
random->setSeed(187);
shared_ptr<ItemInstance> item = itemEntity->getItem();
std::shared_ptr<ItemInstance> item = itemEntity->getItem();
glPushMatrix();
float bob = Mth::sin((itemEntity->age + a) / 10.0f + itemEntity->bobOffs) * 0.1f + 0.1f;
@@ -172,7 +172,7 @@ void ItemRenderer::render(shared_ptr<Entity> _itemEntity, double x, double y, do
}
}
void ItemRenderer::renderItemBillboard(shared_ptr<ItemEntity> entity, Icon *icon, int count, float a, float red, float green, float blue)
void ItemRenderer::renderItemBillboard(std::shared_ptr<ItemEntity> entity, Icon *icon, int count, float a, float red, float green, float blue)
{
Tesselator *t = Tesselator::getInstance();
@@ -213,7 +213,7 @@ void ItemRenderer::renderItemBillboard(shared_ptr<ItemEntity> entity, Icon *icon
float width = 1 / 16.0f;
float margin = 0.35f / 16.0f;
shared_ptr<ItemInstance> item = entity->getItem();
std::shared_ptr<ItemInstance> item = entity->getItem();
int items = item->count;
if (items < 2)
@@ -315,7 +315,7 @@ void ItemRenderer::renderItemBillboard(shared_ptr<ItemEntity> entity, Icon *icon
}
}
void ItemRenderer::renderGuiItem(Font *font, Textures *textures, shared_ptr<ItemInstance> item, float x, float y, float fScale, float fAlpha)
void ItemRenderer::renderGuiItem(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, float x, float y, float fScale, float fAlpha)
{
renderGuiItem(font,textures,item,x,y,fScale,fScale,fAlpha, true);
}
@@ -325,7 +325,7 @@ extern IDirect3DDevice9 *g_pD3DDevice;
#endif
// 4J - this used to take x and y as ints, and no scale and alpha - but this interface is now implemented as a wrapper round this more fully featured one
void ItemRenderer::renderGuiItem(Font *font, Textures *textures, shared_ptr<ItemInstance> item, float x, float y, float fScaleX,float fScaleY, float fAlpha, bool useCompiled)
void ItemRenderer::renderGuiItem(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, float x, float y, float fScaleX,float fScaleY, float fAlpha, bool useCompiled)
{
int itemId = item->id;
int itemAuxValue = item->getAuxValue();
@@ -447,13 +447,13 @@ void ItemRenderer::renderGuiItem(Font *font, Textures *textures, shared_ptr<Item
}
// 4J - original interface, now just a wrapper for preceding overload
void ItemRenderer::renderGuiItem(Font *font, Textures *textures, shared_ptr<ItemInstance> item, int x, int y)
void ItemRenderer::renderGuiItem(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, int x, int y)
{
renderGuiItem(font, textures, item, (float)x, (float)y, 1.0f, 1.0f );
}
// 4J - this used to take x and y as ints, and no scale, alpha or foil - but this interface is now implemented as a wrapper round this more fully featured one
void ItemRenderer::renderAndDecorateItem(Font *font, Textures *textures, const shared_ptr<ItemInstance> item, float x, float y,float fScale,float fAlpha, bool isFoil)
void ItemRenderer::renderAndDecorateItem(Font *font, Textures *textures, const std::shared_ptr<ItemInstance> item, float x, float y,float fScale,float fAlpha, bool isFoil)
{
if(item==NULL) return;
renderAndDecorateItem(font, textures, item, x, y,fScale, fScale, fAlpha, isFoil, true);
@@ -461,7 +461,7 @@ void ItemRenderer::renderAndDecorateItem(Font *font, Textures *textures, const s
// 4J - added isConstantBlended and blendFactor parameters. This is true if the gui item is being rendered from a context where it already has blending enabled to do general interface fading
// (ie from the gui rather than xui). In this case we dno't want to enable/disable blending, and do need to restore the blend state when we are done.
void ItemRenderer::renderAndDecorateItem(Font *font, Textures *textures, const shared_ptr<ItemInstance> item, float x, float y,float fScaleX, float fScaleY,float fAlpha, bool isFoil, bool isConstantBlended, bool useCompiled)
void ItemRenderer::renderAndDecorateItem(Font *font, Textures *textures, const std::shared_ptr<ItemInstance> item, float x, float y,float fScaleX, float fScaleY,float fAlpha, bool isFoil, bool isConstantBlended, bool useCompiled)
{
if (item == NULL)
{
@@ -507,7 +507,7 @@ void ItemRenderer::renderAndDecorateItem(Font *font, Textures *textures, const s
}
// 4J - original interface, now just a wrapper for preceding overload
void ItemRenderer::renderAndDecorateItem(Font *font, Textures *textures, const shared_ptr<ItemInstance> item, int x, int y)
void ItemRenderer::renderAndDecorateItem(Font *font, Textures *textures, const std::shared_ptr<ItemInstance> item, int x, int y)
{
renderAndDecorateItem( font, textures, item, (float)x, (float)y, 1.0f, 1.0f, item->isFoil() );
}
@@ -560,12 +560,12 @@ void ItemRenderer::blitGlint(int id, float x, float y, float w, float h)
}
}
void ItemRenderer::renderGuiItemDecorations(Font *font, Textures *textures, shared_ptr<ItemInstance> item, int x, int y, float fAlpha)
void ItemRenderer::renderGuiItemDecorations(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, int x, int y, float fAlpha)
{
renderGuiItemDecorations(font, textures, item, x, y, L"", fAlpha);
}
void ItemRenderer::renderGuiItemDecorations(Font *font, Textures *textures, shared_ptr<ItemInstance> item, int x, int y, const wstring &countText, float fAlpha)
void ItemRenderer::renderGuiItemDecorations(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, int x, int y, const wstring &countText, float fAlpha)
{
if (item == NULL)
{
Minecraft.Client/Rendering/EntityRenderers/ItemRenderer.h
+10 -10
View File
@@ -18,20 +18,20 @@ public:
ItemRenderer();
virtual ~ItemRenderer();
virtual void render(shared_ptr<Entity> _itemEntity, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _itemEntity, double x, double y, double z, float rot, float a);
private:
virtual void renderItemBillboard(shared_ptr<ItemEntity> entity, Icon *icon, int count, float a, float red, float green, float blue);
virtual void renderItemBillboard(std::shared_ptr<ItemEntity> entity, Icon *icon, int count, float a, float red, float green, float blue);
public:
// 4J - original 2 interface variants
void renderGuiItem(Font *font, Textures *textures, shared_ptr<ItemInstance> item, int x, int y);
void renderAndDecorateItem(Font *font, Textures *textures, const shared_ptr<ItemInstance> item, int x, int y);
void renderGuiItem(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, int x, int y);
void renderAndDecorateItem(Font *font, Textures *textures, const std::shared_ptr<ItemInstance> item, int x, int y);
// 4J - new interfaces added
void renderGuiItem(Font *font, Textures *textures, shared_ptr<ItemInstance> item, float x, float y, float fScale, float fAlpha);
void renderGuiItem(Font *font, Textures *textures, shared_ptr<ItemInstance> item, float x, float y, float fScaleX,float fScaleY, float fAlpha, bool useCompiled); // 4J Added useCompiled
void renderAndDecorateItem(Font *font, Textures *textures, const shared_ptr<ItemInstance> item, float x, float y, float fScale, float fAlpha, bool isFoil);
void renderAndDecorateItem(Font *font, Textures *textures, const shared_ptr<ItemInstance> item, float x, float y, float fScaleX, float fScaleY, float fAlpha, bool isFoil, bool isConstantBlended, bool useCompiled = true); // 4J - added isConstantBlended and useCompiled
void renderGuiItem(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, float x, float y, float fScale, float fAlpha);
void renderGuiItem(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, float x, float y, float fScaleX,float fScaleY, float fAlpha, bool useCompiled); // 4J Added useCompiled
void renderAndDecorateItem(Font *font, Textures *textures, const std::shared_ptr<ItemInstance> item, float x, float y, float fScale, float fAlpha, bool isFoil);
void renderAndDecorateItem(Font *font, Textures *textures, const std::shared_ptr<ItemInstance> item, float x, float y, float fScaleX, float fScaleY, float fAlpha, bool isFoil, bool isConstantBlended, bool useCompiled = true); // 4J - added isConstantBlended and useCompiled
// 4J Added
virtual void SetItemFrame(bool bSet) {m_bItemFrame=bSet;}
@@ -42,8 +42,8 @@ private:
void blitGlint(int id, float x, float y, float w, float h); // 4J - changed x,y,w,h to floats
public:
void renderGuiItemDecorations(Font *font, Textures *textures, shared_ptr<ItemInstance> item, int x, int y, float fAlpha = 1.0f);
void renderGuiItemDecorations(Font *font, Textures *textures, shared_ptr<ItemInstance> item, int x, int y, const wstring &countText, float fAlpha = 1.0f);
void renderGuiItemDecorations(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, int x, int y, float fAlpha = 1.0f);
void renderGuiItemDecorations(Font *font, Textures *textures, std::shared_ptr<ItemInstance> item, int x, int y, const wstring &countText, float fAlpha = 1.0f);
private:
void fillRect(Tesselator *t, int x, int y, int w, int h, int c);
public:
Minecraft.Client/Rendering/EntityRenderers/ItemSpriteRenderer.cpp
+1 -1
View File
@@ -17,7 +17,7 @@ ItemSpriteRenderer::ItemSpriteRenderer(Item *sourceItem, int sourceItemAuxValue
// this(sourceItem, 0);
//}
void ItemSpriteRenderer::render(shared_ptr<Entity> e, double x, double y, double z, float rot, float a)
void ItemSpriteRenderer::render(std::shared_ptr<Entity> e, double x, double y, double z, float rot, float a)
{
// the icon is already cached in the item object, so there should not be any performance impact by not caching it here
Icon *icon = sourceItem->getIcon(sourceItemAuxValue);
Minecraft.Client/Rendering/EntityRenderers/ItemSpriteRenderer.h
+1 -1
View File
@@ -11,7 +11,7 @@ private:
public:
ItemSpriteRenderer(Item *sourceItem, int sourceItemAuxValue = 0);
//ItemSpriteRenderer(Item *icon);
virtual void render(shared_ptr<Entity> e, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> e, double x, double y, double z, float rot, float a);
private:
void renderIcon(Tesselator *t, Icon *icon);
Minecraft.Client/Rendering/EntityRenderers/LavaSlimeRenderer.cpp
+6 -6
View File
@@ -8,11 +8,11 @@ LavaSlimeRenderer::LavaSlimeRenderer() : MobRenderer(new LavaSlimeModel(), .25f)
this->modelVersion = ((LavaSlimeModel *) model)->getModelVersion();
}
void LavaSlimeRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void LavaSlimeRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
// 4J - original version used generics and thus had an input parameter of type LavaSlime rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type LavaSlime rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<LavaSlime> mob = dynamic_pointer_cast<LavaSlime>(_mob);
std::shared_ptr<LavaSlime> mob = dynamic_pointer_cast<LavaSlime>(_mob);
int modelVersion = ((LavaSlimeModel *) model)->getModelVersion();
if (modelVersion != this->modelVersion)
{
@@ -23,11 +23,11 @@ void LavaSlimeRenderer::render(shared_ptr<Entity> _mob, double x, double y, doub
MobRenderer::render(mob, x, y, z, rot, a);
}
void LavaSlimeRenderer::scale(shared_ptr<Mob> _slime, float a)
void LavaSlimeRenderer::scale(std::shared_ptr<Mob> _slime, float a)
{
// 4J - original version used generics and thus had an input parameter of type LavaSlime rather than shared_ptr<Mob> we have here -
// 4J - original version used generics and thus had an input parameter of type LavaSlime rather than std::shared_ptr<Mob> we have here -
// do some casting around instead
shared_ptr<LavaSlime> slime = dynamic_pointer_cast<LavaSlime>(_slime);
std::shared_ptr<LavaSlime> slime = dynamic_pointer_cast<LavaSlime>(_slime);
int size = slime->getSize();
float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1);
float w = 1 / (ss + 1);
Minecraft.Client/Rendering/EntityRenderers/LavaSlimeRenderer.h
+2 -2
View File
@@ -10,8 +10,8 @@ private:
public:
LavaSlimeRenderer();
virtual void render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
protected:
virtual void scale(shared_ptr<Mob> _slime, float a);
virtual void scale(std::shared_ptr<Mob> _slime, float a);
};
Minecraft.Client/Rendering/EntityRenderers/LightningBoltRenderer.cpp
+2 -2
View File
@@ -3,10 +3,10 @@
#include "../Tesselator.h"
#include "../../../Minecraft.World/Headers/net.minecraft.world.entity.global.h"
void LightningBoltRenderer::render(shared_ptr<Entity> _bolt, double x, double y, double z, float rot, float a)
void LightningBoltRenderer::render(std::shared_ptr<Entity> _bolt, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<LightningBolt> bolt = dynamic_pointer_cast<LightningBolt>(_bolt);
std::shared_ptr<LightningBolt> bolt = dynamic_pointer_cast<LightningBolt>(_bolt);
Tesselator *t = Tesselator::getInstance();
Minecraft.Client/Rendering/EntityRenderers/LightningBoltRenderer.h
+1 -1
View File
@@ -4,5 +4,5 @@
class LightningBoltRenderer : public EntityRenderer
{
public:
virtual void render(shared_ptr<Entity> bolt, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> bolt, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/MinecartRenderer.cpp
+2 -2
View File
@@ -10,10 +10,10 @@ MinecartRenderer::MinecartRenderer()
model = new MinecartModel();
}
void MinecartRenderer::render(shared_ptr<Entity> _cart, double x, double y, double z, float rot, float a)
void MinecartRenderer::render(std::shared_ptr<Entity> _cart, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Minecart> cart = dynamic_pointer_cast<Minecart>(_cart);
std::shared_ptr<Minecart> cart = dynamic_pointer_cast<Minecart>(_cart);
glPushMatrix();
Minecraft.Client/Rendering/EntityRenderers/MinecartRenderer.h
+1 -1
View File
@@ -8,5 +8,5 @@ protected:
public:
MinecartRenderer();
void render(shared_ptr<Entity> _cart, double x, double y, double z, float rot, float a);
void render(std::shared_ptr<Entity> _cart, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/MobRenderer.cpp
+19 -19
View File
@@ -31,11 +31,11 @@ float MobRenderer::rotlerp(float from, float to, float a)
return from + a * diff;
}
void MobRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void MobRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
// 4J - added - this used to use generics so the input parameter could be a mob (or derived type), but we aren't
// able to do that so dynamically casting to get the more specific type here.
shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(_mob);
std::shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(_mob);
glPushMatrix();
glDisable(GL_CULL_FACE);
@@ -54,7 +54,7 @@ void MobRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z,
if (mob->isRiding() && dynamic_pointer_cast<Mob>(mob->riding))
{
shared_ptr<Mob> riding = dynamic_pointer_cast<Mob>(mob->riding);
std::shared_ptr<Mob> riding = dynamic_pointer_cast<Mob>(mob->riding);
bodyRot = rotlerp(riding->yBodyRotO, riding->yBodyRot, a);
float headDiff = Mth::wrapDegrees(headRot - bodyRot);
@@ -233,9 +233,9 @@ void MobRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z,
MemSect(0);
}
void MobRenderer::renderModel(shared_ptr<Entity> mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale)
void MobRenderer::renderModel(std::shared_ptr<Entity> mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale)
{
shared_ptr<Player> player = dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player);
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player);
bindTexture(mob->customTextureUrl, mob->getTexture());
if (!mob->isInvisible())
@@ -262,12 +262,12 @@ void MobRenderer::renderModel(shared_ptr<Entity> mob, float wp, float ws, float
}
}
void MobRenderer::setupPosition(shared_ptr<Mob> mob, double x, double y, double z)
void MobRenderer::setupPosition(std::shared_ptr<Mob> mob, double x, double y, double z)
{
glTranslatef((float) x, (float) y, (float) z);
}
void MobRenderer::setupRotations(shared_ptr<Mob> mob, float bob, float bodyRot, float a)
void MobRenderer::setupRotations(std::shared_ptr<Mob> mob, float bob, float bodyRot, float a)
{
glRotatef(180 - bodyRot, 0, 1, 0);
if (mob->deathTime > 0)
@@ -279,49 +279,49 @@ void MobRenderer::setupRotations(shared_ptr<Mob> mob, float bob, float bodyRot,
}
}
float MobRenderer::getAttackAnim(shared_ptr<Mob> mob, float a)
float MobRenderer::getAttackAnim(std::shared_ptr<Mob> mob, float a)
{
return mob->getAttackAnim(a);
}
float MobRenderer::getBob(shared_ptr<Mob> mob, float a)
float MobRenderer::getBob(std::shared_ptr<Mob> mob, float a)
{
return (mob->tickCount + a);
}
void MobRenderer::additionalRendering(shared_ptr<Mob> mob, float a)
void MobRenderer::additionalRendering(std::shared_ptr<Mob> mob, float a)
{
}
int MobRenderer::prepareArmorOverlay(shared_ptr<Mob> mob, int layer, float a)
int MobRenderer::prepareArmorOverlay(std::shared_ptr<Mob> mob, int layer, float a)
{
return prepareArmor(mob, layer, a);
}
int MobRenderer::prepareArmor(shared_ptr<Mob> mob, int layer, float a)
int MobRenderer::prepareArmor(std::shared_ptr<Mob> mob, int layer, float a)
{
return -1;
}
void MobRenderer::prepareSecondPassArmor(shared_ptr<Mob> mob, int layer, float a)
void MobRenderer::prepareSecondPassArmor(std::shared_ptr<Mob> mob, int layer, float a)
{
}
float MobRenderer::getFlipDegrees(shared_ptr<Mob> mob)
float MobRenderer::getFlipDegrees(std::shared_ptr<Mob> mob)
{
return 90;
}
int MobRenderer::getOverlayColor(shared_ptr<Mob> mob, float br, float a)
int MobRenderer::getOverlayColor(std::shared_ptr<Mob> mob, float br, float a)
{
return 0;
}
void MobRenderer::scale(shared_ptr<Mob> mob, float a)
void MobRenderer::scale(std::shared_ptr<Mob> mob, float a)
{
}
void MobRenderer::renderName(shared_ptr<Mob> mob, double x, double y, double z)
void MobRenderer::renderName(std::shared_ptr<Mob> mob, double x, double y, double z)
{
if (Minecraft::renderDebug())
{
@@ -330,7 +330,7 @@ void MobRenderer::renderName(shared_ptr<Mob> mob, double x, double y, double z)
}
// 4J Added parameter for color here so that we can colour players names
void MobRenderer::renderNameTag(shared_ptr<Mob> mob, const wstring& OriginalName, double x, double y, double z, int maxDist, int color /*= 0xffffffff*/)
void MobRenderer::renderNameTag(std::shared_ptr<Mob> mob, const wstring& OriginalName, double x, double y, double z, int maxDist, int color /*= 0xffffffff*/)
{
if ( app.GetGameSettings(eGameSetting_DisplayHUD)==0 )
@@ -396,7 +396,7 @@ void MobRenderer::renderNameTag(shared_ptr<Mob> mob, const wstring& OriginalName
Tesselator *t = Tesselator::getInstance();
int offs = 0;
shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob);
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(mob);
if (player != NULL && app.isXuidDeadmau5( player->getXuid() ) ) offs = -10;
wstring playerName;
Minecraft.Client/Rendering/EntityRenderers/MobRenderer.h
+15 -15
View File
@@ -23,22 +23,22 @@ public:
private:
float rotlerp(float from, float to, float a);
public:
virtual void render(shared_ptr<Entity> mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> mob, double x, double y, double z, float rot, float a);
protected:
virtual void renderModel(shared_ptr<Entity> mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale);
virtual void setupPosition(shared_ptr<Mob> mob, double x, double y, double z);
virtual void setupRotations(shared_ptr<Mob> mob, float bob, float bodyRot, float a);
virtual float getAttackAnim(shared_ptr<Mob> mob, float a);
virtual float getBob(shared_ptr<Mob> mob, float a);
virtual void additionalRendering(shared_ptr<Mob> mob, float a);
virtual int prepareArmorOverlay(shared_ptr<Mob> mob, int layer, float a);
virtual int prepareArmor(shared_ptr<Mob> mob, int layer, float a);
virtual void prepareSecondPassArmor(shared_ptr<Mob> mob, int layer, float a);
virtual float getFlipDegrees(shared_ptr<Mob> mob);
virtual int getOverlayColor(shared_ptr<Mob> mob, float br, float a);
virtual void scale(shared_ptr<Mob> mob, float a);
virtual void renderName(shared_ptr<Mob> mob, double x, double y, double z);
virtual void renderNameTag(shared_ptr<Mob> mob, const wstring& name, double x, double y, double z, int maxDist, int color = 0xff000000);
virtual void renderModel(std::shared_ptr<Entity> mob, float wp, float ws, float bob, float headRotMinusBodyRot, float headRotx, float scale);
virtual void setupPosition(std::shared_ptr<Mob> mob, double x, double y, double z);
virtual void setupRotations(std::shared_ptr<Mob> mob, float bob, float bodyRot, float a);
virtual float getAttackAnim(std::shared_ptr<Mob> mob, float a);
virtual float getBob(std::shared_ptr<Mob> mob, float a);
virtual void additionalRendering(std::shared_ptr<Mob> mob, float a);
virtual int prepareArmorOverlay(std::shared_ptr<Mob> mob, int layer, float a);
virtual int prepareArmor(std::shared_ptr<Mob> mob, int layer, float a);
virtual void prepareSecondPassArmor(std::shared_ptr<Mob> mob, int layer, float a);
virtual float getFlipDegrees(std::shared_ptr<Mob> mob);
virtual int getOverlayColor(std::shared_ptr<Mob> mob, float br, float a);
virtual void scale(std::shared_ptr<Mob> mob, float a);
virtual void renderName(std::shared_ptr<Mob> mob, double x, double y, double z);
virtual void renderNameTag(std::shared_ptr<Mob> mob, const wstring& name, double x, double y, double z, int maxDist, int color = 0xff000000);
public:
// 4J Added
Minecraft.Client/Rendering/EntityRenderers/MobSpawnerRenderer.cpp
+3 -3
View File
@@ -5,15 +5,15 @@
#include "../../../Minecraft.World/Headers/net.minecraft.world.level.tile.entity.h"
#include "../../../Minecraft.World/Headers/net.minecraft.world.entity.h"
void MobSpawnerRenderer::render(shared_ptr<TileEntity> _spawner, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
void MobSpawnerRenderer::render(std::shared_ptr<TileEntity> _spawner, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<MobSpawnerTileEntity> spawner = dynamic_pointer_cast<MobSpawnerTileEntity>(_spawner);
std::shared_ptr<MobSpawnerTileEntity> spawner = dynamic_pointer_cast<MobSpawnerTileEntity>(_spawner);
glPushMatrix();
glTranslatef((float) x + 0.5f, (float) y, (float) z + 0.5f);
shared_ptr<Entity> e = spawner->getDisplayEntity();
std::shared_ptr<Entity> e = spawner->getDisplayEntity();
if (e != NULL)
{
e->setLevel(spawner->level);
Minecraft.Client/Rendering/EntityRenderers/MobSpawnerRenderer.h
+2 -2
View File
@@ -5,7 +5,7 @@ using namespace std;
class MobSpawnerRenderer : public TileEntityRenderer
{
private:
unordered_map<wstring, shared_ptr<Entity> > models;
unordered_map<wstring, std::shared_ptr<Entity> > models;
public:
virtual void render(shared_ptr<TileEntity> _spawner, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
virtual void render(std::shared_ptr<TileEntity> _spawner, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
};
Minecraft.Client/Rendering/EntityRenderers/MushroomCowRenderer.cpp
+6 -6
View File
@@ -9,21 +9,21 @@ MushroomCowRenderer::MushroomCowRenderer(Model *model, float shadow) : MobRender
{
}
void MushroomCowRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void MushroomCowRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
// 4J - original version used generics and thus had an input parameter of type MushroomCow rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type MushroomCow rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
//shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob);
//std::shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob);
// 4J Stu - No need to do the cast, just pass through as-is
MobRenderer::render(_mob, x, y, z, rot, a);
}
void MushroomCowRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
void MushroomCowRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
{
// 4J - original version used generics and thus had an input parameter of type MushroomCow rather than shared_ptr<Mob> we have here -
// 4J - original version used generics and thus had an input parameter of type MushroomCow rather than std::shared_ptr<Mob> we have here -
// do some casting around instead
shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob);
std::shared_ptr<MushroomCow> mob = dynamic_pointer_cast<MushroomCow>(_mob);
MobRenderer::additionalRendering(mob, a);
if (mob->isBaby()) return;
bindTexture(TN_TERRAIN); // 4J was "/terrain.png"
Minecraft.Client/Rendering/EntityRenderers/MushroomCowRenderer.h
+2 -2
View File
@@ -7,8 +7,8 @@ class MushroomCowRenderer : public MobRenderer
public:
MushroomCowRenderer(Model *model, float shadow);
virtual void render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
protected:
virtual void additionalRendering(shared_ptr<Mob> _mob, float a);
virtual void additionalRendering(std::shared_ptr<Mob> _mob, float a);
};
Minecraft.Client/Rendering/EntityRenderers/OcelotRenderer.cpp
+4 -4
View File
@@ -6,16 +6,16 @@ OzelotRenderer::OzelotRenderer(Model *model, float shadow) : MobRenderer(model,
{
}
void OzelotRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void OzelotRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
MobRenderer::render(_mob, x, y, z, rot, a);
}
void OzelotRenderer::scale(shared_ptr<Mob> _mob, float a)
void OzelotRenderer::scale(std::shared_ptr<Mob> _mob, float a)
{
// 4J - original version used generics and thus had an input parameter of type Blaze rather than shared_ptr<Entity> we have here -
// 4J - original version used generics and thus had an input parameter of type Blaze rather than std::shared_ptr<Entity> we have here -
// do some casting around instead
shared_ptr<Ozelot> mob = dynamic_pointer_cast<Ozelot>(_mob);
std::shared_ptr<Ozelot> mob = dynamic_pointer_cast<Ozelot>(_mob);
MobRenderer::scale(mob, a);
if (mob->isTame())
{
Minecraft.Client/Rendering/EntityRenderers/OcelotRenderer.h
+2 -2
View File
@@ -7,8 +7,8 @@ class OzelotRenderer : public MobRenderer
public:
OzelotRenderer(Model *model, float shadow);
void render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
void render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
protected:
void scale(shared_ptr<Mob> _mob, float a);
void scale(std::shared_ptr<Mob> _mob, float a);
};
Minecraft.Client/Rendering/EntityRenderers/PaintingRenderer.cpp
+4 -4
View File
@@ -11,10 +11,10 @@ PaintingRenderer::PaintingRenderer()
random = new Random();
}
void PaintingRenderer::render(shared_ptr<Entity> _painting, double x, double y, double z, float rot, float a)
void PaintingRenderer::render(std::shared_ptr<Entity> _painting, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Painting> painting = dynamic_pointer_cast<Painting>(_painting);
std::shared_ptr<Painting> painting = dynamic_pointer_cast<Painting>(_painting);
random->setSeed(187);
@@ -33,7 +33,7 @@ void PaintingRenderer::render(shared_ptr<Entity> _painting, double x, double y,
glPopMatrix();
}
void PaintingRenderer::renderPainting(shared_ptr<Painting> painting, int w, int h, int uo, int vo)
void PaintingRenderer::renderPainting(std::shared_ptr<Painting> painting, int w, int h, int uo, int vo)
{
float xx0 = -w / 2.0f;
float yy0 = -h / 2.0f;
@@ -113,7 +113,7 @@ void PaintingRenderer::renderPainting(shared_ptr<Painting> painting, int w, int
}
void PaintingRenderer::setBrightness(shared_ptr<Painting> painting, float ss, float ya)
void PaintingRenderer::setBrightness(std::shared_ptr<Painting> painting, float ss, float ya)
{
int x = Mth::floor(painting->x);
int y = Mth::floor(painting->y + ya/16.0f);
Minecraft.Client/Rendering/EntityRenderers/PaintingRenderer.h
+3 -3
View File
@@ -11,9 +11,9 @@ private:
public:
PaintingRenderer(); // 4J -added
virtual void render(shared_ptr<Entity> _painting, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _painting, double x, double y, double z, float rot, float a);
private:
void renderPainting(shared_ptr<Painting> painting, int w, int h, int uo, int vo);
void setBrightness(shared_ptr<Painting> painting, float ss, float ya);
void renderPainting(std::shared_ptr<Painting> painting, int w, int h, int uo, int vo);
void setBrightness(std::shared_ptr<Painting> painting, float ss, float ya);
};
Minecraft.Client/Rendering/EntityRenderers/PigRenderer.cpp
+3 -3
View File
@@ -7,10 +7,10 @@ PigRenderer::PigRenderer(Model *model, Model *armor, float shadow) : MobRenderer
setArmor(armor);
}
int PigRenderer::prepareArmor(shared_ptr<Mob> _pig, int layer, float a)
int PigRenderer::prepareArmor(std::shared_ptr<Mob> _pig, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(_pig);
std::shared_ptr<Pig> pig = dynamic_pointer_cast<Pig>(_pig);
MemSect(31);
bindTexture(TN_MOB_SADDLE); // 4J was L"/mob/saddle.png"
@@ -18,7 +18,7 @@ int PigRenderer::prepareArmor(shared_ptr<Mob> _pig, int layer, float a)
return (layer == 0 && pig->hasSaddle()) ? 1 : -1;
}
void PigRenderer::render(shared_ptr<Entity> mob, double x, double y, double z, float rot, float a)
void PigRenderer::render(std::shared_ptr<Entity> mob, double x, double y, double z, float rot, float a)
{
MobRenderer::render(mob, x, y, z, rot, a);
}
Minecraft.Client/Rendering/EntityRenderers/PigRenderer.h
+2 -2
View File
@@ -6,8 +6,8 @@ class PigRenderer : public MobRenderer
public:
PigRenderer(Model *model, Model *armor, float shadow);
protected:
virtual int prepareArmor(shared_ptr<Mob> _pig, int layer, float a);
virtual int prepareArmor(std::shared_ptr<Mob> _pig, int layer, float a);
public:
virtual void render(shared_ptr<Entity> mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> mob, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/PistonPieceRenderer.cpp
+2 -2
View File
@@ -12,10 +12,10 @@ PistonPieceRenderer::PistonPieceRenderer()
tileRenderer = NULL;
}
void PistonPieceRenderer::render(shared_ptr<TileEntity> _entity, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
void PistonPieceRenderer::render(std::shared_ptr<TileEntity> _entity, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<PistonPieceEntity> entity = dynamic_pointer_cast<PistonPieceEntity>(_entity);
std::shared_ptr<PistonPieceEntity> entity = dynamic_pointer_cast<PistonPieceEntity>(_entity);
Tile *tile = Tile::tiles[entity->getId()];
if (tile != NULL && entity->getProgress(a) <= 1) // 4J - changed condition from < to <= as our chunk update is async to main thread and so we can have to render these with progress of 1
Minecraft.Client/Rendering/EntityRenderers/PistonPieceRenderer.h
+1 -1
View File
@@ -10,6 +10,6 @@ private:
public:
PistonPieceRenderer();
virtual void render(shared_ptr<TileEntity> _entity, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
virtual void render(std::shared_ptr<TileEntity> _entity, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
virtual void onNewLevel(Level *level);
};
Minecraft.Client/Rendering/EntityRenderers/PlayerRenderer.cpp
+23 -23
View File
@@ -46,10 +46,10 @@ unsigned int PlayerRenderer::getNametagColour(int index)
return 0xFF000000;
}
int PlayerRenderer::prepareArmor(shared_ptr<Mob> _player, int layer, float a)
int PlayerRenderer::prepareArmor(std::shared_ptr<Mob> _player, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
// 4J-PB - need to disable rendering armour for some special skins (Daleks)
unsigned int uiAnimOverrideBitmask=player->getAnimOverrideBitmask();
@@ -58,7 +58,7 @@ int PlayerRenderer::prepareArmor(shared_ptr<Mob> _player, int layer, float a)
return -1;
}
shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
std::shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
if (itemInstance != NULL)
{
Item *item = itemInstance->getItem();
@@ -108,11 +108,11 @@ int PlayerRenderer::prepareArmor(shared_ptr<Mob> _player, int layer, float a)
}
void PlayerRenderer::prepareSecondPassArmor(shared_ptr<Mob> _player, int layer, float a)
void PlayerRenderer::prepareSecondPassArmor(std::shared_ptr<Mob> _player, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
std::shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
if (itemInstance != NULL)
{
Item *item = itemInstance->getItem();
@@ -127,14 +127,14 @@ void PlayerRenderer::prepareSecondPassArmor(shared_ptr<Mob> _player, int layer,
}
}
void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void PlayerRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
if(mob->hasInvisiblePrivilege()) return;
shared_ptr<ItemInstance> item = mob->inventory->getSelected();
std::shared_ptr<ItemInstance> item = mob->inventory->getSelected();
armorParts1->holdingRightHand = armorParts2->holdingRightHand = humanoidModel->holdingRightHand = item != NULL ? 1 : 0;
if (item != NULL)
{
@@ -228,10 +228,10 @@ void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double
}
void PlayerRenderer::renderName(shared_ptr<Mob> _mob, double x, double y, double z)
void PlayerRenderer::renderName(std::shared_ptr<Mob> _mob, double x, double y, double z)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
if (Minecraft::renderNames() && mob != entityRenderDispatcher->cameraEntity
&& !mob->isInvisibleTo(Minecraft::GetInstance()->player) ) // 4J-JEV: Todo, move to LivingEntityRenderer.
@@ -316,14 +316,14 @@ void PlayerRenderer::renderName(shared_ptr<Mob> _mob, double x, double y, double
}
void PlayerRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
void PlayerRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
{
MobRenderer::additionalRendering(_mob,a);
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3);
std::shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3);
if (headGear != NULL)
{
// don't render the pumpkin for the skins
@@ -428,7 +428,7 @@ void PlayerRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
}
shared_ptr<ItemInstance> item = mob->inventory->getSelected();
std::shared_ptr<ItemInstance> item = mob->inventory->getSelected();
if (item != NULL)
{
@@ -438,7 +438,7 @@ void PlayerRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
if (mob->fishing != NULL)
{
item = shared_ptr<ItemInstance>( new ItemInstance(Item::stick) );
item = std::shared_ptr<ItemInstance>( new ItemInstance(Item::stick) );
}
UseAnim anim = UseAnim_none;//null;
@@ -521,7 +521,7 @@ void PlayerRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
}
void PlayerRenderer::scale(shared_ptr<Mob> player, float a)
void PlayerRenderer::scale(std::shared_ptr<Mob> player, float a)
{
float s = 15 / 16.0f;
glScalef(s, s, s);
@@ -540,10 +540,10 @@ void PlayerRenderer::renderHand()
}
}
void PlayerRenderer::setupPosition(shared_ptr<Mob> _mob, double x, double y, double z)
void PlayerRenderer::setupPosition(std::shared_ptr<Mob> _mob, double x, double y, double z)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
if (mob->isAlive() && mob->isSleeping())
{
@@ -556,10 +556,10 @@ void PlayerRenderer::setupPosition(shared_ptr<Mob> _mob, double x, double y, dou
}
}
void PlayerRenderer::setupRotations(shared_ptr<Mob> _mob, float bob, float bodyRot, float a)
void PlayerRenderer::setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
std::shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
if (mob->isAlive() && mob->isSleeping())
{
@@ -574,11 +574,11 @@ void PlayerRenderer::setupRotations(shared_ptr<Mob> _mob, float bob, float bodyR
}
// 4J Added override to stop rendering shadow if player is invisible
void PlayerRenderer::renderShadow(shared_ptr<Entity> e, double x, double y, double z, float pow, float a)
void PlayerRenderer::renderShadow(std::shared_ptr<Entity> e, double x, double y, double z, float pow, float a)
{
if(app.GetGameHostOption(eGameHostOption_HostCanBeInvisible) > 0)
{
shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
std::shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
if(player != NULL && player->hasInvisiblePrivilege()) return;
}
EntityRenderer::renderShadow(e,x,y,z,pow,a);
Minecraft.Client/Rendering/EntityRenderers/PlayerRenderer.h
+9 -9
View File
@@ -23,20 +23,20 @@ private:
static const wstring MATERIAL_NAMES[5];
protected:
virtual int prepareArmor(shared_ptr<Mob> _player, int layer, float a);
virtual void prepareSecondPassArmor(shared_ptr<Mob> mob, int layer, float a);
virtual int prepareArmor(std::shared_ptr<Mob> _player, int layer, float a);
virtual void prepareSecondPassArmor(std::shared_ptr<Mob> mob, int layer, float a);
public:
virtual void render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
protected:
virtual void renderName(shared_ptr<Mob> _mob, double x, double y, double z);
virtual void additionalRendering(shared_ptr<Mob> _mob, float a);
virtual void scale(shared_ptr<Mob> _player, float a);
virtual void renderName(std::shared_ptr<Mob> _mob, double x, double y, double z);
virtual void additionalRendering(std::shared_ptr<Mob> _mob, float a);
virtual void scale(std::shared_ptr<Mob> _player, float a);
public:
void renderHand();
protected:
virtual void setupPosition(shared_ptr<Mob> _mob, double x, double y, double z);
virtual void setupRotations(shared_ptr<Mob> _mob, float bob, float bodyRot, float a);
virtual void setupPosition(std::shared_ptr<Mob> _mob, double x, double y, double z);
virtual void setupRotations(std::shared_ptr<Mob> _mob, float bob, float bodyRot, float a);
private:
virtual void renderShadow(shared_ptr<Entity> e, double x, double y, double z, float pow, float a); // 4J Added override
virtual void renderShadow(std::shared_ptr<Entity> e, double x, double y, double z, float pow, float a); // 4J Added override
};
Minecraft.Client/Rendering/EntityRenderers/SheepRenderer.cpp
+3 -3
View File
@@ -8,10 +8,10 @@ SheepRenderer::SheepRenderer(Model *model, Model *armor, float shadow) : MobRend
setArmor(armor);
}
int SheepRenderer::prepareArmor(shared_ptr<Mob> _sheep, int layer, float a)
int SheepRenderer::prepareArmor(std::shared_ptr<Mob> _sheep, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(_sheep);
std::shared_ptr<Sheep> sheep = dynamic_pointer_cast<Sheep>(_sheep);
if (layer == 0 && !sheep->isSheared() &&
!sheep->isInvisibleTo(Minecraft::GetInstance()->player)) // 4J-JEV: Todo, merge with java fix (for invisible sheep armour) in '1.7.5'.
@@ -28,7 +28,7 @@ int SheepRenderer::prepareArmor(shared_ptr<Mob> _sheep, int layer, float a)
return -1;
}
void SheepRenderer::render(shared_ptr<Entity> mob, double x, double y, double z, float rot, float a)
void SheepRenderer::render(std::shared_ptr<Entity> mob, double x, double y, double z, float rot, float a)
{
MobRenderer::render(mob, x, y, z, rot, a);
}
Minecraft.Client/Rendering/EntityRenderers/SheepRenderer.h
+2 -2
View File
@@ -7,8 +7,8 @@ public:
SheepRenderer(Model *model, Model *armor, float shadow);
protected:
virtual int prepareArmor(shared_ptr<Mob> _sheep, int layer, float a);
virtual int prepareArmor(std::shared_ptr<Mob> _sheep, int layer, float a);
public:
virtual void render(shared_ptr<Entity> mob, double x, double y, double z, float rot, float a);
virtual void render(std::shared_ptr<Entity> mob, double x, double y, double z, float rot, float a);
};
Minecraft.Client/Rendering/EntityRenderers/SignRenderer.cpp
+2 -2
View File
@@ -13,10 +13,10 @@ SignRenderer::SignRenderer()
signModel = new SignModel();
}
void SignRenderer::render(shared_ptr<TileEntity> _sign, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
void SignRenderer::render(std::shared_ptr<TileEntity> _sign, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<SignTileEntity> sign = dynamic_pointer_cast<SignTileEntity>(_sign);
std::shared_ptr<SignTileEntity> sign = dynamic_pointer_cast<SignTileEntity>(_sign);
Tile *tile = sign->getTile();
Minecraft.Client/Rendering/EntityRenderers/SignRenderer.h
+1 -1
View File
@@ -8,5 +8,5 @@ private:
SignModel *signModel;
public:
SignRenderer(); // 4J - added
virtual void render(shared_ptr<TileEntity> sign, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
virtual void render(std::shared_ptr<TileEntity> sign, double x, double y, double z, float a, bool setColor, float alpha=1.0f, bool useCompiled = true); // 4J added setColor param
};
Minecraft.Client/Rendering/EntityRenderers/SilverfishRenderer.cpp
+3 -3
View File
@@ -7,17 +7,17 @@ SilverfishRenderer::SilverfishRenderer() : MobRenderer(new SilverfishModel(), 0.
{
}
float SilverfishRenderer::getFlipDegrees(shared_ptr<Silverfish> spider)
float SilverfishRenderer::getFlipDegrees(std::shared_ptr<Silverfish> spider)
{
return 180;
}
void SilverfishRenderer::render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
void SilverfishRenderer::render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a)
{
MobRenderer::render(_mob, x, y, z, rot, a);
}
int SilverfishRenderer::prepareArmor(shared_ptr<Mob> _silverfish, int layer, float a)
int SilverfishRenderer::prepareArmor(std::shared_ptr<Mob> _silverfish, int layer, float a)
{
return -1;
}
Minecraft.Client/Rendering/EntityRenderers/SilverfishRenderer.h
+3 -3
View File
@@ -13,11 +13,11 @@ public:
SilverfishRenderer();
protected:
float getFlipDegrees(shared_ptr<Silverfish> spider);
float getFlipDegrees(std::shared_ptr<Silverfish> spider);
public:
void render(shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
void render(std::shared_ptr<Entity> _mob, double x, double y, double z, float rot, float a);
protected:
int prepareArmor(shared_ptr<Mob> _silverfish, int layer, float a);
int prepareArmor(std::shared_ptr<Mob> _silverfish, int layer, float a);
};
Minecraft.Client/Rendering/EntityRenderers/SkullTileRenderer.cpp
+2 -2
View File
@@ -19,9 +19,9 @@ SkullTileRenderer::~SkullTileRenderer()
delete zombieModel;
}
void SkullTileRenderer::render(shared_ptr<TileEntity> _skull, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
void SkullTileRenderer::render(std::shared_ptr<TileEntity> _skull, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled)
{
shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(_skull);
std::shared_ptr<SkullTileEntity> skull = dynamic_pointer_cast<SkullTileEntity>(_skull);
renderSkull((float) x, (float) y, (float) z, skull->getData() & SkullTile::PLACEMENT_MASK, skull->getRotation() * 360 / 16.0f, skull->getSkullType(), skull->getExtraType());
}
Minecraft.Client/Rendering/EntityRenderers/SkullTileRenderer.h
+1 -1
View File
@@ -18,7 +18,7 @@ public:
SkullTileRenderer();
~SkullTileRenderer();
void render(shared_ptr<TileEntity> skull, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled = true);
void render(std::shared_ptr<TileEntity> skull, double x, double y, double z, float a, bool setColor, float alpha, bool useCompiled = true);
void init(TileEntityRenderDispatcher *tileEntityRenderDispatcher);
void renderSkull(float x, float y, float z, int face, float rot, int type, const wstring &extra);
};
Minecraft.Client/Rendering/EntityRenderers/SlimeRenderer.cpp
+4 -4
View File
@@ -7,10 +7,10 @@ SlimeRenderer::SlimeRenderer(Model *model, Model *armor, float shadow) : MobRend
this->armor = armor;
}
int SlimeRenderer::prepareArmor(shared_ptr<Mob> _slime, int layer, float a)
int SlimeRenderer::prepareArmor(std::shared_ptr<Mob> _slime, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(_slime);
std::shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(_slime);
if (slime->isInvisible()) return 0;
@@ -32,10 +32,10 @@ int SlimeRenderer::prepareArmor(shared_ptr<Mob> _slime, int layer, float a)
return -1;
}
void SlimeRenderer::scale(shared_ptr<Mob> _slime, float a)
void SlimeRenderer::scale(std::shared_ptr<Mob> _slime, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(_slime);
std::shared_ptr<Slime> slime = dynamic_pointer_cast<Slime>(_slime);
float size = (float) slime->getSize();
float ss = (slime->oSquish + (slime->squish - slime->oSquish) * a) / (size * 0.5f + 1);
Minecraft.Client/Rendering/EntityRenderers/SlimeRenderer.h
+2 -2
View File
@@ -8,6 +8,6 @@ private:
public:
SlimeRenderer(Model *model, Model *armor, float shadow);
protected:
virtual int prepareArmor(shared_ptr<Mob> _slime, int layer, float a);
virtual void scale(shared_ptr<Mob> _slime, float a);
virtual int prepareArmor(std::shared_ptr<Mob> _slime, int layer, float a);
virtual void scale(std::shared_ptr<Mob> _slime, float a);
};
Minecraft.Client/Rendering/EntityRenderers/SnowManRenderer.cpp
+4 -4
View File
@@ -13,14 +13,14 @@ SnowManRenderer::SnowManRenderer() : MobRenderer(new SnowManModel(), 0.5f)
this->setArmor(model);
}
void SnowManRenderer::additionalRendering(shared_ptr<Mob> _mob, float a)
void SnowManRenderer::additionalRendering(std::shared_ptr<Mob> _mob, float a)
{
// 4J - original version used generics and thus had an input parameter of type SnowMan rather than shared_ptr<Mob> we have here -
// 4J - original version used generics and thus had an input parameter of type SnowMan rather than std::shared_ptr<Mob> we have here -
// do some casting around instead
shared_ptr<SnowMan> mob = dynamic_pointer_cast<SnowMan>(_mob);
std::shared_ptr<SnowMan> mob = dynamic_pointer_cast<SnowMan>(_mob);
MobRenderer::additionalRendering(mob, a);
shared_ptr<ItemInstance> headGear = shared_ptr<ItemInstance>( new ItemInstance(Tile::pumpkin, 1) );
std::shared_ptr<ItemInstance> headGear = std::shared_ptr<ItemInstance>( new ItemInstance(Tile::pumpkin, 1) );
if (headGear != NULL && headGear->getItem()->id < 256)
{
glPushMatrix();
Minecraft.Client/Rendering/EntityRenderers/SnowManRenderer.h
+1 -1
View File
@@ -13,5 +13,5 @@ public:
SnowManRenderer();
protected:
virtual void additionalRendering(shared_ptr<Mob> _mob, float a);
virtual void additionalRendering(std::shared_ptr<Mob> _mob, float a);
};
Minecraft.Client/Rendering/EntityRenderers/SpiderRenderer.cpp
+5 -5
View File
@@ -8,15 +8,15 @@ SpiderRenderer::SpiderRenderer() : MobRenderer(new SpiderModel(), 1.0f)
this->setArmor(new SpiderModel());
}
float SpiderRenderer::getFlipDegrees(shared_ptr<Mob> spider)
float SpiderRenderer::getFlipDegrees(std::shared_ptr<Mob> spider)
{
return 180;
}
int SpiderRenderer::prepareArmor(shared_ptr<Mob> _spider, int layer, float a)
int SpiderRenderer::prepareArmor(std::shared_ptr<Mob> _spider, int layer, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Spider> spider = dynamic_pointer_cast<Spider>(_spider);
std::shared_ptr<Spider> spider = dynamic_pointer_cast<Spider>(_spider);
if (layer!=0) return -1;
MemSect(31);
@@ -52,10 +52,10 @@ int SpiderRenderer::prepareArmor(shared_ptr<Mob> _spider, int layer, float a)
return 1;
}
void SpiderRenderer::scale(shared_ptr<Mob> _mob, float a)
void SpiderRenderer::scale(std::shared_ptr<Mob> _mob, float a)
{
// 4J - dynamic cast required because we aren't using templates/generics in our version
shared_ptr<Spider> mob = dynamic_pointer_cast<Spider>(_mob);
std::shared_ptr<Spider> mob = dynamic_pointer_cast<Spider>(_mob);
float scale = mob->getModelScale();
glScalef(scale, scale, scale);
}
Minecraft.Client/Rendering/EntityRenderers/SpiderRenderer.h
+3 -3
View File
@@ -6,7 +6,7 @@ class SpiderRenderer : public MobRenderer
public:
SpiderRenderer();
protected:
virtual float getFlipDegrees(shared_ptr<Mob> spider);
virtual int prepareArmor(shared_ptr<Mob> _spider, int layer, float a);
void scale(shared_ptr<Mob> _mob, float a);
virtual float getFlipDegrees(std::shared_ptr<Mob> spider);
virtual int prepareArmor(std::shared_ptr<Mob> _spider, int layer, float a);
void scale(std::shared_ptr<Mob> _mob, float a);
};

Some files were not shown because too many files have changed in this diff Show More