Entity Renderer

EntityRenderer (abstract base)
  ├─ MobRenderer (for living entities)
  │   ├─ HumanoidMobRenderer
  │   │   ├─ PlayerRenderer
  │   │   ├─ ZombieRenderer
  │   │   ├─ SkeletonRenderer
  │   │   └─ ...
  │   ├─ QuadrupedRenderer
  │   │   ├─ PigRenderer
  │   │   ├─ CowRenderer
  │   │   ├─ SheepRenderer
  │   │   └─ ...
  │   └─ Other specialized renderers
  │       ├─ SpiderRenderer
  │       ├─ EndermanRenderer
  │       ├─ GhastRenderer
  │       └─ ...
  └─ Simple entity renderers
      ├─ BoatRenderer
      ├─ MinecartRenderer
      ├─ ArrowRenderer
      ├─ ItemRenderer
      └─ ...

class EntityRenderer {
public:
    virtual void render(shared_ptr<Entity> entity, double x, double y, double z, 
                       float rot, float a) = 0;
protected:
    float shadowRadius;
    float shadowStrength;
    Model *model;
    TileRenderer *tileRenderer;
};

virtual void render(shared_ptr<Entity> entity, double x, double y, double z,
                   float rot, float a) = 0;

virtual void bindTexture(int resourceName);
virtual void bindTexture(const wstring& resourceName);
virtual bool bindTexture(const wstring& urlTexture, int backupTexture);

virtual void renderShadow(shared_ptr<Entity> e, double x, double y, double z,
                         float pow, float a);

virtual void postRender(shared_ptr<Entity> entity, double x, double y, double z,
                       float rot, float a, bool bRenderPlayerShadow);

class MobRenderer : public EntityRenderer {
protected:
    Model *model;
    Model *armor;
public:
    MobRenderer(Model *model, float shadow);
};

virtual void renderModel(shared_ptr<Entity> mob, float wp, float ws, float bob,
                        float headRotMinusBodyRot, float headRotx, float scale);

virtual void setupRotations(shared_ptr<Mob> mob, float bob, 
                           float bodyRot, float a);

static const int MAX_ARMOR_LAYERS = 4;

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 void renderNameTag(shared_ptr<Mob> mob, const wstring& name,
                          double x, double y, double z, int maxDist, 
                          int color = 0xff000000);

#define PLAYER_NAME_READABLE_FULLSCREEN 16
#define PLAYER_NAME_READABLE_DISTANCE_SPLITSCREEN 8
#define PLAYER_NAME_READABLE_DISTANCE_SD 8

class Model {
public:
    float attackTime;
    bool riding;
    vector<ModelPart *> cubes;
    bool young;
    
    virtual void render(shared_ptr<Entity> entity, float time, float r, float bob,
                       float yRot, float xRot, float scale, bool usecompiled);
    virtual void setupAnim(float time, float r, float bob, float yRot, 
                          float xRot, float scale, unsigned int uiBitmaskOverrideAnim=0);
    virtual void prepareMobModel(shared_ptr<Mob> mob, float time, float r, float a);
};

vector<ModelPart *> cubes;

unordered_map<wstring, TexOffs *> mappedTexOffs;
int texWidth;
int texHeight;

void setMapTex(wstring id, int x, int y);
TexOffs *getMapTex(wstring id);

class HumanoidModel : public Model {
public:
    ModelPart *head, *hair, *body, *arm0, *arm1, *leg0, *leg1, *ear, *cloak;
    
    int holdingLeftHand;
    int holdingRightHand;
    bool idle;
    bool sneaking;
    bool bowAndArrow;
    bool eating;
};

enum animbits {
    eAnim_ArmsDown = 0,
    eAnim_ArmsOutFront,
    eAnim_NoLegAnim,
    eAnim_HasIdle,
    eAnim_ForceAnim,
    eAnim_SingleLegs,      // Both legs move together
    eAnim_SingleArms,      // Both arms move together
    eAnim_StatueOfLiberty, // Weeping Angel style
    eAnim_DontRenderArmour,
    eAnim_NoBobbing,
    eAnim_DisableRenderHead,
    eAnim_DisableRenderArm0,
    eAnim_DisableRenderArm1,
    eAnim_DisableRenderTorso,
    eAnim_DisableRenderLeg0,
    eAnim_DisableRenderLeg1,
    eAnim_DisableRenderHair
};

virtual void setupAnim(float time, float r, float bob, float yRot,
                      float xRot, float scale, 
                      unsigned int uiBitmaskOverrideAnim=0);

void renderHair(float scale, bool usecompiled);
void renderEars(float scale, bool usecompiled);
void renderCloak(float scale, bool usecompiled);

class BookModel : public Model {
public:
    ModelPart *leftLid, *rightLid;
    ModelPart *leftPages, *rightPages;
    ModelPart *flipPage1, *flipPage2;
    ModelPart *seam;
};

class BlazeRenderer : public MobRenderer {
private:
    int modelVersion;
public:
    virtual void render(shared_ptr<Entity> mob, double x, double y, double z,
                       float rot, float a);
};

class BoatRenderer : public EntityRenderer {
protected:
    Model *model;
public:
    virtual void render(shared_ptr<Entity> boat, double x, double y, double z,
                       float rot, float a);
};

class EntityRenderDispatcher {
public:
    static EntityRenderDispatcher *instance;
    
    void prepare(Level *level, Textures *textures, Font *font,
                shared_ptr<Entity> player, Options *options, float a);
    void render(shared_ptr<Entity> entity, float a);
    
    static double xOff, yOff, zOff;  // Camera offset
};

class TileEntityRenderDispatcher {
public:
    static TileEntityRenderDispatcher *instance;
    
    void prepare(Level *level, Textures *textures, Font *font,
                shared_ptr<Entity> player, float a);
    void render(shared_ptr<TileEntity> tileEntity, float a);
    
    static double xOff, yOff, zOff;
};

void _reinit(int newTexWidth, int newTexHeight);

virtual void render(shared_ptr<Entity> entity, float time, float r, float bob,
                   float yRot, float xRot, float scale, 
                   bool usecompiled);  // Use compiled display lists

virtual void renderFlame(shared_ptr<Entity> e, double x, double y, double z, float a);