the whole game

2026-03-02 22:04:18 +03:00
parent 816e9060b4
commit f0617a5d22
2069 changed files with 581500 additions and 0 deletions
--- a/src/client/renderer/entity/ArrowRenderer.cpp
+++ b/src/client/renderer/entity/ArrowRenderer.cpp
@@ -0,0 +1,63 @@
+#include "ArrowRenderer.h"
+
+#include "../Tesselator.h"
+#include "../Textures.h"
+#include "../gles.h"
+#include "../../../world/entity/Entity.h"
+#include "../../../world/entity/projectile/Arrow.h"
+
+void ArrowRenderer::render(Entity* entity, float x, float y, float z, float rot, float a) {
+	bindTexture("item/arrows.png");
+	Arrow* arrow = (Arrow*) entity;
+	glPushMatrix2();
+	glTranslatef(x, y, z);
+	glRotatef(arrow->yRotO + (arrow->yRot - arrow->yRotO) * a - 90, 0, 1, 0);
+	glRotatef(arrow->xRotO + (arrow->xRot - arrow->xRotO) * a, 0, 0, 1);
+	Tesselator& t = Tesselator::instance;
+
+	int type = 0;
+
+	float u0 = 0 / 32.0f;
+	float u1 = 16 / 32.0f;
+	float v0 = (0 + type * 10) / 32.0f;
+	float v1 = (5 + type * 10) / 32.0f;
+
+	float u02 = 0 / 32.0f;
+	float u12 = 5 / 32.0f;
+	float v02 = (5 + type * 10) / 32.0f;
+	float v12 = (10 + type * 10) / 32.0f;
+	float ss = 0.9f / 16.0f;
+	float shake = arrow->shakeTime - a;
+	if (shake > 0) {
+		float pow = -Mth::sin(shake * 3) * shake;
+		glRotatef(pow, 0, 0, 1);
+	}
+	glRotatef(45, 1, 0, 0);
+	glScalef(ss, ss, ss);
+
+	glTranslatef(-4, 0, 0);
+
+	t.begin();
+	t.vertexUV(-7, -2, -2, u02, v02);
+	t.vertexUV(-7, -2, +2, u12, v02);
+	t.vertexUV(-7, +2, +2, u12, v12);
+	t.vertexUV(-7, +2, -2, u02, v12);
+
+	t.vertexUV(-7, +2, -2, u02, v02);
+	t.vertexUV(-7, +2, +2, u12, v02);
+	t.vertexUV(-7, -2, +2, u12, v12);
+	t.vertexUV(-7, -2, -2, u02, v12);
+	t.draw();
+
+	for (int i = 0; i < 4; i++) {
+		glRotatef(90, 1, 0, 0);
+		t.begin();
+		t.vertexUV(-8, -2, 0, u0, v0);
+		t.vertexUV(+8, -2, 0, u1, v0);
+		t.vertexUV(+8, +2, 0, u1, v1);
+		t.vertexUV(-8, +2, 0, u0, v1);
+		t.endOverrideAndDraw();
+	}
+
+	glPopMatrix2();
+}
--- a/src/client/renderer/entity/ArrowRenderer.h
+++ b/src/client/renderer/entity/ArrowRenderer.h
@@ -0,0 +1,9 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ArrowRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ArrowRenderer_H__
+#include "EntityRenderer.h"
+
+class ArrowRenderer : public EntityRenderer {
+	void render(Entity* arrow, float x, float y, float z, float rot, float a);
+};
+
+#endif /* NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ArrowRenderer_H__ */
--- a/src/client/renderer/entity/ChickenRenderer.cpp
+++ b/src/client/renderer/entity/ChickenRenderer.cpp
@@ -0,0 +1,23 @@
+#include "ChickenRenderer.h"
+#include "../../../util/Mth.h"
+#include "../../../world/entity/animal/Chicken.h"
+
+
+ChickenRenderer::ChickenRenderer( Model* model, float shadow )
+:   super(model, shadow)
+{
+}
+
+void ChickenRenderer::render( Entity* mob, float x, float y, float z, float rot, float a )
+{
+	super::render(mob, x, y, z, rot, a);
+}
+
+float ChickenRenderer::getBob( Mob* mob_, float a )
+{
+	Chicken* mob = (Chicken*) mob_;
+	float flap = mob->oFlap+(mob->flap-mob->oFlap)*a;
+	float flapSpeed = mob->oFlapSpeed+(mob->flapSpeed-mob->oFlapSpeed)*a;
+
+	return (Mth::sin(flap)+1)*flapSpeed;
+}
--- a/src/client/renderer/entity/ChickenRenderer.h
+++ b/src/client/renderer/entity/ChickenRenderer.h
@@ -0,0 +1,22 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ChickenRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ChickenRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "MobRenderer.h"
+
+class Mob;
+
+class ChickenRenderer: public MobRenderer
+{
+    typedef MobRenderer super;
+public:
+    ChickenRenderer(Model* model, float shadow);
+
+    void render(Entity* mob, float x, float y, float z, float rot, float a);
+
+protected:
+    float getBob(Mob* mob_, float a);
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ChickenRenderer_H__*/
--- a/src/client/renderer/entity/CreeperRenderer.h
+++ b/src/client/renderer/entity/CreeperRenderer.h
@@ -0,0 +1,94 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__CreeperRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__CreeperRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "MobRenderer.h"
+
+#include "../../model/CreeperModel.h"
+#include "../../model/Model.h"
+#include "../../../world/entity/monster/Creeper.h"
+#include "../../../util/Mth.h"
+
+class CreeperRenderer: public MobRenderer
+{
+	typedef MobRenderer super;
+public:
+    CreeperRenderer()
+	:	super(new CreeperModel(), 0.5f)
+	{
+    }
+
+protected:
+    void scale(Mob* mob, float a) {
+        Creeper* creeper = (Creeper*) mob;
+
+        float g = creeper->getSwelling(a);
+
+        float wobble = 1.0f + Mth::sin(g * 100) * g * 0.01f;
+        if (g < 0) g = 0;
+        if (g > 1) g = 1;
+        g = g * g;
+        g = g * g;
+        float s = (1.0f + g * 0.4f) * wobble;
+        float hs = (1.0f + g * 0.1f) / wobble;
+        glScalef(s, hs, s);
+    }
+
+    int getOverlayColor(Mob* mob, float br, float a) {
+        Creeper* creeper = (Creeper*) mob;
+
+        float step = creeper->getSwelling(a);
+
+        if ((int) (step * 10) % 2 == 0) return 0;
+
+        int _a = (int) (step * 0.2f * 255);
+        if (_a < 0) _a = 0;
+        if (_a > 255) _a = 255;
+
+        int r = 255;
+        int g = 255;
+        int b = 255;
+
+        return (_a << 24) | (r << 16) | (g << 8) | b;
+    }
+
+  //  int prepareArmor(Mob* mob, int layer, float a) {
+		//Creeper* creeper = (Creeper*) mob;
+  //      if (creeper->isPowered()) {
+  //          if (layer == 1) {
+  //              float time = mob->tickCount + a;
+  //              bindTexture("/armor/power.png");
+  //              glMatrixMode(GL_TEXTURE);
+  //              glLoadIdentity();
+  //              float uo = time * 0.01f;
+  //              float vo = time * 0.01f;
+  //              glTranslatef(uo, vo, 0);
+  //              setArmor(armorModel);
+  //              glMatrixMode(GL_MODELVIEW);
+  //              glEnable(GL_BLEND);
+  //              float br = 0.5f;
+  //              glColor4f2(br, br, br, 1);
+  //              glDisable(GL_LIGHTING);
+  //              glBlendFunc2(GL_ONE, GL_ONE);
+  //              return 1;
+  //          }
+  //          if (layer == 2) {
+  //              glMatrixMode(GL_TEXTURE);
+  //              glLoadIdentity();
+  //              glMatrixMode(GL_MODELVIEW);
+  //              glEnable(GL_LIGHTING);
+  //              glDisable(GL_BLEND);
+  //          }
+  //      }
+  //      return -1;
+  //  }
+
+  //  int prepareArmorOverlay(Mob* mob, int layer, float a) {
+  //      return -1;
+  //  }
+//private:
+    //Model* armorModel = /*new*/ CreeperModel(2);
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__CreeperRenderer_H__*/
--- a/src/client/renderer/entity/EntityRenderDispatcher.cpp
+++ b/src/client/renderer/entity/EntityRenderDispatcher.cpp
@@ -0,0 +1,194 @@
+#include "EntityRenderDispatcher.h"
+
+#include "../../Options.h"
+#include "../../../world/entity/player/Player.h"
+#include "../../../world/item/Item.h"
+#include "../../../world/level/Level.h"
+#include "../../../world/level/tile/Tile.h"
+#include "../../model/ModelInclude.h"
+
+#include "ItemSpriteRenderer.h"
+#include "FallingTileRenderer.h"
+
+#include "HumanoidMobRenderer.h"
+#include "ItemRenderer.h"
+#include "TntRenderer.h"
+#include "TripodCameraRenderer.h"
+#include "PigRenderer.h"
+#include "MobRenderer.h"
+#include "PlayerRenderer.h"
+
+#include "CreeperRenderer.h"
+#include "SpiderRenderer.h"
+
+#include "ChickenRenderer.h"
+#include "SheepRenderer.h"
+#include "ArrowRenderer.h"
+#include "PaintingRenderer.h"
+
+
+/*static*/
+EntityRenderDispatcher* EntityRenderDispatcher::instance = NULL;
+
+/*static*/
+float	EntityRenderDispatcher::xOff = 0,
+		EntityRenderDispatcher::yOff = 0,
+		EntityRenderDispatcher::zOff = 0;
+
+EntityRenderDispatcher::EntityRenderDispatcher()
+:	itemInHandRenderer(NULL)
+{
+	//@note: The Models (model/armor) will be deleted by resp. MobRenderer
+	assign( ER_ITEM_RENDERER,       new ItemRenderer());
+	assign(	ER_HUMANOID_RENDERER,	new HumanoidMobRenderer(new HumanoidModel(), 0));
+	assign(	ER_PIG_RENDERER,		new PigRenderer(new PigModel(), NULL/*new PigModel(0.5f)*/, 0));
+	assign(	ER_COW_RENDERER,		new MobRenderer(new CowModel(), 0));
+	assign(	ER_CHICKEN_RENDERER,	new ChickenRenderer( new ChickenModel(), 0));
+	assign(	ER_SHEEP_RENDERER,	    new SheepRenderer(new SheepModel(), new SheepFurModel(), 0));
+	assign(	ER_SKELETON_RENDERER,	new HumanoidMobRenderer(new SkeletonModel(), 0.5f));
+	assign(	ER_ZOMBIE_RENDERER,		new HumanoidMobRenderer(new ZombieModel(), 0.5f));
+	assign(	ER_CREEPER_RENDERER,	new CreeperRenderer());
+	assign(	ER_SPIDER_RENDERER,		new SpiderRenderer());
+	assign(	ER_TNT_RENDERER,		new TntRenderer());
+	assign(	ER_ARROW_RENDERER,		new ArrowRenderer());
+	assign( ER_PLAYER_RENDERER,		new PlayerRenderer(new HumanoidModel(), 0));
+	assign( ER_THROWNEGG_RENDERER,  new ItemSpriteRenderer(Item::egg->getIcon(0)));
+	assign( ER_SNOWBALL_RENDERER,   new ItemSpriteRenderer(Item::snowBall->getIcon(0)));
+	assign( ER_PAINTING_RENDERER,   new PaintingRenderer());
+	assign( ER_FALLINGTILE_RENDERER,new FallingTileRenderer());
+
+	for (RendererIterator it = _renderers.begin(); it != _renderers.end(); ++it) {
+		it->second->init(this);
+	}
+}
+
+void EntityRenderDispatcher::destroy() 
+{
+	if (instance) {
+		delete instance;
+		instance = NULL;
+	}
+}
+
+EntityRenderDispatcher* EntityRenderDispatcher::getInstance()
+{
+	if (!instance)
+		instance = new EntityRenderDispatcher();
+
+	return instance;
+}
+
+EntityRenderDispatcher::~EntityRenderDispatcher()
+{
+	std::set<EntityRenderer*> destroyed;
+	for (RendererCIterator cit = _renderers.begin(); cit != _renderers.end(); ++cit) {
+		if (destroyed.find(cit->second) == destroyed.end()) {
+			destroyed.insert(cit->second);
+			delete cit->second;
+		}
+	}
+}
+
+void EntityRenderDispatcher::prepare( Level* level, Font* font, Mob* player, Options* options, float a )
+{
+	this->level = level;
+	this->options = options;
+	this->cameraEntity = player;
+	this->_font = font;
+	if(player->isSleeping()) {
+		int t = level->getTile(Mth::floor(player->x), Mth::floor(player->y), Mth::floor(player->z));
+		if (t == Tile::bed->id) {
+			int data = level->getData(Mth::floor(player->x), Mth::floor(player->y), Mth::floor(player->z));
+
+			int direction = data & 3;
+			playerRotY = float(direction * 90 + 180);
+			playerRotX = 0;
+		}
+	}
+	else {
+		playerRotY = player->yRotO + (player->yRot - player->yRotO) * a;
+		playerRotX = player->xRotO + (player->xRot - player->xRotO) * a;
+	}
+	
+	xPlayer = player->xOld + (player->x - player->xOld) * a;
+	yPlayer = player->yOld + (player->y - player->yOld) * a;
+	zPlayer = player->zOld + (player->z - player->zOld) * a;
+}
+
+void EntityRenderDispatcher::render( Entity* entity, float a )
+{
+	float x = entity->xOld + (entity->x - entity->xOld) * a;
+	float y = entity->yOld + (entity->y - entity->yOld) * a;
+	float z = entity->zOld + (entity->z - entity->zOld) * a;
+	float r = entity->yRotO + (entity->yRot - entity->yRotO) * a;
+
+	float br = entity->getBrightness(a);
+	glColor4f2(br, br, br, 1);
+
+	render(entity, x - xOff, y - yOff, z - zOff, r, a);
+}
+
+void EntityRenderDispatcher::render( Entity* entity, float x, float y, float z, float rot, float a )
+{
+	EntityRenderer* renderer = getRenderer(entity);
+	if (renderer != NULL) {
+		renderer->render(entity, x, y, z, rot, a);
+		//renderer->postRender(entity, x, y, z, rot, a);
+	}
+}
+
+EntityRenderer* EntityRenderDispatcher::getRenderer( Entity* entity )
+{
+	EntityRendererId rendererId = entity->entityRendererId;
+
+	if (rendererId == ER_QUERY_RENDERER)
+		rendererId = entity->queryEntityRenderer();
+
+	return getRenderer(rendererId);
+}
+
+EntityRenderer* EntityRenderDispatcher::getRenderer( EntityRendererId rendererId )
+{
+
+	EntityRenderer* renderer = NULL;
+	RendererCIterator cit = _renderers.find(rendererId);
+	if (cit != _renderers.end()) {
+		renderer = cit->second;
+	}
+	return renderer;
+}
+
+void EntityRenderDispatcher::setLevel( Level* level )
+{
+	this->level = level;
+}
+
+void EntityRenderDispatcher::setMinecraft( Minecraft* minecraft )
+{
+	this->minecraft = minecraft;
+}
+
+float EntityRenderDispatcher::distanceToSqr( float x, float y, float z )
+{
+	float xd = x - xPlayer;
+	float yd = y - yPlayer;
+	float zd = z - zPlayer;
+	return xd * xd + yd * yd + zd * zd;
+}
+
+Font* EntityRenderDispatcher::getFont()
+{
+	return _font;
+}
+
+void EntityRenderDispatcher::onGraphicsReset()
+{
+	for (RendererIterator it = _renderers.begin(); it != _renderers.end(); ++it) {
+		it->second->onGraphicsReset();
+	}
+}
+
+void EntityRenderDispatcher::assign( EntityRendererId id, EntityRenderer* renderer )
+{
+	_renderers.insert(std::make_pair(id, renderer));
+}
--- a/src/client/renderer/entity/EntityRenderDispatcher.h
+++ b/src/client/renderer/entity/EntityRenderDispatcher.h
@@ -0,0 +1,76 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__EntityRenderDispatcher_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__EntityRenderDispatcher_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include <map>
+#include "../../../world/entity/EntityRendererId.h"
+
+class EntityRenderer;
+class Level;
+class Font;
+class Textures;
+class ItemInHandRenderer;
+class Minecraft;
+class Textures;
+class Options;
+class Entity;
+class Mob;
+
+class EntityRenderDispatcher
+{
+	typedef std::map<EntityRendererId, EntityRenderer*> RendererMap;
+	typedef RendererMap::iterator RendererIterator;
+	typedef RendererMap::const_iterator RendererCIterator;
+
+public:
+	EntityRenderDispatcher();
+	~EntityRenderDispatcher();
+	static EntityRenderDispatcher* getInstance();
+
+	static void destroy();
+
+    void prepare(Level* level, Font* font, Mob* player, Options* options, float a);
+
+    void render(Entity* entity, float a);
+    void render(Entity* entity, float x, float y, float z, float rot, float a);
+	EntityRenderer* getRenderer( Entity* entity );
+	EntityRenderer* getRenderer( EntityRendererId rendererId );
+
+    void setLevel(Level* level);
+	void setMinecraft(Minecraft* minecraft);
+
+    float distanceToSqr(float x, float y, float z);
+
+    Font* getFont();
+
+	void onGraphicsReset();
+private:
+	void assign(EntityRendererId id, EntityRenderer* renderer);
+public:
+	ItemInHandRenderer* itemInHandRenderer;
+
+	//TripodCameraRenderer tripodCameraRenderer;
+
+	static float xOff, yOff, zOff;
+
+	Textures* textures;
+	Level* level;
+	Minecraft* minecraft;
+	Mob* cameraEntity;
+
+	float playerRotY;
+	float playerRotX;
+	Options* options;
+
+	float xPlayer, yPlayer, zPlayer;
+
+private:
+	static EntityRenderDispatcher* instance;
+
+	Font* _font;
+	// For onGraphicsReset etc
+	RendererMap _renderers;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__EntityRenderDispatcher_H__*/
--- a/src/client/renderer/entity/EntityRenderer.cpp
+++ b/src/client/renderer/entity/EntityRenderer.cpp
@@ -0,0 +1,249 @@
+#include "EntityRenderer.h"
+
+#include "../Tesselator.h"
+#include "../Textures.h"
+#include "../gles.h"
+#include "../../../world/phys/AABB.h"
+#include "EntityRenderDispatcher.h"
+
+EntityRenderDispatcher* EntityRenderer::entityRenderDispatcher = NULL;
+
+EntityRenderer::EntityRenderer()
+:	shadowRadius(0),
+	shadowStrength(1.0f)
+{}
+
+void EntityRenderer::bindTexture(const std::string& resourceName) {
+	entityRenderDispatcher->textures->loadAndBindTexture(resourceName);
+}
+
+//bool bindTexture(std::string urlTexture, std::string backupTexture) {
+//    Textures t = entityRenderDispatcher.textures;
+
+//    int id = t.loadHttpTexture(urlTexture, backupTexture);
+//    if (id >= 0) {
+//        t.bind(id);
+//        return true;
+//    } else {
+//        return false;
+//    }
+//}
+
+/*static*/
+void EntityRenderer::render(const AABB& bb, float xo, float yo, float zo) {
+	glDisable2(GL_TEXTURE_2D);
+	Tesselator& t = Tesselator::instance;
+	glColor4f2(1, 1, 1, 1);
+	t.begin();
+	t.offset(xo, yo, zo);
+	//t.normal(0, 0, -1);
+	t.vertex(bb.x0, bb.y1, bb.z0);
+	t.vertex(bb.x1, bb.y1, bb.z0);
+	t.vertex(bb.x1, bb.y0, bb.z0);
+	t.vertex(bb.x0, bb.y0, bb.z0);
+
+	//t.normal(0, 0, 1);
+	t.vertex(bb.x0, bb.y0, bb.z1);
+	t.vertex(bb.x1, bb.y0, bb.z1);
+	t.vertex(bb.x1, bb.y1, bb.z1);
+	t.vertex(bb.x0, bb.y1, bb.z1);
+
+	//t.normal(0, -1, 0);
+	t.vertex(bb.x0, bb.y0, bb.z0);
+	t.vertex(bb.x1, bb.y0, bb.z0);
+	t.vertex(bb.x1, bb.y0, bb.z1);
+	t.vertex(bb.x0, bb.y0, bb.z1);
+
+	//t.normal(0, 1, 0);
+	t.vertex(bb.x0, bb.y1, bb.z1);
+	t.vertex(bb.x1, bb.y1, bb.z1);
+	t.vertex(bb.x1, bb.y1, bb.z0);
+	t.vertex(bb.x0, bb.y1, bb.z0);
+
+	//t.normal(-1, 0, 0);
+	t.vertex(bb.x0, bb.y0, bb.z1);
+	t.vertex(bb.x0, bb.y1, bb.z1);
+	t.vertex(bb.x0, bb.y1, bb.z0);
+	t.vertex(bb.x0, bb.y0, bb.z0);
+
+	//t.normal(1, 0, 0);
+	t.vertex(bb.x1, bb.y0, bb.z0);
+	t.vertex(bb.x1, bb.y1, bb.z0);
+	t.vertex(bb.x1, bb.y1, bb.z1);
+	t.vertex(bb.x1, bb.y0, bb.z1);
+	t.offset(0, 0, 0);
+	t.draw();
+	glEnable2(GL_TEXTURE_2D);
+	// model.render(0, 1)
+}
+
+/*static*/
+void EntityRenderer::renderFlat(const AABB& bb) {
+	Tesselator& t = Tesselator::instance;
+	t.begin();
+	t.vertex(bb.x0, bb.y1, bb.z0);
+	t.vertex(bb.x1, bb.y1, bb.z0);
+	t.vertex(bb.x1, bb.y0, bb.z0);
+	t.vertex(bb.x0, bb.y0, bb.z0);
+	t.vertex(bb.x0, bb.y0, bb.z1);
+	t.vertex(bb.x1, bb.y0, bb.z1);
+	t.vertex(bb.x1, bb.y1, bb.z1);
+	t.vertex(bb.x0, bb.y1, bb.z1);
+	t.vertex(bb.x0, bb.y0, bb.z0);
+	t.vertex(bb.x1, bb.y0, bb.z0);
+	t.vertex(bb.x1, bb.y0, bb.z1);
+	t.vertex(bb.x0, bb.y0, bb.z1);
+	t.vertex(bb.x0, bb.y1, bb.z1);
+	t.vertex(bb.x1, bb.y1, bb.z1);
+	t.vertex(bb.x1, bb.y1, bb.z0);
+	t.vertex(bb.x0, bb.y1, bb.z0);
+	t.vertex(bb.x0, bb.y0, bb.z1);
+	t.vertex(bb.x0, bb.y1, bb.z1);
+	t.vertex(bb.x0, bb.y1, bb.z0);
+	t.vertex(bb.x0, bb.y0, bb.z0);
+	t.vertex(bb.x1, bb.y0, bb.z0);
+	t.vertex(bb.x1, bb.y1, bb.z0);
+	t.vertex(bb.x1, bb.y1, bb.z1);
+	t.vertex(bb.x1, bb.y0, bb.z1);
+	t.draw();
+}
+
+void EntityRenderer::init(EntityRenderDispatcher* entityRenderDispatcher) {
+	this->entityRenderDispatcher = entityRenderDispatcher;
+}
+
+Font* EntityRenderer::getFont() {
+	return entityRenderDispatcher->getFont();
+}
+
+//void postRender(Entity entity, float x, float y, float z, float rot, float a) {
+//    if (entityRenderDispatcher.options.fancyGraphics && shadowRadius > 0) {
+//        float dist = entityRenderDispatcher.distanceToSqr(entity.x, entity.y, entity.z);
+//        float pow = (float) ((1 - dist / (16.0f * 16.0f)) * shadowStrength);
+//        if (pow > 0) {
+//            renderShadow(entity, x, y, z, pow, a);
+//        }
+//    }
+//    if (entity.isOnFire()) renderFlame(entity, x, y, z, a);
+//}
+
+//void renderFlame(Entity e, float x, float y, float z, float a) {
+//	glDisable2(GL_LIGHTING);
+//	int tex = Tile.fire.tex;
+
+//	int xt = (tex & 0xf) << 4;
+//	int yt = tex & 0xf0;
+
+//	float u0 = (xt) / 256.0f;
+//	float u1 = (xt + 15.99f) / 256.0f;
+//	float v0 = (yt) / 256.0f;
+//	float v1 = (yt + 15.99f) / 256.0f;
+
+//	glPushMatrix2();
+//	glTranslatef2((float) x, (float) y, (float) z);
+
+//	float s = e.bbWidth * 1.4f;
+//	glScalef2(s, s, s);
+//	bindTexture("terrain.png");
+//	Tesselator t = Tesselator.instance;
+
+//	float r = 1.0f;
+//	float xo = 0.5f;
+//	float yo = 0.0f;
+
+//	float h = e.bbHeight / e.bbWidth;
+
+//	glRotatef2(-entityRenderDispatcher.playerRotY, 0, 1, 0);
+//	glTranslatef2(0, 0, -0.4f + ((int) h) * 0.02f);
+//	glColor4f2(1, 1, 1, 1);
+//	// glRotatef2(-playerRotX, 1, 0, 0);
+//	t.begin();
+//	while (h > 0) {
+//		t.vertexUV(r - xo, 0 - yo, 0, u1, v1);
+//		t.vertexUV(0 - xo, 0 - yo, 0, u0, v1);
+//		t.vertexUV(0 - xo, 1.4f - yo, 0, u0, v0);
+//		t.vertexUV(r - xo, 1.4f - yo, 0, u1, v0);
+//		h -= 1;
+//		yo -= 1;
+//		r *= 0.9f;
+//		glTranslatef2(0, 0, -0.04f);
+//	}
+//	t.end();
+//	glPopMatrix2();
+//	glEnable2(GL_LIGHTING);
+//}
+
+//void renderShadow(Entity e, float x, float y, float z, float pow, float a) {
+//	glEnable2(GL_BLEND);
+//	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+//	Textures textures = entityRenderDispatcher.textures;
+//	textures.bind(textures.loadTexture("%clamp%/misc/shadow.png"));
+
+//	Level level = getLevel();
+
+//	glDepthMask(false);
+//	float r = shadowRadius;
+
+//	float ex = e.xOld + (e.x - e.xOld) * a;
+//	float ey = e.yOld + (e.y - e.yOld) * a + e.getShadowHeightOffs();
+//	float ez = e.zOld + (e.z - e.zOld) * a;
+
+//	int x0 = Mth.floor(ex - r);
+//	int x1 = Mth.floor(ex + r);
+//	int y0 = Mth.floor(ey - r);
+//	int y1 = Mth.floor(ey);
+//	int z0 = Mth.floor(ez - r);
+//	int z1 = Mth.floor(ez + r);
+
+//	float xo = x - ex;
+//	float yo = y - ey;
+//	float zo = z - ez;
+
+//	Tesselator tt = Tesselator.instance;
+//	tt.begin();
+//	for (int xt = x0; xt <= x1; xt++)
+//		for (int yt = y0; yt <= y1; yt++)
+//			for (int zt = z0; zt <= z1; zt++) {
+//				int t = level.getTile(xt, yt - 1, zt);
+//				if (t > 0 && level.getRawBrightness(xt, yt, zt) > 3) {
+//					renderTileShadow(Tile.tiles[t], x, y + e.getShadowHeightOffs(), z, xt, yt, zt, pow, r, xo, yo + e.getShadowHeightOffs(), zo);
+//				}
+//			}
+//			tt.end();
+
+//			glColor4f2(1, 1, 1, 1);
+//			glDisable2(GL_BLEND);
+//			glDepthMask(true);
+//}
+
+//Level* getLevel() {
+//	return entityRenderDispatcher.level;
+//}
+
+//void renderTileShadow(Tile tt, float x, float y, float z, int xt, int yt, int zt, float pow, float r, float xo, float yo, float zo) {
+//	Tesselator t = Tesselator.instance;
+//	if (!tt.isCubeShaped()) return;
+
+//	float a = ((pow - (y - (yt + yo)) / 2) * 0.5f) * getLevel().getBrightness(xt, yt, zt);
+//	if (a < 0) return;
+//	if (a > 1) a = 1;
+//	t.color(1, 1, 1, (float) a);
+//	// glColor4f2(1, 1, 1, (float) a);
+
+//	float x0 = xt + tt.xx0 + xo;
+//	float x1 = xt + tt.xx1 + xo;
+//	float y0 = yt + tt.yy0 + yo + 1.0 / 64.0f;
+//	float z0 = zt + tt.zz0 + zo;
+//	float z1 = zt + tt.zz1 + zo;
+
+//	float u0 = (float) ((x - (x0)) / 2 / r + 0.5f);
+//	float u1 = (float) ((x - (x1)) / 2 / r + 0.5f);
+//	float v0 = (float) ((z - (z0)) / 2 / r + 0.5f);
+//	float v1 = (float) ((z - (z1)) / 2 / r + 0.5f);
+
+//	t.vertexUV(x0, y0, z0, u0, v0);
+//	t.vertexUV(x0, y0, z1, u0, v1);
+//	t.vertexUV(x1, y0, z1, u1, v1);
+//	t.vertexUV(x1, y0, z0, u1, v0);
+//}
--- a/src/client/renderer/entity/EntityRenderer.h
+++ b/src/client/renderer/entity/EntityRenderer.h
@@ -0,0 +1,40 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__EntityRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__EntityRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include <string>
+#include "../../model/HumanoidModel.h"
+
+class Textures;
+class Tesselator;
+class EntityRenderDispatcher;
+class Entity;
+class AABB;
+class Font;
+
+class EntityRenderer
+{
+protected:
+	EntityRenderer();
+public:
+    virtual ~EntityRenderer() {}
+	void init(EntityRenderDispatcher* entityRenderDispatcher);
+
+	virtual void render(Entity* entity, float x, float y, float z, float rot, float a) = 0;
+    static void render(const AABB& bb, float xo, float yo, float zo);
+    static void renderFlat(const AABB& bb);
+
+	Font* getFont();
+
+	virtual void onGraphicsReset() {}
+
+protected:
+	void bindTexture(const std::string& resourceName);
+
+	float shadowRadius;
+	float shadowStrength;
+	static EntityRenderDispatcher* entityRenderDispatcher;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__EntityRenderer_H__*/
--- a/src/client/renderer/entity/FallingTileRenderer.cpp
+++ b/src/client/renderer/entity/FallingTileRenderer.cpp
@@ -0,0 +1,32 @@
+#include "FallingTileRenderer.h"
+#include "../TileRenderer.h"
+#include "../../../world/entity/item/FallingTile.h"
+#include "../../../world/level/tile/Tile.h"
+#include "../../../world/level/Level.h"
+
+FallingTileRenderer::FallingTileRenderer() {
+    this->shadowRadius = 0.5f;
+    tileRenderer = new TileRenderer();
+}
+
+FallingTileRenderer::~FallingTileRenderer() {
+    delete tileRenderer;
+}
+
+void FallingTileRenderer::render( Entity* e, float x, float y, float z, float rot, float a ) {
+    FallingTile* tile = (FallingTile*) e;
+
+    glPushMatrix();
+    glTranslatef(x, y, z);
+
+    bindTexture("terrain.png");
+    Tile* tt = Tile::tiles[tile->tile];
+
+    Level* level = tile->getLevel();
+
+    if (tt != NULL) {
+        tileRenderer->renderBlock(tt, level, Mth::floor(tile->x), Mth::floor(tile->y), Mth::floor(tile->z));
+
+    }
+    glPopMatrix();
+}
--- a/src/client/renderer/entity/FallingTileRenderer.h
+++ b/src/client/renderer/entity/FallingTileRenderer.h
@@ -0,0 +1,22 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__FallingTileRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__FallingTileRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "EntityRenderer.h"
+
+class TileRenderer;
+
+class FallingTileRenderer: public EntityRenderer
+{
+    typedef EntityRenderer super;
+public:
+    FallingTileRenderer();
+    ~FallingTileRenderer();
+
+    void render(Entity* e, float x, float y, float z, float rot, float a);
+private:
+    TileRenderer* tileRenderer;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__FallingTileRenderer_H__*/
--- a/src/client/renderer/entity/HumanoidMobRenderer.cpp
+++ b/src/client/renderer/entity/HumanoidMobRenderer.cpp
@@ -0,0 +1,83 @@
+#include "HumanoidMobRenderer.h"
+#include "EntityRenderDispatcher.h"
+#include "../ItemInHandRenderer.h"
+#include "../TileRenderer.h"
+#include "../../model/HumanoidModel.h"
+#include "../../../world/level/tile/Tile.h"
+#include "../../../world/entity/player/Player.h"
+#include "../../../world/entity/player/Inventory.h"
+#include "../../../world/item/ItemInstance.h"
+#include "../../../world/item/Item.h"
+#include "../../../world/item/BowItem.h"
+
+HumanoidMobRenderer::HumanoidMobRenderer(HumanoidModel* humanoidModel, float shadow)
+:	super(humanoidModel, shadow),
+	humanoidModel(humanoidModel)
+{
+}
+
+void HumanoidMobRenderer::renderHand() {
+	humanoidModel->attackTime = 0;
+	humanoidModel->setupAnim(0, 0, 0, 0, 0, 1 / 16.0f);
+
+	//@attn @cuberender @enableClientState @vertexarray
+	glEnableClientState2(GL_VERTEX_ARRAY);
+	glEnableClientState2(GL_TEXTURE_COORD_ARRAY);
+	//glEnableClientState2(GL_COLOR_ARRAY); 
+	humanoidModel->arm0.render(1 / 16.0f);
+	glDisableClientState2(GL_VERTEX_ARRAY);
+	glDisableClientState2(GL_TEXTURE_COORD_ARRAY);
+	//glDisableClientState2(GL_COLOR_ARRAY); 
+}
+
+void HumanoidMobRenderer::additionalRendering(Mob* mob, float a) {
+	ItemInstance* item = mob->getCarriedItem();
+	if (item != NULL && item->count > 0) {
+		glPushMatrix2();
+		humanoidModel->arm0.translateTo(1 / 16.0f);
+		glTranslatef2(-1.0f / 16.0f, 7.0f / 16.0f, 1.0f / 16.0f);
+
+		if (item->id < 256 && TileRenderer::canRender(Tile::tiles[item->id]->getRenderShape())) {
+			float s = 8.0f / 16.0f;
+			glTranslatef2(0.0f, 3.0f / 16.0f, -5 / 16.0f);
+			s *= 0.75f;
+			glRotatef2(20.0f, 1.0f, 0.0f, 0.0f);
+			glRotatef2(45.0f, 0.0f, 1.0f, 0.0f);
+			glScalef2(s, -s, s);
+		} else if (item->id == Item::bow->id) {
+			const float s = 10.0f / 16.0f;
+			glTranslatef2(0 / 16.0f, 2 / 16.0f, 5 / 16.0f);
+			glRotatef2(-20, 0, 1, 0);
+			glScalef2(s, -s, s);
+			glRotatef2(-100, 1, 0, 0);
+			glRotatef2(45, 0, 1, 0);
+		} else if (Item::items[item->id]->isHandEquipped()) {
+			float s = 10.0f / 16.0f;
+			glTranslatef2(0.0f, 3.0f / 16.0f, 0.0f);
+			glScalef2(s, -s, s);
+			glRotatef2(-100.0f, 1.0f, 0.0f, 0.0f);
+			glRotatef2(45.0f, 0.0f, 1.0f, 0.0f);
+		} else {
+			float s = 6 / 16.0f;
+			glTranslatef2(+4 / 16.0f, +3 / 16.0f, -3 / 16.0f);
+			glScalef2(s, s, s);
+			glRotatef2(60.0f, 0.0f, 0.0f, 1.0f);
+			glRotatef2(-90.0f, 1.0f, 0.0f, 0.0f);
+			glRotatef2(20.0f, 0.0f, 0.0f, 1.0f);
+		}
+		entityRenderDispatcher->itemInHandRenderer->renderItem(mob, item);
+		glPopMatrix2();
+	}
+}
+
+void HumanoidMobRenderer::render( Entity* mob_, float x, float y, float z, float rot, float a ) {
+	Mob* mob = (Mob*)mob_;
+	ItemInstance* carriedItem = mob->getCarriedItem();
+	if(carriedItem != NULL)
+		humanoidModel->holdingRightHand = true;
+
+	humanoidModel->sneaking = mob->isSneaking();
+
+	super::render(mob_, x, y, z, rot, a);
+	humanoidModel->holdingRightHand = false;
+}
--- a/src/client/renderer/entity/HumanoidMobRenderer.h
+++ b/src/client/renderer/entity/HumanoidMobRenderer.h
@@ -0,0 +1,26 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__HumanoidMobRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__HumanoidMobRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "MobRenderer.h"
+
+class HumanoidModel;
+class Mob;
+
+class HumanoidMobRenderer: public MobRenderer
+{
+	typedef MobRenderer super;
+public:
+    HumanoidMobRenderer(HumanoidModel* humanoidModel, float shadow);
+
+	void renderHand();
+	void render(Entity* mob_, float x, float y, float z, float rot, float a);
+protected:
+    void additionalRendering(Mob* mob, float a);
+
+private:
+	HumanoidModel* humanoidModel;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__HumanoidMobRenderer_H__*/
--- a/src/client/renderer/entity/ItemRenderer.cpp
+++ b/src/client/renderer/entity/ItemRenderer.cpp
@@ -0,0 +1,321 @@
+#include "ItemRenderer.h"
+#include "EntityRenderDispatcher.h"
+#include "../Tesselator.h"
+#include "../TileRenderer.h"
+#include "../Textures.h"
+#include "../../gui/Font.h"
+#include "../../../world/entity/item/ItemEntity.h"
+#include "../../../world/item/ItemInstance.h"
+#include "../../../world/level/tile/Tile.h"
+#include "../../../util/Mth.h"
+#include "../../../util/Random.h"
+#include "EntityRenderer.h"
+#include "../ItemInHandRenderer.h"
+#include "../../gui/Gui.h"
+#include "../../../world/item/Item.h"
+
+/*static*/
+TileRenderer* ItemRenderer::tileRenderer = new TileRenderer();
+
+ItemRenderer::ItemRenderer()
+{
+	shadowRadius = 0.15f;
+	shadowStrength = 0.75f;
+}
+
+void ItemRenderer::teardown_static() {
+	if (tileRenderer) {
+		delete tileRenderer;
+		tileRenderer = NULL;
+	}
+}
+
+void ItemRenderer::render(Entity* itemEntity_, float x, float y, float z, float rot, float a) {
+	ItemEntity* itemEntity = (ItemEntity*) itemEntity_;
+	random.setSeed(187);
+	ItemInstance* item = &itemEntity->item;
+
+	glPushMatrix2();
+	float bob = Mth::sin((itemEntity->age + a) / 10.0f + itemEntity->bobOffs) * 0.1f + 0.1f;
+	float spin = ((itemEntity->age + a) / 20.0f + itemEntity->bobOffs) * Mth::RADDEG;
+
+	int count = 1;
+	if (item->count > 20) count = 4;
+	else if (item->count > 5) count = 3;
+	else if (item->count > 1) count = 2;
+
+	glTranslatef2((float) x, (float) y + bob, (float) z);
+	//glEnable2(GL_RESCALE_NORMAL);
+	if (item->id < 256 && TileRenderer::canRender(Tile::tiles[item->id]->getRenderShape())) {
+		glRotatef2(spin, 0, 1, 0);
+
+		float br = itemEntity->getBrightness(a);
+		if (item->id == Tile::sand->id || item->id == Tile::sandStone->id) br *= 0.8f;
+		glColor4f2(br, br, br, 1.0f);
+
+		bindTexture("terrain.png");
+		float s = 1 / 4.0f;
+		//if (!Tile::tiles[item->id]->isCubeShaped() && item->id != Tile::stoneSlabHalf->id) {
+		const int shape = Tile::tiles[item->id]->getRenderShape();
+		if (shape == Tile::SHAPE_CROSS_TEXTURE || shape == Tile::SHAPE_TORCH)
+			s = 0.5f;
+
+		glScalef2(s, s, s);
+		for (int i = 0; i < count; i++) {
+			if (i > 0) {
+				glPushMatrix2();
+				float xo = (random.nextFloat() * 2 - 1) * 0.2f / s;
+				float yo = (random.nextFloat() * 2 - 1) * 0.2f / s;
+				float zo = (random.nextFloat() * 2 - 1) * 0.2f / s;
+				glTranslatef2(xo, yo, zo);
+			}
+			//static Stopwatch w;
+			//w.start();
+			entityRenderDispatcher->itemInHandRenderer->renderItem(NULL, item);
+			//tileRenderer->renderTile(Tile::tiles[item->id], item->getAuxValue());
+			//w.stop();
+			//w.printEvery(100, "render-item");
+			if (i > 0) glPopMatrix2();
+		}
+	} else {
+		glScalef2(1 / 2.0f, 1 / 2.0f, 1 / 2.0f);
+		int icon = item->getIcon();
+		if (item->id < 256) {
+			bindTexture("terrain.png");
+		} else {
+			bindTexture("gui/items.png");
+		}
+		Tesselator& t = Tesselator::instance;
+
+		float u0 = ((icon % 16) * 16 + 0) / 256.0f;
+		float u1 = ((icon % 16) * 16 + 16) / 256.0f;
+		float v0 = ((icon / 16) * 16 + 0) / 256.0f;
+		float v1 = ((icon / 16) * 16 + 16) / 256.0f;
+
+		float r = 1.0f;
+		float xo = 0.5f;
+		float yo = 0.25f;
+
+		// glRotatef2(-playerRotX, 1, 0, 0);
+		for (int i = 0; i < count; i++) {
+			glPushMatrix2();
+			if (i > 0) {
+				float _xo = (random.nextFloat() * 2 - 1) * 0.3f;
+				float _yo = (random.nextFloat() * 2 - 1) * 0.3f;
+				float _zo = (random.nextFloat() * 2 - 1) * 0.3f;
+				glTranslatef2(_xo, _yo, _zo);
+			}
+			glRotatef2(180 - entityRenderDispatcher->playerRotY, 0, 1, 0);
+			t.begin();
+			//t.normal(0, 1, 0);
+			t.vertexUV(0 - xo, 0 - yo, 0, u0, v1);
+			t.vertexUV(r - xo, 0 - yo, 0, u1, v1);
+			t.vertexUV(r - xo, 1 - yo, 0, u1, v0);
+			t.vertexUV(0 - xo, 1 - yo, 0, u0, v0);
+			//t.end();
+			t.draw();
+
+			glPopMatrix2();
+		}
+	}
+	//glDisable2(GL_RESCALE_NORMAL);
+	glPopMatrix2();
+}
+
+
+// @note: _18 -> a,b,c,-1,   a,b,c-1, ...
+static const signed short _6[] = {139, 140, 141, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+static const signed short _17[] = {16, 17, 18, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+static const signed short _18[] = {79, 80, 81, -1, 79, 80, 81, -1, 79, 80, 81, -1, 79, 80, 81, -1};
+static const signed short _24[] = {11, 12, 13, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+static const signed short _35[] = {52, 59, 58, 57, 56, 55, 54, 53, 67, 66, 65, 64, 63, 62, 61, 60};
+static const signed short _44[] = {28, 32, 30, 29, 31, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+static const signed short _98[] = {1, 2, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+static const signed short _155[] = {34, 36, 35, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+static const signed short _263[] = {230, 151, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+static const signed short _351[] = {-1, 152, 154, -1, 193, 215, 216, -1, -1, 217, 218, 219, 220, 221, 222, 144};
+
+static const signed short _mapper[] = {-1, 7, 9, 8, 0, 5, -2, -1, -1, -1, -1, -1, 14, 15, 39, 38, 37, -2, -2, -1, 49, 41, 46, -1, -2, -1, -1, -1, -1, -1, 235, -1, -1, -1, -1, -2, -1, 134, 135, 136, 137, 43, 44, -1, -2, 6, 76, 71, 4, 47, 129, -1, -1, 22, 74, -1, 40, 45, 72, -1, -1, 75, -1, -1, -1, 128, -1, 21, -1, -1, -1, -1, -1, 42, -1, -1, -1, -1, -1, -1, 48, 77, 10, 236, -1, 69, -1, 20, -1, 50, -1, -1, -1, -1, -1, -1, 68, -1, -2, -1, -1, -1, 130, 78, -1, -1, -1, 70, 23, 25, -1, -1, 19, -1, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 24, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, 27, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 73, -1, 51, -1, -1, -1, -1, -1, 82, -1, -1, 174, 173, 175, 231, 234, 147, 190, -2, 153, 150, 149, 146, 185, 166, 164, 167, 186, 170, 169, 171, 187, 177, 176, 178, 165, 195, 194, 188, 181, 180, 182, 189, 191, 228, 168, 172, 145, 179, 183, 142, 233, 232, 198, 200, 201, 202, -1, -1, -1, -1, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 192, 156, 157, 133, -1, 148, 131, -1, -1, -1, -1, -1, -1, -1, 226, -1, 199, -1, 159, 158, 138, 224, 225, -1, -1, -1, -1, -1, -1, -1, 227, -1, -1, -2, 223, 229, -1, 132, -1, -1, -1, 184, 196, -1, 143, 160, 161, 162, 163, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 155, 197};
+
+#define IRMAPCASE(x) case x: return  _##x [item->getAuxValue() & 15]
+
+int ItemRenderer::getAtlasPos(const ItemInstance* item) {
+	int id = item->id;
+	if (id < 0 || id >= sizeof(_mapper) / sizeof(const signed short))
+		return -1;
+
+	int texId = _mapper[id];
+	if (texId != -2)
+		return texId;
+
+	switch(id) {
+		IRMAPCASE(6);
+		IRMAPCASE(17);
+		IRMAPCASE(18);
+		IRMAPCASE(24);
+		IRMAPCASE(35);
+		IRMAPCASE(44);
+		IRMAPCASE(98);
+		IRMAPCASE(155);
+		IRMAPCASE(263);
+		IRMAPCASE(351);
+	default:
+		break;
+	}
+	return -1;
+}
+
+/*static*/
+void ItemRenderer::renderGuiItem(Font* font, Textures* textures, const ItemInstance* item, float x, float y, bool fancy) {
+	renderGuiItem(font, textures, item, x, y, 16, 16, fancy);
+}
+void ItemRenderer::renderGuiItem(Font* font, Textures* textures, const ItemInstance* item, float x, float y, float w, float h, bool fancy) {
+	if (item == NULL) {
+		//LOGW("item is NULL @ ItemRenderer::renderGuiItem\n");
+		return;
+	}
+	const int id = item->id;
+	if (!Item::items[id])
+		return;
+
+	int i = getAtlasPos(item);
+
+	if (i < 0) {
+		Tesselator& t = Tesselator::instance;
+		if (!t.isOverridden())
+			renderGuiItemCorrect(font, textures, item, int(x), int(y));
+		else {
+			// @huge @attn @todo @fix:	This is just guess-works..
+			//							it we're batching for saving the
+			//							buffer, this will fail miserably
+			t.endOverrideAndDraw();
+			glDisable2(GL_TEXTURE_2D);
+			fillRect(t, x, y, w, h, 0xff0000);
+			glEnable2(GL_TEXTURE_2D);
+			renderGuiItemCorrect(font, textures, item, int(x), int(y));
+			t.beginOverride();
+		}
+		return;
+	}
+
+	textures->loadAndBindTexture("gui/gui_blocks.png");
+	float u0, u1, v0, v1;
+	if (i < 128) {
+		const float P = 48.0f / 512.0f;
+		u0 = (float)(i%10) * P;
+		v0 = (float)(i/10) * P;
+		u1 = u0 + P;
+		v1 = v0 + P;
+	} else {
+		i -= 128;
+		const float P = 16.0f / 512.0f;
+		u0 = float(i & 31) * P;
+		v0 = 27 * P + float(i >> 5) * P; // 27 "icon" rows down
+		u1 = u0 + P;
+		v1 = v0 + P;
+	}
+
+	const float blitOffset = 0;
+	Tesselator& t = Tesselator::instance;
+	t.begin();
+	t.colorABGR( item->count>0? 0xffffffff : 0x60ffffff);
+	t.vertexUV(x,     y + h, blitOffset, u0, v1);
+	t.vertexUV(x + w, y + h, blitOffset, u1, v1);
+	t.vertexUV(x + w, y,     blitOffset, u1, v0);
+	t.vertexUV(x,     y,     blitOffset, u0, v0);
+	t.draw();
+}
+
+void ItemRenderer::renderGuiItemDecorations(const ItemInstance* item, float x, float y) {
+	if (!item) return;
+	if (item->count > 0 && item->isDamaged()) {
+		float p = std::floor(13.5f - (float) item->getDamageValue() * 13.0f / (float) item->getMaxDamage());
+		int cc = (int) std::floor(255.5f - (float) item->getDamageValue() * 255.0f / (float) item->getMaxDamage());
+		//glDisable(GL_LIGHTING);
+		//glDisable(GL_DEPTH_TEST);
+		//glDisable(GL_TEXTURE_2D);
+
+		Tesselator& t = Tesselator::instance;
+
+		int ca = (255 - cc) << 16 | (cc) << 8;
+		int cb = ((255 - cc) / 4) << 16 | (255 / 4) << 8;
+		fillRect(t, x + 2, y + 13, 13, 1, 0x000000);
+		fillRect(t, x + 2, y + 13, 12, 1, cb);
+		fillRect(t, x + 2, y + 13, p, 1, ca);
+
+		//glEnable(GL_TEXTURE_2D);
+		//glEnable(GL_LIGHTING);
+		//glEnable(GL_DEPTH_TEST);
+		glColor4f2(1, 1, 1, 1);
+	}
+}
+
+void ItemRenderer::fillRect(Tesselator& t, float x, float y, float w, float h, int c) {
+	t.begin();
+	t.color(c);
+	t.vertex(x + 0, y + 0, 0);
+	t.vertex(x + 0, y + h, 0);
+	t.vertex(x + w, y + h, 0);
+	t.vertex(x + w, y + 0, 0);
+	t.draw();
+}
+
+
+void ItemRenderer::renderGuiItemCorrect(Font* font, Textures* textures, const ItemInstance* item, int x, int y) {
+	if (item == NULL)
+		return;
+
+	//glDisable(GL_CULL_FACE);
+	if (item->id < 256 && TileRenderer::canRender(Tile::tiles[item->id]->getRenderShape()))
+	{
+		int paint = item->id;
+		textures->loadAndBindTexture("terrain.png");
+
+		static float ff = 0;// ff += 0.005f;
+		static float gg = 0;// gg += 0.01f;
+
+		Tile* tile = Tile::tiles[paint];
+		glPushMatrix2();
+		glTranslatef2((GLfloat)(x - 2), (GLfloat)(y + 3), -8);
+		glScalef2(10.0f, 10.0f, 10.0f);
+		glTranslatef2(1.0f, 0.5f, 0.0f);
+		glRotatef2(ff + 180.0f + 30.0f, 1, 0, 0);
+		glRotatef2(gg + 45.0f, 0, 1, 0);
+
+		//glColor4f2(1, 1, 1, 1);
+		glScalef2(1, 1, 1);
+		tileRenderer->renderGuiTile(tile, item->getAuxValue());
+		glPopMatrix2();
+	}
+	else if (item->getIcon() >= 0)
+	{
+		//if (item->id == Item::camera->id) {
+		//	printf("item->id: %d, %d\n", item->id, item->getIcon());
+		//}
+		if (item->id < 256) {
+			textures->loadAndBindTexture("terrain.png");
+		} else {
+			textures->loadAndBindTexture("gui/items.png");
+		}
+		//Tesselator& t = Tesselator::instance;
+		//t.scale2d(Gui::InvGuiScale, Gui::InvGuiScale);
+		blit((float)x, (float)y, (float)(item->getIcon() % 16 * 16), (float)(item->getIcon() / 16 * 16), 16, 16);
+		//t.resetScale();
+	}
+	//glEnable(GL_CULL_FACE);
+}
+
+/*static*/
+void ItemRenderer::blit(float x, float y, float sx, float sy, float w, float h) {
+	float blitOffset = 0;
+	const float us = 1 / 256.0f;
+	const float vs = 1 / 256.0f;
+	Tesselator& t = Tesselator::instance;
+	t.begin();
+	t.vertexUV(x, y + h, blitOffset, sx * us, (sy + h) * vs);
+	t.vertexUV(x + w, y + h, blitOffset, (sx + w) * us, (sy + h) * vs);
+	t.vertexUV(x + w, y, blitOffset, (sx + w) * us, sy * vs);
+	t.vertexUV(x, y, blitOffset, sx * us, sy * vs);
+	//t.end();
+	t.draw();
+}
--- a/src/client/renderer/entity/ItemRenderer.h
+++ b/src/client/renderer/entity/ItemRenderer.h
@@ -0,0 +1,38 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ItemRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ItemRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "EntityRenderer.h"
+#include "../../../util/Random.h"
+
+class Font;
+class Entity;
+class ItemInstance;
+class Textures;
+class Tesselator;
+class TileRenderer;
+
+class ItemRenderer: public EntityRenderer
+{
+public:
+    ItemRenderer();
+
+    void render(Entity* itemEntity_, float x, float y, float z, float rot, float a);
+    static void renderGuiItem(Font* font, Textures* textures, const ItemInstance* item, float x, float y, bool fancy);
+	static void renderGuiItem(Font* font, Textures* textures, const ItemInstance* item, float x, float y, float w, float h, bool fancy);
+	static void renderGuiItemCorrect(Font* font, Textures* textures, const ItemInstance* item, int x, int y);
+	//void renderGuiItemDecorations(Font* font, Textures* textures, ItemInstance* item, int x, int y);
+	static void renderGuiItemDecorations(const ItemInstance* item, float x, float y);
+
+	static void blit(float x, float y, float sx, float sy, float w, float h);
+	static int  getAtlasPos(const ItemInstance* item);
+
+	static void teardown_static();
+private:
+	static void fillRect(Tesselator& t, float x, float y, float w, float h, int c);
+	static TileRenderer* tileRenderer;
+	Random random;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ItemRenderer_H__*/
--- a/src/client/renderer/entity/ItemSpriteRenderer.cpp
+++ b/src/client/renderer/entity/ItemSpriteRenderer.cpp
@@ -0,0 +1,41 @@
+#include "ItemSpriteRenderer.h"
+#include "EntityRenderDispatcher.h"
+#include "../Tesselator.h"
+#include "../../../world/entity/Entity.h"
+
+
+ItemSpriteRenderer::ItemSpriteRenderer( int icon )
+:	icon(icon)
+{
+}
+
+void ItemSpriteRenderer::render( Entity* e, float x, float y, float z, float rot, float a )
+{
+	glPushMatrix2();
+
+	glTranslatef2((float) x, (float) y, (float) z);
+	glScalef2(1 / 2.0f, 1 / 2.0f, 1 / 2.0f);
+	bindTexture("gui/items.png");
+	Tesselator& t = Tesselator::instance;
+
+	float u0 = ((icon % 16) * 16 + 0) / 256.0f;
+	float u1 = ((icon % 16) * 16 + 16) / 256.0f;
+	float v0 = ((icon / 16) * 16 + 0) / 256.0f;
+	float v1 = ((icon / 16) * 16 + 16) / 256.0f;
+
+
+	float r = 1.0f;
+	float xo = 0.5f;
+	float yo = 0.25f;
+
+	glRotatef2(180 - entityRenderDispatcher->playerRotY, 0, 1, 0);
+	glRotatef2(-entityRenderDispatcher->playerRotX, 1, 0, 0);
+	t.begin();
+	t.vertexUV(0 - xo, 0 - yo, 0, u0, v1);
+	t.vertexUV(r - xo, 0 - yo, 0, u1, v1);
+	t.vertexUV(r - xo, 1 - yo, 0, u1, v0);
+	t.vertexUV(0 - xo, 1 - yo, 0, u0, v0);
+	t.draw();
+
+	glPopMatrix2();
+}
--- a/src/client/renderer/entity/ItemSpriteRenderer.h
+++ b/src/client/renderer/entity/ItemSpriteRenderer.h
@@ -0,0 +1,18 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ItemSpriteRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ItemSpriteRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "EntityRenderer.h"
+
+class ItemSpriteRenderer: public EntityRenderer
+{
+public:
+    ItemSpriteRenderer(int icon);
+
+	void render(Entity* e, float x, float y, float z, float rot, float a);
+private:
+	int icon;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__ItemSpriteRenderer_H__*/
--- a/src/client/renderer/entity/MobRenderer.cpp
+++ b/src/client/renderer/entity/MobRenderer.cpp
@@ -0,0 +1,241 @@
+#include "MobRenderer.h"
+#include "EntityRenderDispatcher.h"
+#include "../../gui/Font.h"
+#include "../Tesselator.h"
+#include "../../Minecraft.h"
+#include "../../model/Model.h"
+#include "../../../world/entity/Mob.h"
+#include "../../../util/Mth.h"
+
+MobRenderer::MobRenderer(Model* model, float shadow)
+:	model(model),
+	armor(NULL)
+{
+	shadowRadius = shadow;
+}
+
+MobRenderer::~MobRenderer() {
+	delete model;
+}
+
+void MobRenderer::setArmor(Model* armor) {
+	this->armor = armor;
+}
+
+Model* MobRenderer::getArmor() {
+	return armor;
+}
+
+void MobRenderer::render(Entity* e, float x, float y, float z, float rot, float a)
+{
+	Mob* mob = (Mob*) e;
+
+	glPushMatrix2();
+	glDisable2(GL_CULL_FACE);
+
+	model->attackTime = getAttackAnim(mob, a);
+	model->riding = false;//mob.isRiding();
+	model->young = mob->isBaby();
+
+	if (armor) {
+		armor->riding = model->riding;
+		armor->young  = model->young;
+		armor->attackTime = model->attackTime;
+	}
+
+	float bodyRot = (mob->yBodyRotO + (mob->yBodyRot - mob->yBodyRotO) * a);
+	float headRot = (mob->yRotO + (mob->yRot - mob->yRotO) * a);
+	float headRotx = (mob->xRotO + (mob->xRot - mob->xRotO) * a);
+
+	float yoffset = mob->heightOffset;
+	setupPosition(mob, x, y - yoffset, z);
+
+	float bob = getBob(mob, a);
+	setupRotations(mob, bob, bodyRot, a);
+
+	float ascale = 1 / 16.0f;
+	glScalef2(-1, -1, 1);
+
+	scale(mob, a);
+	glTranslatef2(0, -24 * ascale - 0.125f / 16.0f, 0);
+
+	float ws = mob->walkAnimSpeedO + (mob->walkAnimSpeed - mob->walkAnimSpeedO) * a;
+	float wp = mob->walkAnimPos - mob->walkAnimSpeed * (1 - a);
+	if (mob->isBaby()) {
+		wp *= 3.0f;
+	}
+
+	if (ws > 1) ws = 1;
+
+	bindTexture(mob->getTexture());
+	//glEnable2(GL_ALPHA_TEST);
+
+	model->prepareMobModel(mob, wp, ws, a);
+	model->render(e, wp, ws, bob, headRot - bodyRot, headRotx, ascale);
+
+	for (int i = 0; i < MAX_ARMOR_LAYERS; i++) {
+		if (prepareArmor(mob, i, a) < 0) continue;
+
+		armor->prepareMobModel(mob, wp, ws, a);
+		armor->render(e, wp, ws, bob, headRot - bodyRot, headRotx, ascale);
+		glDisable2(GL_BLEND);
+		glEnable2(GL_ALPHA_TEST);
+	}
+
+	additionalRendering(mob, a);
+	float br = mob->getBrightness(a);
+	int overlayColor = getOverlayColor(mob, br, a);
+
+	bool renderOverlay = ((overlayColor >> 24) & 0xff) > 0;
+	bool renderHurt = (mob->hurtTime > 0) || (mob->deathTime > 0);
+
+	if (renderOverlay || renderHurt) {
+		glDisable2(GL_TEXTURE_2D);
+		glDisable2(GL_ALPHA_TEST);
+		glEnable2(GL_BLEND);
+		glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		glDepthFunc(GL_EQUAL);
+
+		if (renderHurt) {
+			glEnable(GL_COLOR_MATERIAL);
+			glColor4f2(br, 0, 0, 0.4f);
+			model->render(e, wp, ws, bob, headRot - bodyRot, headRotx, ascale);
+			for (int i = 0; i < MAX_ARMOR_LAYERS; i++) {
+				if (prepareArmor(mob, i, a) < 0) continue;
+
+				glColor4f2(br, 0, 0, 0.4f);
+				armor->prepareMobModel(mob, wp, ws, a);
+				armor->render(e, wp, ws, bob, headRot - bodyRot, headRotx, ascale);
+			}
+		}
+
+		if (renderOverlay) {
+			float r = ((overlayColor >> 16) & 0xff) / 255.0f;
+			float g = ((overlayColor >> 8) & 0xff) / 255.0f;
+			float b = ((overlayColor) & 0xff) / 255.0f;
+			float aa = ((overlayColor >> 24) & 0xff) / 255.0f;
+			glColor4f2(r, g, b, aa);
+			model->render(e, wp, ws, bob, headRot - bodyRot, headRotx, ascale);
+			for (int i = 0; i < MAX_ARMOR_LAYERS; i++) {
+				if (prepareArmor(mob, i, a) < 0) continue;
+
+				glColor4f2(r, g, b, aa);
+				armor->prepareMobModel(mob, wp, ws, a);
+				armor->render(e, wp, ws, bob, headRot - bodyRot, headRotx, ascale);
+			}
+		}
+
+		glDepthFunc(GL_LEQUAL);
+		glDisable2(GL_BLEND);
+		glEnable2(GL_ALPHA_TEST);
+		glEnable2(GL_TEXTURE_2D);
+	}
+
+	glEnable2(GL_CULL_FACE);
+	//glEnable2(GL_DEPTH_TEST);
+
+	glPopMatrix2();
+
+	renderName(mob, x, y, z);
+}
+
+void MobRenderer::setupPosition(Entity* mob, float x, float y, float z) {
+	glTranslatef2((float) x, (float) y, (float) z);
+}
+
+void MobRenderer::setupRotations(Entity* mob_, float bob, float bodyRot, float a) {
+	glRotatef2(180 - bodyRot, 0, 1, 0);
+
+	Mob* mob = (Mob*)mob_;
+	if (mob->deathTime > 0) {
+		float fall = (mob->deathTime + a - 1) / 20.0f * 1.6f;
+		fall = Mth::sqrt(fall);
+		if (fall > 1) fall = 1;
+		glRotatef2(fall * getFlipDegrees(mob), 0, 0, 1);
+	}
+}
+
+float MobRenderer::getAttackAnim(Mob* mob, float a) {
+	return mob->getAttackAnim(a);
+}
+
+float MobRenderer::getBob(Mob* mob, float a) {
+	return (mob->tickCount + a);
+}
+
+void MobRenderer::additionalRendering(Mob* mob, float a) {
+}
+
+void MobRenderer::onGraphicsReset() {
+	if (model) model->onGraphicsReset();
+	if (armor) armor->onGraphicsReset();
+}
+
+int MobRenderer::prepareArmor(Mob* mob, int layer, float a) {
+	return -1;
+}
+
+float MobRenderer::getFlipDegrees(Mob* mob) {
+	return 90;
+}
+
+int MobRenderer::getOverlayColor(Mob* mob, float br, float a) {
+	return 0;
+}
+
+void MobRenderer::scale(Mob* mob, float a) {
+}
+
+void MobRenderer::renderName(Mob* mob, float x, float y, float z) {
+	/*
+	std::stringstream ss; ss << mob->entityId;
+	renderNameTag(mob, ss.str(), x, y, z, 64);
+	*/
+}
+
+void MobRenderer::renderNameTag(Mob* mob, const std::string& name, float x, float y, float z, int maxDist) {
+	float dist = mob->distanceToSqr(entityRenderDispatcher->cameraEntity);
+
+	if (dist > maxDist*maxDist)
+		return;
+
+	Font* font = getFont();
+
+	float size = 1.60f;
+	float s = 1 / 60.0f * size;
+
+	glPushMatrix2();
+	glTranslatef2((float) x + 0, (float) y + 1.0f /*2.3f*/, (float) z);
+
+	glRotatef2(-entityRenderDispatcher->playerRotY, 0, 1, 0);
+	glRotatef2(entityRenderDispatcher->playerRotX, 1, 0, 0);
+
+	glScalef2(-s, -s, s);
+
+	glDepthMask(false);
+	glDisable2(GL_DEPTH_TEST);
+	glEnable2(GL_BLEND);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	Tesselator& t = Tesselator::instance;
+
+	glDisable2(GL_TEXTURE_2D);
+	t.begin();
+	int w = font->width(name) / 2;
+	t.color(0.0f, 0.0f, 0.0f, 0.25f);
+	t.vertex(-(float)w - 1, -1, 0);
+	t.vertex(-(float)w - 1, +8, 0);
+	t.vertex(+(float)w + 1, +8, 0);
+	t.vertex(+(float)w + 1, -1, 0);
+	//t.end();
+	t.draw();
+	glEnable2(GL_TEXTURE_2D);
+	const float fnameWidth = (float)font->width(name) / -2;
+	font->draw(name, fnameWidth, 0, 0x20ffffff);
+	glEnable2(GL_DEPTH_TEST);
+
+	glDepthMask(true);
+	font->draw(name, (float) fnameWidth, 0, 0xffffffff);
+	glDisable2(GL_BLEND);
+	glColor4f2(1, 1, 1, 1);
+	glPopMatrix2();
+}
--- a/src/client/renderer/entity/MobRenderer.h
+++ b/src/client/renderer/entity/MobRenderer.h
@@ -0,0 +1,51 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__MobRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__MobRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "EntityRenderer.h"
+
+#include <string>
+
+class Model;
+class Entity;
+class Mob;
+
+class MobRenderer: public EntityRenderer
+{
+	static const int MAX_ARMOR_LAYERS = 4;
+public:
+	// @note: MobRenderer::model will be deleted automagically
+	// Armor models (setArmor(Model*)) is to be deleted by derived classes.
+    MobRenderer(Model* model, float shadow);
+	~MobRenderer();
+
+	virtual int prepareArmor(Mob* mob, int layer, float a);
+
+	virtual void setupPosition(Entity* mob, float x, float y, float z);
+    virtual void setupRotations(Entity* mob_, float bob, float bodyRot, float a);
+
+    virtual float getAttackAnim(Mob* mob, float a);
+    virtual float getBob(Mob* mob, float a);
+
+    virtual float getFlipDegrees(Mob* mob);
+
+    virtual int getOverlayColor(Mob* mob, float br, float a);
+
+    virtual void scale(Mob* mob, float a);
+
+	virtual void render(Entity* mob_, float x, float y, float z, float rot, float a);
+	virtual void renderName(Mob* mob, float x, float y, float z);
+	virtual void renderNameTag(Mob* mob, const std::string& name, float x, float y, float z, int maxDist);
+	virtual void additionalRendering(Mob* mob, float a);
+
+	virtual void onGraphicsReset();
+protected:
+	void setArmor(Model* armor);
+	Model* getArmor();
+private:
+	Model* model;
+	Model* armor;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__MobRenderer_H__*/
--- a/src/client/renderer/entity/PaintingRenderer.cpp
+++ b/src/client/renderer/entity/PaintingRenderer.cpp
@@ -0,0 +1,99 @@
+#include "PaintingRenderer.h"
+#include "../../../world/entity/Painting.h"
+#include "../../../world/Direction.h"
+#include "../Tesselator.h"
+#include "../Textures.h"
+#include "../gles.h"
+
+void PaintingRenderer::render( Entity* entity, float x, float y, float z, float rot, float a ) {
+	glPushMatrix();
+	glTranslatef(float(x), float(y), float(z));
+	glRotatef(rot, 0, 1.0f, 0);
+	//glEnable(GL_RESCALE_NORMAL);
+	bindTexture("art/kz.png");
+	Painting* painting = (Painting*)entity;
+	const Motive* motive = painting->motive;
+
+	float s = 1.0f / 16.0f;
+	glScalef(s, s, s);
+	renderPainting(painting, motive->w, motive->h, motive->uo, motive->vo, a);
+	//glDisable(GL_RESCALE_NORMAL);
+	glPopMatrix();
+}
+
+void PaintingRenderer::renderPainting( Painting* painting, int w, int h, int uo, int vo, float a) {
+	float xx0 = -w / 2.0f;
+	float yy0 = -h / 2.0f;
+
+	float edgeWidth = 0.5f;
+
+	// Back
+	float bu0 = (12 * 16) / 256.0f;
+	float bu1 = (12 * 16 + 16) / 256.0f;
+	float bv0 = (0) / 256.0f;
+	float bv1 = (0 + 16) / 256.0f;
+
+	// Border
+	float uu0 = (12 * 16) / 256.0f;
+	float uu1 = (12 * 16 + 16) / 256.0f;
+	float uv0 = (0.5f) / 256.0f;
+	float uv1 = (0.5f) / 256.0f;
+
+	// Border
+	float su0 = (12 * 16 + 0.5f) / 256.0f;
+	float su1 = (12 * 16 + 0.5f) / 256.0f;
+	float sv0 = (0) / 256.0f;
+	float sv1 = (0 + 16) / 256.0f;
+
+	for (int xs = 0; xs < w / 16; xs++) {
+		for (int ys = 0; ys < h / 16; ys++) {
+			float x0 = xx0 + (xs + 1) * 16;
+			float x1 = xx0 + (xs) * 16;
+			float y0 = yy0 + (ys + 1) * 16;
+			float y1 = yy0 + (ys) * 16;
+			//setBrightness(painting, (x0 + x1) / 2, (y0 + y1) / 2);
+
+			// Painting
+			float fu0 = (uo + w - (xs) * 16) / 256.0f;
+			float fu1 = (uo + w - (xs + 1) * 16) / 256.0f;
+			float fv0 = (vo + h - (ys) * 16) / 256.0f;
+			float fv1 = (vo + h - (ys + 1) * 16) / 256.0f;
+
+			Tesselator& t = Tesselator::instance;
+			float br = painting->getBrightness(a);
+			t.color(br, br, br);
+
+			t.begin();
+			t.vertexUV(x0, y1, -edgeWidth, fu1, fv0);
+			t.vertexUV(x1, y1, -edgeWidth, fu0, fv0);
+			t.vertexUV(x1, y0, -edgeWidth, fu0, fv1);
+			t.vertexUV(x0, y0, -edgeWidth, fu1, fv1);
+
+			t.vertexUV(x0, y0, edgeWidth, bu0, bv0);
+			t.vertexUV(x1, y0, edgeWidth, bu1, bv0);
+			t.vertexUV(x1, y1, edgeWidth, bu1, bv1);
+			t.vertexUV(x0, y1, edgeWidth, bu0, bv1);
+
+			t.vertexUV(x0, y0, -edgeWidth, uu0, uv0);
+			t.vertexUV(x1, y0, -edgeWidth, uu1, uv0);
+			t.vertexUV(x1, y0, edgeWidth, uu1, uv1);
+			t.vertexUV(x0, y0, edgeWidth, uu0, uv1);
+
+			t.vertexUV(x0, y1, edgeWidth, uu0, uv0);
+			t.vertexUV(x1, y1, edgeWidth, uu1, uv0);
+			t.vertexUV(x1, y1, -edgeWidth, uu1, uv1);
+			t.vertexUV(x0, y1, -edgeWidth, uu0, uv1);
+
+			t.vertexUV(x0, y0, edgeWidth, su1, sv0);
+			t.vertexUV(x0, y1, edgeWidth, su1, sv1);
+			t.vertexUV(x0, y1, -edgeWidth, su0, sv1);
+			t.vertexUV(x0, y0, -edgeWidth, su0, sv0);
+
+			t.vertexUV(x1, y0, -edgeWidth, su1, sv0);
+			t.vertexUV(x1, y1, -edgeWidth, su1, sv1);
+			t.vertexUV(x1, y1, edgeWidth, su0, sv1);
+			t.vertexUV(x1, y0, edgeWidth, su0, sv0);
+			t.draw();
+		}
+	}
+}
--- a/src/client/renderer/entity/PaintingRenderer.h
+++ b/src/client/renderer/entity/PaintingRenderer.h
@@ -0,0 +1,12 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__PaintingRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__PaintingRenderer_H__
+#include "EntityRenderer.h"
+class Painting;
+class PaintingRenderer : public EntityRenderer {
+public:
+	void render(Entity* entity, float x, float y, float z, float rot, float a);
+private:
+	void renderPainting(Painting* painting, int w, int h, int uo, int vo, float a);
+};
+
+#endif /* NET_MINECRAFT_CLIENT_RENDERER_ENTITY__PaintingRenderer_H__ */
--- a/src/client/renderer/entity/PigRenderer.h
+++ b/src/client/renderer/entity/PigRenderer.h
@@ -0,0 +1,29 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__PigRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__PigRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "../../model/Model.h"
+#include "../../../world/entity/animal/Pig.h"
+
+class PigRenderer: public MobRenderer
+{
+	typedef MobRenderer super;
+public:
+    PigRenderer(Model* model, Model* armor, float shadow)
+	:	super(model, shadow)
+	{
+       // setArmor(armor);
+    }
+
+    //void render(Entity* mob, float x, float y, float z, float rot, float a) {
+    //    super::render(mob, x, y, z, rot, a);
+    //}    
+protected:
+	//int prepareArmor(Entity* pig, int layer, float a) {
+	//	bindTexture("/mob/saddle.png");
+	//	return (layer == 0 && pig->hasSaddle()) ? 1 : -1;
+	//}
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__PigRenderer_H__*/
--- a/src/client/renderer/entity/PlayerRenderer.cpp
+++ b/src/client/renderer/entity/PlayerRenderer.cpp
@@ -0,0 +1,87 @@
+#include "PlayerRenderer.h"
+#include "EntityRenderDispatcher.h"
+#include "../../../world/entity/player/Player.h"
+#include "../../../world/level/Level.h"
+#include "../../../world/item/ArmorItem.h"
+
+static const std::string armorFilenames[10] = {
+	"armor/cloth_1.png",	"armor/cloth_2.png",
+	"armor/chain_1.png",	"armor/chain_2.png",
+	"armor/iron_1.png",		"armor/iron_2.png",
+	"armor/diamond_1.png",	"armor/diamond_2.png",
+	"armor/gold_1.png",		"armor/gold_2.png",
+};
+
+PlayerRenderer::PlayerRenderer( HumanoidModel* humanoidModel, float shadow )
+:	super(humanoidModel, shadow),
+	armorParts1(new HumanoidModel(1.0f)),
+	armorParts2(new HumanoidModel(0.5f))
+{
+}
+
+PlayerRenderer::~PlayerRenderer() {
+	delete armorParts1;
+	delete armorParts2;
+}
+
+void PlayerRenderer::setupPosition( Entity* mob, float x, float y, float z ) {
+	Player* player = (Player*) mob;
+	if(player->isAlive() && player->isSleeping()) {
+		return super::setupPosition(mob, x + player->bedOffsetX, y + player->bedOffsetY, z + player->bedOffsetZ);
+	}
+	return super::setupPosition(mob, x, y, z);
+}
+
+void PlayerRenderer::setupRotations( Entity* mob, float bob, float bodyRot, float a ) {
+	Player* player = (Player*) mob;
+	if(player->isAlive() && player->isSleeping()) {
+		glRotatef(player->getSleepRotation(), 0, 1, 0);
+		glRotatef(getFlipDegrees(player), 0, 0, 1);
+		glRotatef(270, 0, 1, 0);
+		return;
+	}
+	super::setupRotations(mob, bob, bodyRot, a);
+}
+
+void PlayerRenderer::renderName( Mob* mob, float x, float y, float z ){
+	//@todo: figure out how to handle HideGUI
+	if (mob != entityRenderDispatcher->cameraEntity && mob->level->adventureSettings.showNameTags) {
+		renderNameTag(mob, ((Player*)mob)->name, x, y, z, 32);
+	}
+}
+
+int PlayerRenderer::prepareArmor(Mob* mob, int layer, float a) {
+	Player* player = (Player*) mob;
+
+	ItemInstance* itemInstance = player->getArmor(layer);
+	if (!ItemInstance::isArmorItem(itemInstance))
+		return -1;
+
+	ArmorItem* armorItem = (ArmorItem*) itemInstance->getItem();
+	int fnIndex = (armorItem->modelIndex + armorItem->modelIndex) + (layer == 2 ? 1 : 0);
+	bindTexture(armorFilenames[fnIndex]);
+
+	HumanoidModel* armor = layer == 2 ? armorParts2 : armorParts1;
+
+	armor->head.visible = layer == 0;
+	//armor.hair.visible = layer == 0;
+	armor->body.visible = layer == 1 || layer == 2;
+	armor->arm0.visible = layer == 1;
+	armor->arm1.visible = layer == 1;
+	armor->leg0.visible = layer == 2 || layer == 3;
+	armor->leg1.visible = layer == 2 || layer == 3;
+
+	setArmor(armor);
+
+	/*if (itemInstance.isEnchanted())
+		return 15; */
+
+	return 1;
+}
+
+void PlayerRenderer::onGraphicsReset() {
+	super::onGraphicsReset();
+
+	if (armorParts1) armorParts1->onGraphicsReset();
+	if (armorParts2) armorParts2->onGraphicsReset();
+}
--- a/src/client/renderer/entity/PlayerRenderer.h
+++ b/src/client/renderer/entity/PlayerRenderer.h
@@ -0,0 +1,26 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__PlayerRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__PlayerRenderer_H__
+
+#include "HumanoidMobRenderer.h"
+
+class PlayerRenderer : public HumanoidMobRenderer
+{
+	typedef HumanoidMobRenderer super;
+public:
+	PlayerRenderer(HumanoidModel* humanoidModel, float shadow);
+	~PlayerRenderer();
+
+	virtual int prepareArmor(Mob* mob, int layer, float a);
+
+	virtual void setupPosition(Entity* mob, float x, float y, float z);
+	virtual void setupRotations(Entity* mob, float bob, float bodyRot, float a);
+
+	virtual void renderName(Mob* mob, float x, float y, float z);
+	virtual void onGraphicsReset();
+private:
+	HumanoidModel* armorParts1;
+	HumanoidModel* armorParts2;
+};
+
+
+#endif /* NET_MINECRAFT_CLIENT_RENDERER_ENTITY__PlayerRenderer_H__ */
--- a/src/client/renderer/entity/SheepRenderer.cpp
+++ b/src/client/renderer/entity/SheepRenderer.cpp
@@ -0,0 +1,29 @@
+#include "SheepRenderer.h"
+#include "../../../world/entity/animal/Sheep.h"
+#include "../gles.h"
+
+SheepRenderer::SheepRenderer( Model* model, Model* armor, float shadow )
+:   super(model, shadow)
+{
+	setArmor(armor);
+}
+
+SheepRenderer::~SheepRenderer() {
+	delete getArmor();
+}
+
+int SheepRenderer::prepareArmor(Mob* mob, int layer, float a) {
+	Sheep* sheep = (Sheep*) mob;
+
+	if (layer == 0 && !sheep->isSheared()) {
+		bindTexture("mob/sheep_fur.png");
+
+		float brightness = sheep->getBrightness(a);
+		int color = sheep->getColor();
+		glColor4f2(	brightness * Sheep::COLOR[color][0],
+					brightness * Sheep::COLOR[color][1],
+					brightness * Sheep::COLOR[color][2], 1);
+		return 1;
+	}
+	return -1;
+}
--- a/src/client/renderer/entity/SheepRenderer.h
+++ b/src/client/renderer/entity/SheepRenderer.h
@@ -0,0 +1,20 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__SheepRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__SheepRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "MobRenderer.h"
+class Mob;
+
+class SheepRenderer: public MobRenderer
+{
+    typedef MobRenderer super;
+
+public:
+    SheepRenderer(Model* model, Model* armor, float shadow);
+	~SheepRenderer();
+protected:
+	int prepareArmor(Mob* sheep, int layer, float a);
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__SheepRenderer_H__*/
--- a/src/client/renderer/entity/SpiderRenderer.h
+++ b/src/client/renderer/entity/SpiderRenderer.h
@@ -0,0 +1,46 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__SpiderRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__SpiderRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "MobRenderer.h"
+
+#include "../gles.h"
+#include "../../model/SpiderModel.h"
+#include "../../../world/entity/monster/Spider.h"
+
+class SpiderRenderer: public MobRenderer
+{
+    typedef MobRenderer super;
+public:
+    SpiderRenderer()
+    :   super(new SpiderModel(), 1.0f)
+    {
+        //this->setArmor(/*new*/ SpiderModel());
+    }
+
+protected:
+    float getFlipDegrees(Mob* spider) {
+        return 180;
+    }
+
+//    int prepareArmor(Mob* spider, int layer, float a) {
+//        if (layer != 0) return -1;
+//        bindTexture("/mob/spider_eyes.png");
+//        float br = 1.0f;
+//        glEnable(GL_BLEND);
+//        glDisable(GL_ALPHA_TEST);
+////        glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+//        glBlendFunc2(GL_ONE, GL_ONE);
+//        glColor4f2(1, 1, 1, br);
+//        return 1;
+//    }
+
+    /*@Override*/
+    void scale(Mob* mob, float a) {
+        float scale = ((Spider*)mob)->getModelScale();
+        glScalef(scale, scale, scale);
+    }
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__SpiderRenderer_H__*/
--- a/src/client/renderer/entity/TntRenderer.cpp
+++ b/src/client/renderer/entity/TntRenderer.cpp
@@ -0,0 +1,47 @@
+#include "TntRenderer.h"
+#include "../Tesselator.h"
+#include "../../../world/level/tile/Tile.h"
+#include "../../../world/entity/item/PrimedTnt.h"
+
+
+TntRenderer::TntRenderer()
+{
+	this->shadowRadius = 0.5f;
+}
+
+void TntRenderer::render( Entity* tnt_, float x, float y, float z, float rot, float a )
+{
+	PrimedTnt* tnt = (PrimedTnt*)tnt_;
+	glPushMatrix2();
+	glTranslatef2((float) x, (float) y, (float) z);
+	if (tnt->life - a + 1 < 10) {
+		float g = 1 - ((tnt->life - a + 1) / 10.0f);
+		if (g < 0) g = 0;
+		if (g > 1) g = 1;
+		g = g * g;
+		g = g * g;
+		float s = 1.0f + g * 0.3f;
+		glScalef2(s, s, s);
+	}
+
+	float br = (1 - ((tnt->life - a + 1) / 100.0f)) * 0.8f;
+	bindTexture("terrain.png");
+
+	Tesselator& t = Tesselator::instance;
+	t.color(1.0f, 1.0f, 1.0f);
+	tileRenderer.renderTile(Tile::tnt, 0);
+
+	if (((tnt->life / 5) & 1) == 0) {
+		glDisable2(GL_TEXTURE_2D);
+		glEnable2(GL_BLEND);
+		glBlendFunc2(GL_SRC_ALPHA, GL_DST_ALPHA);
+		glColor4f2(1, 1, 1, br);
+		//t.color(1.0f, 1.0f, 1.0f, br);
+		tileRenderer.renderTile(Tile::tnt, 0);
+		glColor4f2(1, 1, 1, 1);
+		glDisable2(GL_BLEND);
+		//glEnable2(GL_LIGHTING);
+		glEnable2(GL_TEXTURE_2D);
+	}
+	glPopMatrix2();
+}
--- a/src/client/renderer/entity/TntRenderer.h
+++ b/src/client/renderer/entity/TntRenderer.h
@@ -0,0 +1,18 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__TntRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__TntRenderer_H__
+
+//package net.minecraft.client.renderer.entity;
+
+#include "EntityRenderer.h"
+#include "../TileRenderer.h"
+
+class TntRenderer: public EntityRenderer
+{
+public:
+    TntRenderer();
+	void render(Entity* tnt_, float x, float y, float z, float rot, float a);
+
+	TileRenderer tileRenderer;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__TntRenderer_H__*/
--- a/src/client/renderer/entity/TripodCameraRenderer.cpp
+++ b/src/client/renderer/entity/TripodCameraRenderer.cpp
@@ -0,0 +1,75 @@
+#include "TripodCameraRenderer.h"
+#include "EntityRenderDispatcher.h"
+#include "../Tesselator.h"
+#include "../../Minecraft.h"
+#include "../../../world/entity/item/TripodCamera.h"
+#include "../../../world/level/material/Material.h"
+
+TripodCameraRenderer::TripodCameraRenderer()
+:	tripod(0, 15 * 16 + 3, Material::plant),
+	cameraCube(0, 0)
+{
+	cameraCube.addBox(-4, -4, -6, 8, 8, 10);
+	cameraCube.y = 11;
+	this->shadowRadius = 0.5f;
+}
+
+float TripodCameraRenderer::getFlashTime(const TripodCamera* c, float a) {
+	if (c->life >= 8) return -1;
+	if (c->life < 0) return -1;
+	return (c->life - a) * 0.125f;
+}
+
+void TripodCameraRenderer::render(Entity* cam_, float x, float y, float z, float rot, float a) {
+	TripodCamera* cam = (TripodCamera*)cam_;
+
+	glPushMatrix2();
+	glTranslatef2((float) x, (float) y, (float) z);
+
+	cameraCube.xRot = Mth::DEGRAD * (180.0f + cam->xRot * 0.5f);
+	cameraCube.yRot = -Mth::DEGRAD * cam->yRot;
+
+	//float br = (1 - ((cam->life - a + 1) / 100.0f)) * 0.8f;
+
+	Tesselator& t = Tesselator::instance;
+	t.color(1.0f, 1.0f, 1.0f);
+
+	//printf("xyz: %f, %f, %f\n", x, y, z);
+
+	// Render tripod legs
+	bindTexture("gui/items.png");
+	t.begin();
+	tileRenderer.tesselateCrossTexture(&tripod, 0, -0.5f, -0.5f, -0.5f);//, y, z);
+	t.draw();
+
+	// Render tripod
+	bindTexture("item/camera.png");
+	cameraCube.render(1.0f / 16.0f);
+
+	bool isCurrentlyPicked = entityRenderDispatcher->minecraft->hitResult.entity == cam;
+
+	const float flashLife = getFlashTime(cam, a);
+
+	if (flashLife >= 0) {
+		const float flashStrength = ::sin(flashLife * 6.2830f);
+
+		// Flash
+		glColor4f2(1, 1, 1, flashStrength);
+		glColor4f2(1, 1, 1, 1);
+	}
+
+	// "red light" flashing when photo is about to go off
+	if (isCurrentlyPicked) {
+		glDisable2(GL_TEXTURE_2D);
+		glEnable2(GL_BLEND);
+		glBlendFunc2(GL_SRC_ALPHA, GL_DST_ALPHA);
+		glColor4f2(0.5f,0.5f,0.5f,0.5f);
+
+		cameraCube.renderHorrible(1.0f / 16.0f);
+
+		glColor4f2(1,1,1,1);
+		glDisable2(GL_BLEND);
+		glEnable2(GL_TEXTURE_2D);
+	}
+	glPopMatrix2();
+}
--- a/src/client/renderer/entity/TripodCameraRenderer.h
+++ b/src/client/renderer/entity/TripodCameraRenderer.h
@@ -0,0 +1,29 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_ENTITY__TripodCameraRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_ENTITY__TripodCameraRenderer_H__
+
+#include "EntityRenderer.h"
+#include "../TileRenderer.h"
+#include "../../model/geom/ModelPart.h"
+#include "../../../world/level/tile/Tile.h"
+
+
+class TripodCamera;
+
+class TripodCameraRenderer: public EntityRenderer
+{
+    TileRenderer tileRenderer;
+
+public:
+    TripodCameraRenderer();
+
+	void render(Entity* cam_, float x, float y, float z, float rot, float a);
+	//void render( Tesselator &t );
+
+	static float getFlashTime(const TripodCamera* c, float a);
+
+private:
+	Tile tripod;
+	ModelPart cameraCube;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__TripodCameraRenderer_H__*/