the whole game

src/client/renderer/tileentity/ChestRenderer.cpp

@@ -0,0 +1,76 @@
+#include "ChestRenderer.h"
+#include "TileEntityRenderer.h"
+#include "../gles.h"
+#include "../../model/ChestModel.h"
+#include "../../../world/level/tile/entity/ChestTileEntity.h"
+#include "../../../world/level/tile/ChestTile.h"
+#include "../../../util/Mth.h"
+
+
+void ChestRenderer::render( TileEntity* entity, float x, float y, float z, float a )
+{
+	ChestTileEntity* chest = (ChestTileEntity*) entity;
+	int data = 0;
+
+	if (chest->level) {
+		Tile* tile = chest->getTile();
+		data = chest->getData();
+
+		if (tile != NULL && data == 0) {
+			((ChestTile*)tile)->recalcLockDir(chest->level, chest->x, chest->y, chest->z);
+			data = chest->getData();
+		}
+
+		chest->checkNeighbors();
+	}
+	if (chest->n != NULL || chest->w != NULL) return;
+
+	ChestModel* model;
+	//if (chest->e != NULL || chest->s != NULL) {
+	//	//model = &largeChestModel;
+	//	bindTexture("item/largechest.png");
+	//} else
+	{
+		model = &chestModel;
+		bindTexture("item/chest.png");
+	}
+
+	glPushMatrix2();
+	glColor4f2(1, 1, 1, 1);
+	glTranslatef2(x, y + 1, z + 1);
+	glScalef2(1, -1, -1);
+
+	glTranslatef2(0.5f, 0.5f, 0.5f);
+	GLfloat rot = 0;
+	if (data == 2) rot = 180;
+	if (data == 3) rot = 0;
+	if (data == 4) rot = 90;
+	if (data == 5) rot = -90;
+
+	if (data == 2 && chest->e != NULL) {
+		glTranslatef2(1, 0, 0);
+	}
+	if (data == 5 && chest->s != NULL) {
+		glTranslatef2(0, 0, -1);
+	}
+	glRotatef2(rot, 0, 1, 0);
+	glTranslatef2(-0.5f, -0.5f, -0.5f);
+
+	float open = chest->oOpenness + (chest->openness - chest->oOpenness) * a;
+	if (chest->n != NULL) {
+		float open2 = chest->n->oOpenness + (chest->n->openness - chest->n->oOpenness) * a;
+		if (open2 > open) open = open2;
+	}
+	if (chest->w != NULL) {
+		float open2 = chest->w->oOpenness + (chest->w->openness - chest->w->oOpenness) * a;
+		if (open2 > open) open = open2;
+	}
+
+	open = 1 - open;
+	open = 1 - open * open * open;
+
+	model->lid.xRot = -(open * Mth::PI / 2);
+	model->render();
+	glPopMatrix2();
+	glColor4f2(1, 1, 1, 1);
+}

src/client/renderer/tileentity/ChestRenderer.h

@@ -0,0 +1,21 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__ChestRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__ChestRenderer_H__
+
+//package net.minecraft.client.renderer.tileentity;
+
+#include "TileEntityRenderer.h"
+#include "../../model/ChestModel.h"
+
+class ChestTileEntity;
+
+class ChestRenderer: public TileEntityRenderer
+{
+    /*@Override*/
+    void render(TileEntity* chest, float x, float y, float z, float a);
+
+private:
+    ChestModel chestModel;
+    //LargeChestModel* largeChestModel;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__ChestRenderer_H__*/

src/client/renderer/tileentity/SignRenderer.cpp

@@ -0,0 +1,65 @@
+#include "SignRenderer.h"
+#include "../../../world/level/tile/Tile.h"
+#include "../../../world/level/tile/entity/SignTileEntity.h"
+
+void SignRenderer::render( TileEntity* te, float x, float y, float z, float a )
+{
+    SignTileEntity* sign = (SignTileEntity*) te;
+    Tile* tile = sign->getTile();
+
+    glPushMatrix();
+    float size = 16 / 24.0f;
+    if (tile == Tile::sign) {
+        glTranslatef(x + 0.5f, y + 0.75f * size, z + 0.5f);
+        float rot = sign->getData() * 360 / 16.0f;
+        glRotatef(-rot, 0, 1, 0);
+        signModel.cube2.visible = true;
+    } else {
+        int face = sign->getData();
+        float rot = 0;
+
+        if (face == 2) rot = 180;
+        if (face == 4) rot = 90;
+        if (face == 5) rot = -90;
+
+        glTranslatef(x + 0.5f, y + 0.75f * size, z + 0.5f);
+        glRotatef(-rot, 0, 1, 0);
+        glTranslatef(0, -5 / 16.0f, -7 / 16.0f);
+
+        signModel.cube2.visible = false;
+    }
+
+    bindTexture("item/sign.png");
+
+    glPushMatrix();
+    glScalef(size, -size, -size);
+    signModel.render();
+    glPopMatrix();
+    Font* font = getFont();
+
+    float s = 1 / 60.0f * size;
+    glTranslatef(0, 0.5f * size, 0.07f * size);
+    glScalef(s, -s, s);
+    glNormal3f(0, 0, -1 * s);
+    glDepthMask(false);
+
+    int col = 0;
+	float yy = (float)(SignTileEntity::NUM_LINES * -5);
+    for (int i = 0; i < SignTileEntity::NUM_LINES; i++) {
+        std::string& msg = sign->messages[i];
+        if (i == sign->selectedLine) {
+            std::string s = "> " + msg + " <";
+            font->draw(s, (float)-font->width(s) / 2, yy, col);
+        } else {
+            font->draw(msg, (float)-font->width(msg) / 2, yy, col);
+        }
+		yy += 10;
+    }
+    glDepthMask(true);
+    glColor4f(1, 1, 1, 1);
+    glPopMatrix();
+}
+
+void SignRenderer::onGraphicsReset() {
+	signModel.onGraphicsReset();
+}

src/client/renderer/tileentity/SignRenderer.h

@@ -0,0 +1,21 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__SignRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__SignRenderer_H__
+
+//package net.minecraft.client.renderer.tileentity;
+
+#include "TileEntityRenderer.h"
+
+#include "../../gui/Font.h"
+#include "../../model/SignModel.h"
+
+class SignRenderer: public TileEntityRenderer
+{
+public:
+    /*@Override*/
+    void render(TileEntity* te, float x, float y, float z, float a);
+    void onGraphicsReset();
+private:
+    SignModel signModel;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__SignRenderer_H__*/

src/client/renderer/tileentity/TileEntityRenderDispatcher.cpp

@@ -0,0 +1,136 @@
+#include "TileEntityRenderDispatcher.h"
+#include "ChestRenderer.h"
+#include "../Textures.h"
+#include "../../gui/Font.h"
+#include "../../../SharedConstants.h"
+#include "../../../world/entity/Mob.h"
+#include "../../../world/level/Level.h"
+#include "../../../world/level/tile/entity/TileEntity.h"
+#include "SignRenderer.h"
+
+/*static*/
+TileEntityRenderDispatcher* TileEntityRenderDispatcher::instance = 0;
+/*static*/
+float	TileEntityRenderDispatcher::xOff = 0,
+		TileEntityRenderDispatcher::yOff = 0,
+		TileEntityRenderDispatcher::zOff = 0;
+
+TileEntityRenderDispatcher* TileEntityRenderDispatcher::getInstance()
+{
+	if (!instance) instance = new TileEntityRenderDispatcher();
+	return instance;
+}
+
+TileEntityRenderDispatcher::~TileEntityRenderDispatcher()
+{
+	std::set<TileEntityRenderer*> 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 TileEntityRenderDispatcher::destroy()
+{
+	if (instance) {
+		delete instance;
+		instance = NULL;
+	}
+}
+
+void TileEntityRenderDispatcher::prepare( Level* level, Textures* textures, Font* font, Mob* player, float a )
+{
+	if (this->level != level)
+		setLevel(level);
+
+	this->textures = textures;
+	this->cameraEntity = player;
+	this->_font = font;
+
+	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;
+
+	//        xPlayer -= xPlayerOffs;
+	//        yPlayer -= yPlayerOffs;
+	//        zPlayer -= zPlayerOffs;
+}
+
+void TileEntityRenderDispatcher::render( TileEntity* e, float a )
+{
+	if (e->distanceToSqr(xPlayer, yPlayer, zPlayer) < 64 * 64) {
+		float br = level->getBrightness(e->x, e->y, e->z);
+		glColor4f(br, br, br, 1);
+		render(e, e->x - xOff, e->y - yOff, e->z - zOff, a);
+	}
+}
+
+void TileEntityRenderDispatcher::render( TileEntity* entity, float x, float y, float z, float a )
+{
+	TileEntityRenderer* renderer = getRenderer(entity);
+	if (renderer != NULL) {
+		renderer->render(entity, x, y, z, a);
+	}
+}
+
+void TileEntityRenderDispatcher::setLevel( Level* level )
+{
+	this->level = level;
+
+	for (RendererCIterator cit = _renderers.begin(); cit != _renderers.end(); ++cit)
+		if (cit->second != NULL)
+			cit->second->onNewLevel(level);
+}
+
+float TileEntityRenderDispatcher::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* TileEntityRenderDispatcher::getFont()
+{
+	return _font;
+}
+
+TileEntityRenderer* TileEntityRenderDispatcher::getRenderer( TileEntity* entity )
+{
+	TileEntityRendererId rendererId = entity->rendererId;
+
+	//if (rendererId == TR_QUERY_RENDERER)
+	//	rendererId = entity->queryEntityRenderer();
+
+	return getRenderer(rendererId);
+}
+
+TileEntityRenderer* TileEntityRenderDispatcher::getRenderer( TileEntityRendererId rendererId )
+{
+	TileEntityRenderer* renderer = NULL;
+	RendererCIterator cit = _renderers.find(rendererId);
+	if (cit != _renderers.end()) {
+		renderer = cit->second;
+	}
+	return renderer;
+}
+
+TileEntityRenderDispatcher::TileEntityRenderDispatcher()
+{
+	_renderers.insert(std::make_pair(TR_CHEST_RENDERER, new ChestRenderer()));
+    _renderers.insert(std::make_pair(TR_SIGN_RENDERER, new SignRenderer()));
+
+	for (RendererCIterator cit = _renderers.begin(); cit != _renderers.end(); ++cit)
+		cit->second->init(this);
+}
+
+void TileEntityRenderDispatcher::onGraphicsReset() {
+	for (RendererIterator it = _renderers.begin(); it != _renderers.end(); ++it) {
+		it->second->onGraphicsReset();
+	}
+}

src/client/renderer/tileentity/TileEntityRenderDispatcher.h

@@ -0,0 +1,61 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__TileEntityRenderDispatcher_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__TileEntityRenderDispatcher_H__
+
+//package net.minecraft.client.renderer.tileentity;
+
+#include <map>
+#include "../../../world/level/tile/entity/TileEntityRendererId.h"
+
+class TileEntityRenderer;
+class Level;
+class Textures;
+class TileEntity;
+class Font;
+class Mob;
+
+class TileEntityRenderDispatcher
+{
+	typedef std::map<TileEntityRendererId, TileEntityRenderer*> RendererMap;
+	typedef RendererMap::iterator RendererIterator;
+	typedef RendererMap::const_iterator RendererCIterator;
+
+public:
+	~TileEntityRenderDispatcher();
+
+	static TileEntityRenderDispatcher* getInstance();
+	static void destroy();
+
+	void setLevel(Level* level);
+    void prepare(Level* level, Textures* textures, Font* font, Mob* player, float a);
+
+    void render(TileEntity* e, float a);
+    void render(TileEntity* entity, float x, float y, float z, float a);
+
+    float distanceToSqr(float x, float y, float z);
+
+    Font* getFont();
+
+    TileEntityRenderer* getRenderer( TileEntity* entity );
+    TileEntityRenderer* getRenderer( TileEntityRendererId rendererId );
+
+	void onGraphicsReset();
+private:
+	TileEntityRenderDispatcher();
+public:
+    static float xOff, yOff, zOff;
+
+    Textures* textures;
+    Level* level;
+    Mob* cameraEntity;
+    float playerRotY;
+    float playerRotX;
+
+    float xPlayer, yPlayer, zPlayer;
+private:
+	static TileEntityRenderDispatcher* instance;
+
+	Font* _font;
+	RendererMap _renderers;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__TileEntityRenderDispatcher_H__*/

src/client/renderer/tileentity/TileEntityRenderer.cpp

@@ -0,0 +1,32 @@
+#include "TileEntityRenderer.h"
+#include "TileEntityRenderDispatcher.h"
+#include "../Textures.h"
+#include "../../gui/Font.h"
+#include "../../../world/level/Level.h"
+#include "../../../world/level/tile/entity/TileEntity.h"
+
+TileEntityRenderer::TileEntityRenderer()
+:   tileEntityRenderDispatcher(NULL)
+{
+}
+
+void TileEntityRenderer::bindTexture( const std::string& resourceName )
+{
+	Textures* t = tileEntityRenderDispatcher->textures;
+	if (t != NULL) t->loadAndBindTexture(resourceName);
+}
+
+Level* TileEntityRenderer::getLevel()
+{
+	return tileEntityRenderDispatcher->level;
+}
+
+void TileEntityRenderer::init( TileEntityRenderDispatcher* tileEntityRenderDispatcher )
+{
+	this->tileEntityRenderDispatcher = tileEntityRenderDispatcher;
+}
+
+Font* TileEntityRenderer::getFont()
+{
+	return tileEntityRenderDispatcher->getFont();
+}

src/client/renderer/tileentity/TileEntityRenderer.h

@@ -0,0 +1,38 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__TileEntityRenderer_H__
+#define NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__TileEntityRenderer_H__
+
+//package net.minecraft.client.renderer.tileentity;
+
+#include <string>
+
+class Level;
+class TileEntity;
+class TileEntityRenderDispatcher;
+class Font;
+
+class TileEntityRenderer
+{
+public:
+    TileEntityRenderer();
+    virtual ~TileEntityRenderer(){}
+    
+	void init(TileEntityRenderDispatcher* tileEntityRenderDispatcher);
+    virtual void render(TileEntity* entity, float x, float y, float z, float a) = 0;
+
+    void bindTexture(const std::string& resourceName);
+//     /*protected*/ void bindTexture(const std::string& urlTexture, const std::string& backupTexture) {
+//         Textures t = tileEntityRenderDispatcher.textures;
+//         if (t != NULL) t.bind(t.loadHttpTexture(urlTexture, backupTexture));
+//     }
+
+    Level* getLevel();
+	Font* getFont();
+
+	virtual void onGraphicsReset() {}
+
+    virtual void onNewLevel(Level* level) {}
+protected:
+    TileEntityRenderDispatcher* tileEntityRenderDispatcher;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_RENDERER_TILEENTITY__TileEntityRenderer_H__*/