Initial commit

1 files changed, 7694 insertions, 0 deletions

diff --git a/Minecraft.Client/TileRenderer.cpp b/Minecraft.Client/TileRenderer.cpp
new file mode 100644
index 00000000..3b8d4c4e
--- /dev/null
+++ b/Minecraft.Client/TileRenderer.cpp
@@ -0,0 +1,7694 @@
+#include "stdafx.h"
+
+#include "TileRenderer.h"
+#include "GameRenderer.h"
+#include "Minecraft.h"
+#include "Textures.h"
+#include "..\Minecraft.World\net.minecraft.world.level.h"
+#include "..\Minecraft.World\net.minecraft.world.level.tile.h"
+#include "..\Minecraft.World\net.minecraft.world.level.material.h"
+#include "..\Minecraft.World\net.minecraft.h"
+#include "..\Minecraft.World\net.minecraft.world.h"
+#include "Tesselator.h"
+#include "EntityTileRenderer.h"
+#include "Options.h"
+
+bool TileRenderer::fancy = true;
+
+const float smallUV = ( 1.0f / 16.0f );
+
+void TileRenderer::_init()
+{
+	fixedTexture = NULL;
+	xFlipTexture = false;
+	noCulling = false;
+	blsmooth = 1;
+	applyAmbienceOcclusion = false;
+	setColor = true;
+	northFlip = FLIP_NONE;
+	southFlip = FLIP_NONE;
+	eastFlip = FLIP_NONE;
+	westFlip = FLIP_NONE;
+	upFlip = FLIP_NONE;
+	downFlip = FLIP_NONE;
+
+	tileShapeX0 = 0.0;
+	tileShapeX1 = 0.0;
+	tileShapeY0 = 0.0;
+	tileShapeY1 = 0.0;
+	tileShapeZ0 = 0.0;
+	tileShapeZ1 = 0.0;
+	fixedShape = false;
+	smoothShapeLighting = false;
+	minecraft = Minecraft::GetInstance();
+
+	xMin = 0;
+	yMin = 0;
+	zMin = 0;
+	cache = NULL;
+}
+
+bool TileRenderer::isTranslucentAt(LevelSource *level, int x, int y, int z)
+{
+	if( cache )
+	{
+		int id = ( ( x - xMin2) << 10 ) + ( ( y - yMin2 ) << 5 ) + ( z - zMin2 );
+		if ( ( id & 0xffff8000) == 0 )	// Check 0 <= id <= 32767
+		{
+			assert (id >= 0 );
+			assert (id <= 32 * 32 * 32);
+			if( cache[id] & cache_isTranslucentAt_valid ) return ( ( cache[id] & cache_isTranslucentAt_flag ) == cache_isTranslucentAt_flag );
+
+			bool ret = Tile::transculent[level->getTile(x,y,z)];
+
+			if( ret )
+			{
+				cache[id] |= cache_isTranslucentAt_valid | cache_isTranslucentAt_flag;
+			}
+			else
+			{
+				cache[id] |= cache_isTranslucentAt_valid;
+			}
+			return ret;
+		}
+	}
+	return Tile::transculent[level->getTile(x,y,z)];
+}
+
+float TileRenderer::getShadeBrightness(Tile *tt, LevelSource *level, int x, int y, int z)
+{
+	if( cache )
+	{
+		int id = ( ( x - xMin2) << 10 ) + ( ( y - yMin2 ) << 5 ) + ( z - zMin2 );
+		if ( ( id & 0xffff8000) == 0 )	// Check 0 <= id <= 32767
+		{
+			if( cache[id] & cache_isSolidBlockingTile_valid ) return ( ( cache[id] & cache_isSolidBlockingTile_flag ) ? 0.2f : 1.0f);
+
+			bool isSolidBlocking = level->isSolidBlockingTile(x, y, z);
+
+			if( isSolidBlocking )
+			{
+				cache[id] |= cache_isSolidBlockingTile_valid | cache_isSolidBlockingTile_flag;
+			}
+			else
+			{
+				cache[id] |= cache_isSolidBlockingTile_valid;
+			}
+			return ( isSolidBlocking ? 0.2f : 1.0f);
+		}
+	}
+	return tt->getShadeBrightness(level, x, y, z);
+}
+
+int TileRenderer::getLightColor( Tile *tt, LevelSource *level, int x, int y, int z)
+{
+	if( cache )
+	{
+		int id = ( ( x - xMin2) << 10 ) + ( ( y - yMin2 ) << 5 ) + ( z - zMin2 );
+		if ( ( id & 0xffff8000) == 0 )	// Check 0 <= id <= 32767
+		{
+			// Don't use the cache for liquid tiles, as they are the only type that seem to have their own implementation of getLightColor that actually is important.
+			// Without this we get patches of dark water where their lighting value is 0, it needs to pull in light from the tile above to work
+			if( ( tt->id >= Tile::water_Id ) && ( tt->id <= Tile::calmLava_Id ) ) return tt->getLightColor(level, x, y, z);
+
+			if( cache[id] & cache_getLightColor_valid ) return cache[id] & cache_getLightColor_mask;
+
+			// Not in cache. Have we got the tile type cached? We can pass this as a parameter to Tile::getLightColor( or -1 if we don't) so that underlying things
+			// don't have to get the tile again.
+			int tileId = -1;
+			int xx = x - xMin;
+			int zz = z - zMin;
+			if( ( xx >= 0 ) && ( xx <= 15 ) && ( zz >= 0 ) && ( zz <= 15 ) && ( y >= 0 ) && ( y < Level::maxBuildHeight ) )
+			{
+				int indexY = y;
+				int offset = 0;
+				if(indexY >= Level::COMPRESSED_CHUNK_SECTION_HEIGHT)
+				{
+					indexY -= Level::COMPRESSED_CHUNK_SECTION_HEIGHT;
+					offset = Level::COMPRESSED_CHUNK_SECTION_TILES;
+				}
+
+				unsigned char ucTileId = tileIds[ offset + ( ( ( xx + 0 ) << 11 ) | ( ( zz + 0 ) << 7 ) | ( indexY + 0 ) ) ];
+				// Tiles that were determined to be invisible (by being surrounded by solid stuff) will be set to 255 rather than their actual ID
+				if( ucTileId != 255 )
+				{
+					tileId = (int)ucTileId;
+				}
+			}
+			int ret = tt->getLightColor(level, x, y, z, tileId);
+			cache[id] |= ( ( ret & cache_getLightColor_mask ) | cache_getLightColor_valid );
+			return ret;
+		}
+	}
+	return tt->getLightColor(level, x, y, z);
+}
+
+TileRenderer::TileRenderer( LevelSource* level, int xMin, int yMin, int zMin, unsigned char *tileIds )
+{
+	this->level = level;
+	_init();
+	this->xMin = xMin;
+	this->yMin = yMin;
+	this->zMin = zMin;
+	this->xMin2 = xMin-2;
+	this->yMin2 = yMin-2;
+	this->zMin2 = zMin-2;
+	this->tileIds = tileIds;
+	cache = new unsigned int[32*32*32];
+	XMemSet(cache,0,32*32*32*sizeof(unsigned int));
+}
+
+TileRenderer::~TileRenderer()
+{
+	delete cache;
+}
+
+TileRenderer::TileRenderer( LevelSource* level )
+{
+	this->level = level;
+	_init();
+}
+
+TileRenderer::TileRenderer()
+{
+	this->level = NULL;
+	_init();
+}
+
+void TileRenderer::setFixedTexture( Icon *fixedTexture )
+{
+	this->fixedTexture = fixedTexture;
+}
+
+void TileRenderer::clearFixedTexture()
+{
+	this->fixedTexture = NULL;
+}
+
+bool TileRenderer::hasFixedTexture()
+{
+	return fixedTexture != NULL;
+}
+
+void TileRenderer::setShape(float x0, float y0, float z0, float x1, float y1, float z1)
+{
+	if (!fixedShape)
+	{
+		tileShapeX0 = x0;
+		tileShapeX1 = x1;
+		tileShapeY0 = y0;
+		tileShapeY1 = y1;
+		tileShapeZ0 = z0;
+		tileShapeZ1 = z1;
+		smoothShapeLighting = (tileShapeX0 > 0 || tileShapeX1 < 1 || tileShapeY0 > 0 || tileShapeY1 < 1 || tileShapeZ0 > 0 || tileShapeZ1 < 1);
+	}
+}
+
+void TileRenderer::setShape(Tile *tt)
+{
+	if (!fixedShape)
+	{
+		tileShapeX0 = tt->getShapeX0();
+		tileShapeX1 = tt->getShapeX1();
+		tileShapeY0 = tt->getShapeY0();
+		tileShapeY1 = tt->getShapeY1();
+		tileShapeZ0 = tt->getShapeZ0();
+		tileShapeZ1 = tt->getShapeZ1();
+		smoothShapeLighting = (tileShapeX0 > 0 || tileShapeX1 < 1 || tileShapeY0 > 0 || tileShapeY1 < 1 || tileShapeZ0 > 0 || tileShapeZ1 < 1);
+	}
+}
+
+void TileRenderer::setFixedShape(float x0, float y0, float z0, float x1, float y1, float z1)
+{
+	tileShapeX0 = x0;
+	tileShapeX1 = x1;
+	tileShapeY0 = y0;
+	tileShapeY1 = y1;
+	tileShapeZ0 = z0;
+	tileShapeZ1 = z1;
+	fixedShape = true;
+
+	smoothShapeLighting = (tileShapeX0 > 0 || tileShapeX1 < 1 || tileShapeY0 > 0 || tileShapeY1 < 1 || tileShapeZ0 > 0 || tileShapeZ1 < 1);
+}
+
+void TileRenderer::clearFixedShape()
+{
+	fixedShape = false;
+}
+
+void TileRenderer::tesselateInWorldFixedTexture( Tile* tile, int x, int y, int z, Icon *fixedTexture )	// 4J renamed to differentiate from tesselateInWorld
+{
+	this->setFixedTexture(fixedTexture);
+	tesselateInWorld( tile, x, y, z );
+	this->clearFixedTexture();
+}
+
+void TileRenderer::tesselateInWorldNoCulling( Tile* tile, int x, int y, int z, int forceData,
+											  shared_ptr< TileEntity > forceEntity )	// 4J added forceData, forceEntity param
+{
+	noCulling = true;
+	tesselateInWorld( tile, x, y, z, forceData );
+	noCulling = false;
+}
+
+bool TileRenderer::tesselateInWorld( Tile* tt, int x, int y, int z, int forceData,
+									 shared_ptr< TileEntity > forceEntity )	// 4J added forceData, forceEntity param
+{
+	Tesselator* t = Tesselator::getInstance();
+	int	shape = tt->getRenderShape();
+	tt->updateShape( level, x, y, z, forceData, forceEntity );
+	// AP - now that the culling is done earlier we don't need to call setShape until later on (only for SHAPE_BLOCK)
+	if( shape != Tile::SHAPE_BLOCK )
+	{
+		setShape(tt);
+	}
+	t->setMipmapEnable( Tile::mipmapEnable[tt->id] );	// 4J added
+
+	bool retVal = false;
+	switch(shape)
+	{
+	case Tile::SHAPE_BLOCK:
+		{
+			// 4J - added these faceFlags so we can detect whether this block is going to have no visible faces and early out
+			// the original code checked noCulling and shouldRenderFace directly where faceFlags is used now
+			// AP - I moved this check from tesselateBlockInWorldWithAmbienceOcclusionTexLighting to be even earlier to speed up early rejection.
+			// The flags are then passed down to avoid creating them again.
+			// These changes in combination have more than halved the time it takes to reject a block on Vita
+			int			faceFlags = 0;
+			if ( noCulling )
+			{
+				faceFlags = 0x3f;
+			}
+			else
+			{
+				// these block types can take advantage of a faster version of shouldRenderFace
+				// there are others but this is an easy check which covers the majority
+				// Note: This now covers rock, grass, dirt, stoneBrice, wood, sapling, unbreakable, sand, gravel, goldOre, ironOre, coalOre, treeTrunk
+				if( ( tt->id <= Tile::unbreakable_Id  ) ||
+					( ( tt->id >= Tile::sand_Id ) && ( tt->id <= Tile::treeTrunk_Id ) ) )
+				{
+					faceFlags = tt->getFaceFlags( level, x, y, z );
+				}
+				else
+				{
+					faceFlags |= tt->shouldRenderFace( level, x, y - 1, z, 0 ) ? 0x01 : 0;
+					faceFlags |= tt->shouldRenderFace( level, x, y + 1, z, 1 ) ? 0x02 : 0;
+					faceFlags |= tt->shouldRenderFace( level, x, y, z - 1, 2 ) ? 0x04 : 0;
+					faceFlags |= tt->shouldRenderFace( level, x, y, z + 1, 3 ) ? 0x08 : 0;
+					faceFlags |= tt->shouldRenderFace( level, x - 1, y, z, 4 ) ? 0x10 : 0;
+					faceFlags |= tt->shouldRenderFace( level, x + 1, y, z, 5 ) ? 0x20 : 0;
+				}
+			}
+			if ( faceFlags == 0 )
+			{
+				retVal = false;
+				break;
+			}
+
+			// now we need to set the shape
+			setShape(tt);
+
+			retVal = tesselateBlockInWorld( tt, x, y, z, faceFlags );
+		}
+		break;
+	case Tile::SHAPE_TREE:
+		retVal = tesselateTreeInWorld(tt, x, y, z);
+		break;
+	case Tile::SHAPE_QUARTZ:
+		retVal = tesselateQuartzInWorld(tt, x, y, z);
+		break;
+	case Tile::SHAPE_WATER:
+		retVal = tesselateWaterInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_CACTUS:
+		retVal = tesselateCactusInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_CROSS_TEXTURE:
+		retVal = tesselateCrossInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_STEM:
+		retVal = tesselateStemInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_LILYPAD:
+		retVal = tesselateLilypadInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_ROWS:
+		retVal = tesselateRowInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_TORCH:
+		retVal = tesselateTorchInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_FIRE:
+		retVal = tesselateFireInWorld( (FireTile *)tt, x, y, z );
+		break;
+	case Tile::SHAPE_RED_DUST:
+		retVal = tesselateDustInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_LADDER:
+		retVal = tesselateLadderInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_DOOR:
+		retVal = tesselateDoorInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_RAIL:
+		retVal = tesselateRailInWorld( ( RailTile* )tt, x, y, z );
+		break;
+	case Tile::SHAPE_STAIRS:
+		retVal = tesselateStairsInWorld( (StairTile *)tt, x, y, z );
+		break;
+	case Tile::SHAPE_EGG:
+		retVal = tesselateEggInWorld((EggTile*) tt, x, y, z);
+		break;
+	case Tile::SHAPE_FENCE:
+		retVal = tesselateFenceInWorld( ( FenceTile* )tt, x, y, z );
+		break;
+	case Tile::SHAPE_WALL:
+		retVal = tesselateWallInWorld( (WallTile *) tt, x, y, z);
+		break;
+	case Tile::SHAPE_LEVER:
+		retVal = tesselateLeverInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_TRIPWIRE_SOURCE:
+		retVal = tesselateTripwireSourceInWorld(tt, x, y, z);
+		break;
+	case Tile::SHAPE_TRIPWIRE:
+		retVal = tesselateTripwireInWorld(tt, x, y, z);
+		break;
+	case Tile::SHAPE_BED:
+		retVal = tesselateBedInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_DIODE:
+		retVal = tesselateDiodeInWorld( (DiodeTile *)tt, x, y, z );
+		break;
+	case Tile::SHAPE_PISTON_BASE:
+		retVal = tesselatePistonBaseInWorld( tt, x, y, z, false, forceData );
+		break;
+	case Tile::SHAPE_PISTON_EXTENSION:
+		retVal = tesselatePistonExtensionInWorld( tt, x, y, z, true, forceData );
+		break;
+	case Tile::SHAPE_IRON_FENCE:
+		retVal = tesselateThinFenceInWorld( ( ThinFenceTile* )tt, x, y, z );
+		break;
+	case Tile::SHAPE_VINE:
+		retVal = tesselateVineInWorld( tt, x, y, z );
+		break;
+	case Tile::SHAPE_FENCE_GATE:
+		retVal = tesselateFenceGateInWorld( ( FenceGateTile* )tt, x, y, z );
+		break;
+	case Tile::SHAPE_CAULDRON:
+		retVal = tesselateCauldronInWorld((CauldronTile* ) tt, x, y, z);
+		break;
+	case Tile::SHAPE_FLOWER_POT:
+		retVal = tesselateFlowerPotInWorld((FlowerPotTile *) tt, x, y, z);
+		break;
+	case Tile::SHAPE_ANVIL:
+		retVal = tesselateAnvilInWorld((AnvilTile *) tt, x, y, z);
+		break;
+	case Tile::SHAPE_BREWING_STAND:
+		retVal = tesselateBrewingStandInWorld((BrewingStandTile* ) tt, x, y, z);
+		break;
+	case Tile::SHAPE_PORTAL_FRAME:
+		retVal = tesselateAirPortalFrameInWorld((TheEndPortalFrameTile *)tt, x, y, z);
+		break;
+	case Tile::SHAPE_COCOA:
+		retVal = tesselateCocoaInWorld((CocoaTile *) tt, x, y, z);
+		break;
+	};
+
+
+	t->setMipmapEnable( true );	// 4J added
+	return retVal;
+
+}
+
+bool TileRenderer::tesselateAirPortalFrameInWorld(TheEndPortalFrameTile *tt, int x, int y, int z)
+{
+    int data = level->getData(x, y, z);
+
+    int direction = data & 3;
+    if (direction == Direction::SOUTH)
+	{
+        upFlip = FLIP_180;
+    }
+	else if (direction == Direction::EAST)
+	{
+        upFlip = FLIP_CW;
+    }
+	else if (direction == Direction::WEST)
+	{
+        upFlip = FLIP_CCW;
+    }
+
+    if (!TheEndPortalFrameTile::hasEye(data))
+	{
+        setShape(0, 0, 0, 1, 13.0f / 16.0f, 1);
+        tesselateBlockInWorld(tt, x, y, z);
+
+        upFlip = FLIP_NONE;
+        return true;
+    }
+
+	noCulling = true;
+    setShape(0, 0, 0, 1, 13.0f / 16.0f, 1);
+    tesselateBlockInWorld(tt, x, y, z);
+    setFixedTexture(tt->getEye());
+    setShape(4.0f / 16.0f, 13.0f / 16.0f, 4.0f / 16.0f, 12.0f / 16.0f, 1, 12.0f / 16.0f);
+    tesselateBlockInWorld(tt, x, y, z);
+	noCulling = false;
+    clearFixedTexture();
+
+    upFlip = FLIP_NONE;
+    return true;
+}
+
+bool TileRenderer::tesselateBedInWorld( Tile* tt, int x, int y, int z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	int			data = level->getData( x, y, z );
+	int			direction = BedTile::getDirection( data );
+	bool		isHead = BedTile::isHeadPiece( data );
+
+	float		c10 = 0.5f;
+	float		c11 = 1.0f;
+	float		c2 = 0.8f;
+	float		c3 = 0.6f;
+
+	float		r11 = c11;
+	float		g11 = c11;
+	float		b11 = c11;
+
+	float		r10 = c10;
+	float		r2 = c2;
+	float		r3 = c3;
+
+	float		g10 = c10;
+	float		g2 = c2;
+	float		g3 = c3;
+
+	float		b10 = c10;
+	float		b2 = c2;
+	float		b3 = c3;
+
+	// 4J - change brought forward from 1.8.2
+	int			centerColor;
+	float		centerBrightness;
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		centerColor = getLightColor(tt,  level, x, y, z );
+	}
+	else
+	{
+		centerBrightness = tt->getBrightness( level, x, y, z );
+	}
+
+	// render wooden underside
+	{
+		// 4J - change brought forward from 1.8.2
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( centerColor );
+			t->color( r10, g10, b10 );
+		}
+		else
+		{
+			t->color( r10 * centerBrightness, g10 * centerBrightness, b10 * centerBrightness );
+		}
+
+		Icon *tex = getTexture( tt,  level, x, y, z, Facing::DOWN );
+
+		float u0 = tex->getU0(true);
+		float u1 = tex->getU1(true);
+		float v0 = tex->getV0(true);
+		float v1 = tex->getV1(true);
+
+		float x0 = x + tileShapeX0;
+		float x1 = x + tileShapeX1;
+		float y0 = y + tileShapeY0 + 3.0 / 16.0;
+		float z0 = z + tileShapeZ0;
+		float z1 = z + tileShapeZ1;
+
+		t->vertexUV(  x0 , y0 , z1 ,  u0 , v1  );
+		t->vertexUV(  x0 , y0 , z0 ,  u0 , v0  );
+		t->vertexUV(  x1 , y0 , z0 ,  u1 , v0  );
+		t->vertexUV(  x1 , y0 , z1 ,  u1 , v1  );
+	}
+
+	// render bed top
+	// 4J - change brought forward from 1.8.2
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y + 1, z ) );
+		t->color( r11, g11, b11 );
+	}
+	else
+	{
+		float brightness = tt->getBrightness( level, x, y + 1, z );
+		t->color( r11 * brightness, g11 * brightness, b11 * brightness );
+	}
+
+	Icon *tex = getTexture( tt, level, x, y, z, Facing::UP );
+
+	float u0 = tex->getU0(true);
+	float u1 = tex->getU1(true);
+	float v0 = tex->getV0(true);
+	float v1 = tex->getV1(true);
+
+	float	topLeftU = u0;
+	float	topRightU = u1;
+	float	topLeftV = v0;
+	float	topRightV = v0;
+	float	bottomLeftU = u0;
+	float	bottomRightU = u1;
+	float	bottomLeftV = v1;
+	float	bottomRightV = v1;
+
+	if ( direction == Direction::SOUTH )
+	{
+		// rotate 90 degrees clockwise
+		topRightU = u0;
+		topLeftV = v1;
+		bottomLeftU = u1;
+		bottomRightV = v0;
+	}
+	else if ( direction == Direction::NORTH )
+	{
+		// rotate 90 degrees counter-clockwise
+		topLeftU = u1;
+		topRightV = v1;
+		bottomRightU = u0;
+		bottomLeftV = v0;
+	}
+	else if ( direction == Direction::EAST )
+	{
+		// rotate 180 degrees
+		topLeftU = u1;
+		topRightV = v1;
+		bottomRightU = u0;
+		bottomLeftV = v0;
+		topRightU = u0;
+		topLeftV = v1;
+		bottomLeftU = u1;
+		bottomRightV = v0;
+	}
+
+	float x0 = x + tileShapeX0;
+	float x1 = x + tileShapeX1;
+	float y1 = y + tileShapeY1;
+	float z0 = z + tileShapeZ0;
+	float z1 = z + tileShapeZ1;
+
+	t->vertexUV( x1 , y1 , z1 , bottomLeftU ,bottomLeftV  );
+	t->vertexUV( x1 , y1 , z0 , topLeftU , topLeftV  );
+	t->vertexUV( x0 , y1 , z0 , topRightU ,topRightV  );
+	t->vertexUV( x0 , y1 , z1 , bottomRightU ,bottomRightV  );
+
+	// determine which edge to skip (the one between foot and head piece)
+	int			skipEdge = Direction::DIRECTION_FACING[direction];
+	if ( isHead )
+	{
+		skipEdge = Direction::DIRECTION_FACING[Direction::DIRECTION_OPPOSITE[direction]];
+	}
+	// and which edge to x-flip
+	int			flipEdge = Facing::WEST;
+	switch ( direction )
+	{
+		case Direction::NORTH:
+			break;
+		case Direction::SOUTH:
+			flipEdge = Facing::EAST;
+			break;
+		case Direction::EAST:
+			flipEdge = Facing::NORTH;
+			break;
+		case Direction::WEST:
+			flipEdge = Facing::SOUTH;
+			break;
+	}
+
+	if ( ( skipEdge != Facing::NORTH ) && ( noCulling || tt->shouldRenderFace( level, x, y, z - 1, Facing::NORTH ) ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ0 > 0 ? centerColor : getLightColor(tt,  level, x, y, z - 1 ) );
+			t->color( r2, g2, b2 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y, z - 1 );
+			if ( tileShapeZ0 > 0 ) br = centerBrightness;
+			t->color( r2 * br, g2 * br, b2 * br );
+		}
+		xFlipTexture = flipEdge == Facing::NORTH;
+		renderNorth( tt, x, y, z, getTexture( tt, level, x, y, z, 2 ) );
+	}
+
+	if ( ( skipEdge != Facing::SOUTH ) && ( noCulling || tt->shouldRenderFace( level, x, y, z + 1, Facing::SOUTH ) ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ1 < 1 ? centerColor : getLightColor(tt,  level, x, y, z + 1 ) );
+			t->color( r2, g2, b2 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y, z + 1 );
+			if ( tileShapeZ1 < 1 ) br = centerBrightness;
+			t->color( r2 * br, g2 * br, b2 * br );
+		}
+
+		xFlipTexture = flipEdge == Facing::SOUTH;
+		renderSouth( tt, x, y, z, getTexture( tt, level, x, y, z, 3 ) );
+	}
+
+	if ( ( skipEdge != Facing::WEST ) && ( noCulling || tt->shouldRenderFace( level, x - 1, y, z, Facing::WEST ) ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ0 > 0 ? centerColor : getLightColor(tt,  level, x - 1, y, z ) );
+			t->color( r3, g3, b3 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x - 1, y, z );
+			if ( tileShapeX0 > 0 ) br = centerBrightness;
+			t->color( r3 * br, g3 * br, b3 * br );
+		}
+		xFlipTexture = flipEdge == Facing::WEST;
+		renderWest( tt, x, y, z, getTexture( tt, level, x, y, z, 4 ) );
+	}
+
+	if ( ( skipEdge != Facing::EAST ) && ( noCulling || tt->shouldRenderFace( level, x + 1, y, z, Facing::EAST ) ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ1 < 1 ? centerColor : getLightColor(tt,  level, x + 1, y, z ) );
+			t->color( r3, g3, b3 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x + 1, y, z );
+			if ( tileShapeX1 < 1 ) br = centerBrightness;
+			t->color( r3 * br, g3 * br, b3 * br );
+		}
+		xFlipTexture = flipEdge == Facing::EAST;
+		renderEast( tt, x, y, z, getTexture( tt, level, x, y, z, 5 ) );
+	}
+	xFlipTexture = false;
+	return true;
+
+}
+
+bool TileRenderer::tesselateBrewingStandInWorld(BrewingStandTile *tt, int x, int y, int z)
+{
+    // bounding box first
+    setShape(7.0f / 16.0f, 0.0f, 7.0f / 16.0f, 9.0f / 16.0f, 14.0f / 16.0f, 9.0f / 16.0f);
+    tesselateBlockInWorld(tt, x, y, z);
+
+    setFixedTexture(tt->getBaseTexture());
+    setShape(9.0f / 16.0f, 0.0f, 5.0f / 16.0f, 15.0f / 16.0f, 2 / 16.0f, 11.0f / 16.0f);
+    tesselateBlockInWorld(tt, x, y, z);
+    setShape(2.0f / 16.0f, 0.0f, 1.0f / 16.0f, 8.0f / 16.0f, 2 / 16.0f, 7.0f / 16.0f);
+    tesselateBlockInWorld(tt, x, y, z);
+    setShape(2.0f / 16.0f, 0.0f, 9.0f / 16.0f, 8.0f / 16.0f, 2 / 16.0f, 15.0f / 16.0f);
+    tesselateBlockInWorld(tt, x, y, z);
+
+    clearFixedTexture();
+
+    Tesselator *t = Tesselator::getInstance();
+
+    float br;
+    if (SharedConstants::TEXTURE_LIGHTING)
+	{
+        t->tex2(getLightColor(tt, level, x, y, z));
+        br = 1;
+    }
+	else
+	{
+        br = tt->getBrightness(level, x, y, z);
+    }
+    int col = tt->getColor(level, x, y, z);
+    float r = ((col >> 16) & 0xff) / 255.0f;
+    float g = ((col >> 8) & 0xff) / 255.0f;
+    float b = ((col) & 0xff) / 255.0f;
+
+    t->color(br * r, br * g, br * b);
+
+	Icon *tex = getTexture(tt, 0, 0);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	float v0 = tex->getV0(true);
+	float v1 = tex->getV1(true);
+
+    int data = level->getData(x, y, z);
+
+    for (int arm = 0; arm < 3; arm++)
+	{
+
+        float angle = arm * PI * 2.0f / 3.0f + PI * 0.5f;
+
+		float u0 = tex->getU(8, true);
+		float u1 = tex->getU1(true);
+        if ((data & (1 << arm)) != 0)
+		{
+            u1 = tex->getU0(true);
+        }
+
+		float x0 = x + 8.0f / 16.0f;
+		float x1 = x + 8.0f / 16.0f + sin(angle) * 8.0f / 16.0f;
+		float z0 = z + 8.0f / 16.0f;
+		float z1 = z + 8.0f / 16.0f + cos(angle) * 8.0f / 16.0f;
+
+        t->vertexUV(x0, y + 1.0f, z0, u0, v0);
+        t->vertexUV(x0, y + 0.0f, z0, u0, v1);
+        t->vertexUV(x1, y + 0.0f, z1, u1, v1);
+        t->vertexUV(x1, y + 1.0f, z1, u1, v0);
+
+        t->vertexUV(x1, y + 1.0f, z1, u1, v0);
+        t->vertexUV(x1, y + 0.0f, z1, u1, v1);
+        t->vertexUV(x0, y + 0.0f, z0, u0, v1);
+        t->vertexUV(x0, y + 1.0f, z0, u0, v0);
+    }
+
+    tt->updateDefaultShape();
+
+    return true;
+}
+
+bool TileRenderer::tesselateCauldronInWorld(CauldronTile *tt, int x, int y, int z)
+{
+    // bounding box first
+    tesselateBlockInWorld(tt, x, y, z);
+
+    Tesselator *t = Tesselator::getInstance();
+
+    float br;
+    if (SharedConstants::TEXTURE_LIGHTING)
+	{
+        t->tex2(getLightColor(tt, level, x, y, z));
+        br = 1;
+    }
+	else
+	{
+        br = tt->getBrightness(level, x, y, z);
+    }
+    int col = tt->getColor(level, x, y, z);
+    float r = ((col >> 16) & 0xff) / 255.0f;
+    float g = ((col >> 8) & 0xff) / 255.0f;
+    float b = ((col) & 0xff) / 255.0f;
+
+    t->color(br * r, br * g, br * b);
+
+    // render inside
+    Icon *insideTex = tt->getTexture(Facing::NORTH);
+    const float cWidth = ( 2.0f / 16.0f ) - ( 1.0f / 128.0f );		// 4J - Moved by 1/128th (smallest movement possible with our vertex storage) to remove gap at edge of cauldron
+    renderEast(tt, x - 1.0f + cWidth, y, z, insideTex);
+    renderWest(tt, x + 1.0f - cWidth, y, z, insideTex);
+    renderSouth(tt, x, y, z - 1.0f + cWidth, insideTex);
+    renderNorth(tt, x, y, z + 1.0f - cWidth, insideTex);
+
+    Icon *bottomTex = CauldronTile::getTexture(CauldronTile::TEXTURE_INSIDE);
+    renderFaceUp(tt, x, y - 1.0f + 4.0f / 16.0f, z, bottomTex);
+    renderFaceDown(tt, x, y + 1.0f - 12.0f / 16.0f, z, bottomTex);
+
+    int waterLevel = level->getData(x, y, z);
+    if (waterLevel > 0)
+	{
+        Icon *liquidTex = LiquidTile::getTexture(LiquidTile::TEXTURE_WATER_STILL);
+
+        if (waterLevel > 3)
+		{
+            waterLevel = 3;
+        }
+
+        renderFaceUp(tt, x, y - 1.0f + (6.0f + waterLevel * 3.0f) / 16.0f, z, liquidTex);
+    }
+
+    return true;
+
+}
+
+bool TileRenderer::tesselateFlowerPotInWorld(FlowerPotTile *tt, int x, int y, int z)
+{
+	// bounding box first
+	tesselateBlockInWorld(tt, x, y, z);
+
+	Tesselator *t = Tesselator::getInstance();
+
+	float br;
+	if (SharedConstants::TEXTURE_LIGHTING)
+	{
+		t->tex2(tt->getLightColor(level, x, y, z));
+		br = 1;
+	}
+	else
+	{
+		br = tt->getBrightness(level, x, y, z);
+	}
+	int col = tt->getColor(level, x, y, z);
+	Icon *tex = getTexture(tt, 0);
+	float r = ((col >> 16) & 0xff) / 255.0f;
+	float g = ((col >> 8) & 0xff) / 255.0f;
+	float b = ((col) & 0xff) / 255.0f;
+
+	if (GameRenderer::anaglyph3d)
+	{
+		float cr = (r * 30 + g * 59 + b * 11) / 100;
+		float cg = (r * 30 + g * 70) / (100);
+		float cb = (r * 30 + b * 70) / (100);
+
+		r = cr;
+		g = cg;
+		b = cb;
+	}
+	t->color(br * r, br * g, br * b);
+
+	// render inside
+
+	float halfWidth = (6.0f / 16.0f) / 2 - 0.001f;
+	renderEast(tt, x - 0.5f + halfWidth, y, z, tex);
+	renderWest(tt, x + 0.5f - halfWidth, y, z, tex);
+	renderSouth(tt, x, y, z - 0.5f + halfWidth, tex);
+	renderNorth(tt, x, y, z + 0.5f - halfWidth, tex);
+
+	renderFaceUp(tt, x, y - 0.5f + halfWidth + 3.0f / 16.0f, z, getTexture(Tile::dirt));
+
+	int type = level->getData(x, y, z);
+
+	if (type != 0)
+	{
+		float xOff = 0;
+		float yOff = 4;
+		float zOff = 0;
+		Tile *plant = NULL;
+
+		switch (type)
+		{
+		case FlowerPotTile::TYPE_FLOWER_RED:
+			plant = Tile::rose;
+			break;
+		case FlowerPotTile::TYPE_FLOWER_YELLOW:
+			plant = Tile::flower;
+			break;
+		case FlowerPotTile::TYPE_MUSHROOM_BROWN:
+			plant = Tile::mushroom1;
+			break;
+		case FlowerPotTile::TYPE_MUSHROOM_RED:
+			plant = Tile::mushroom2;
+			break;
+		}
+
+		t->addOffset(xOff / 16.0f, yOff / 16.0f, zOff / 16.0f);
+
+		if (plant != NULL)
+		{
+			tesselateInWorld(plant, x, y, z);
+		}
+		else
+		{
+			if (type == FlowerPotTile::TYPE_CACTUS)
+			{
+
+				// Force drawing of all faces else the cactus misses faces
+				// when a block is adjacent
+				noCulling = true;
+
+				float halfSize = 0.25f / 2;
+				setShape(0.5f - halfSize, 0.0f, 0.5f - halfSize, 0.5f + halfSize, 0.25f, 0.5f + halfSize);
+				tesselateBlockInWorld(Tile::cactus, x, y, z);
+				setShape(0.5f - halfSize, 0.25f, 0.5f - halfSize, 0.5f + halfSize, 0.5f, 0.5f + halfSize);
+				tesselateBlockInWorld(Tile::cactus, x, y, z);
+				setShape(0.5f - halfSize, 0.5f, 0.5f - halfSize, 0.5f + halfSize, 0.75f, 0.5f + halfSize);
+				tesselateBlockInWorld(Tile::cactus, x, y, z);
+
+				noCulling = false;
+
+				setShape(0, 0, 0, 1, 1, 1);
+			}
+			else if (type == FlowerPotTile::TYPE_SAPLING_DEFAULT)
+			{
+				tesselateCrossTexture(Tile::sapling, Sapling::TYPE_DEFAULT, x, y, z, 0.75f);
+			}
+			else if (type == FlowerPotTile::TYPE_SAPLING_BIRCH)
+			{
+				tesselateCrossTexture(Tile::sapling, Sapling::TYPE_BIRCH, x, y, z, 0.75f);
+			}
+			else if (type == FlowerPotTile::TYPE_SAPLING_EVERGREEN)
+			{
+				tesselateCrossTexture(Tile::sapling, Sapling::TYPE_EVERGREEN, x, y, z, 0.75f);
+			}
+			else if (type == FlowerPotTile::TYPE_SAPLING_JUNGLE)
+			{
+				tesselateCrossTexture(Tile::sapling, Sapling::TYPE_JUNGLE, x, y, z, 0.75f);
+			}
+			else if (type == FlowerPotTile::TYPE_FERN)
+			{
+				col = Tile::tallgrass->getColor(level, x, y, z);
+				r = ((col >> 16) & 0xff) / 255.0f;
+				g = ((col >> 8) & 0xff) / 255.0f;
+				b = ((col) & 0xff) / 255.0f;
+				t->color(br * r, br * g, br * b);
+				tesselateCrossTexture(Tile::tallgrass, TallGrass::FERN, x, y, z, 0.75f);
+			}
+			else if (type == FlowerPotTile::TYPE_DEAD_BUSH)
+			{
+				tesselateCrossTexture(Tile::deadBush, TallGrass::FERN, x, y, z, 0.75f);
+			}
+		}
+
+		t->addOffset(-xOff / 16.0f, -yOff / 16.0f, -zOff / 16.0f);
+	}
+
+	return true;
+}
+
+bool TileRenderer::tesselateAnvilInWorld(AnvilTile *tt, int x, int y, int z)
+{
+	return tesselateAnvilInWorld(tt, x, y, z, level->getData(x, y, z));
+
+}
+
+bool TileRenderer::tesselateAnvilInWorld(AnvilTile *tt, int x, int y, int z, int data)
+{
+	Tesselator *t = Tesselator::getInstance();
+
+	float br;
+	if (SharedConstants::TEXTURE_LIGHTING)
+	{
+		t->tex2(tt->getLightColor(level, x, y, z));
+		br = 1;
+	}
+	else
+	{
+		br = tt->getBrightness(level, x, y, z);
+	}
+	int col = tt->getColor(level, x, y, z);
+	float r = ((col >> 16) & 0xff) / 255.0f;
+	float g = ((col >> 8) & 0xff) / 255.0f;
+	float b = ((col) & 0xff) / 255.0f;
+
+	if (GameRenderer::anaglyph3d)
+	{
+		float cr = (r * 30 + g * 59 + b * 11) / 100;
+		float cg = (r * 30 + g * 70) / (100);
+		float cb = (r * 30 + b * 70) / (100);
+
+		r = cr;
+		g = cg;
+		b = cb;
+	}
+	t->color(br * r, br * g, br * b);
+
+	return tesselateAnvilInWorld(tt, x, y, z, data, false);
+}
+
+bool TileRenderer::tesselateAnvilInWorld(AnvilTile *tt, int x, int y, int z, int data, bool render)
+{
+	int facing = render ? 0 : data & 3;
+	bool rotate = false;
+	float bottom = 0;
+
+	switch (facing)
+	{
+	case Direction::NORTH:
+		eastFlip = FLIP_CW;
+		westFlip = FLIP_CCW;
+		break;
+	case Direction::SOUTH:
+		eastFlip = FLIP_CCW;
+		westFlip = FLIP_CW;
+		upFlip = FLIP_180;
+		downFlip = FLIP_180;
+		break;
+	case Direction::WEST:
+		northFlip = FLIP_CW;
+		southFlip = FLIP_CCW;
+		upFlip = FLIP_CCW;
+		downFlip = FLIP_CW;
+		rotate = true;
+		break;
+	case Direction::EAST:
+		northFlip = FLIP_CCW;
+		southFlip = FLIP_CW;
+		upFlip = FLIP_CW;
+		downFlip = FLIP_CCW;
+		rotate = true;
+		break;
+	}
+
+	bottom = tesselateAnvilPiece(tt, x, y, z, AnvilTile::PART_BASE, bottom, 12.0f / 16.0f, 4.0f / 16.0f, 12.0f / 16.0f, rotate, render, data);
+	bottom = tesselateAnvilPiece(tt, x, y, z, AnvilTile::PART_JOINT, bottom, 8.0f / 16.0f, 1.0f / 16.0f, 10.0f / 16.0f, rotate, render, data);
+	bottom = tesselateAnvilPiece(tt, x, y, z, AnvilTile::PART_COLUMN, bottom, 4.0f / 16.0f, 5.0f / 16.0f, 8.0f / 16.0f, rotate, render, data);
+	bottom = tesselateAnvilPiece(tt, x, y, z, AnvilTile::PART_TOP, bottom, 10.0f / 16.0f, 6.0f / 16.0f, 16.0f / 16.0f, rotate, render, data);
+
+	setShape(0, 0, 0, 1, 1, 1);
+	northFlip = FLIP_NONE;
+	southFlip = FLIP_NONE;
+	eastFlip = FLIP_NONE;
+	westFlip = FLIP_NONE;
+	upFlip = FLIP_NONE;
+	downFlip = FLIP_NONE;
+
+	return true;
+}
+
+float TileRenderer::tesselateAnvilPiece(AnvilTile *tt, int x, int y, int z, int part, float bottom, float width, float height, float length, bool rotate, bool render, int data)
+{
+	if (rotate)
+	{
+		float swap = width;
+		width = length;
+		length = swap;
+	}
+
+	width /= 2;
+	length /= 2;
+
+	tt->part = part;
+	setShape(0.5f - width, bottom, 0.5f - length, 0.5f + width, bottom + height, 0.5f + length);
+
+	if (render)
+	{
+		Tesselator *t = Tesselator::getInstance();
+		t->begin();
+		t->normal(0, -1, 0);
+		renderFaceDown(tt, 0, 0, 0, getTexture(tt, 0, data));
+		t->end();
+
+		t->begin();
+		t->normal(0, 1, 0);
+		renderFaceUp(tt, 0, 0, 0, getTexture(tt, 1, data));
+		t->end();
+
+		t->begin();
+		t->normal(0, 0, -1);
+		renderNorth(tt, 0, 0, 0, getTexture(tt, 2, data));
+		t->end();
+
+		t->begin();
+		t->normal(0, 0, 1);
+		renderSouth(tt, 0, 0, 0, getTexture(tt, 3, data));
+		t->end();
+
+		t->begin();
+		t->normal(-1, 0, 0);
+		renderWest(tt, 0, 0, 0, getTexture(tt, 4, data));
+		t->end();
+
+		t->begin();
+		t->normal(1, 0, 0);
+		renderEast(tt, 0, 0, 0, getTexture(tt, 5, data));
+		t->end();
+	}
+	else
+	{
+		tesselateBlockInWorld(tt, x, y, z);
+	}
+
+	return bottom + height;
+}
+
+bool TileRenderer::tesselateTorchInWorld( Tile* tt, int x, int y, int z )
+{
+	int			dir = level->getData( x, y, z );
+
+	Tesselator* t = Tesselator::getInstance();
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		t->color( 1.0f, 1.0f, 1.0f );
+	}
+	else
+	{
+		float br = tt->getBrightness( level, x, y, z );
+		if ( Tile::lightEmission[tt->id] > 0 ) br = 1.0f;
+		t->color( br, br, br );
+	}
+
+	float		r = 0.40f;
+	float		r2 = 0.5f - r;
+	float		h = 0.20f;
+	if ( dir == 1 )
+	{
+		tesselateTorch( tt, (float)x - r2, (float)y + h, (float)z, -r, 0.0f, 0 );
+	}
+	else if ( dir == 2 )
+	{
+		tesselateTorch( tt, (float)x + r2, (float)y + h, (float)z, +r, 0.0f, 0 );
+	}
+	else if ( dir == 3 )
+	{
+		tesselateTorch( tt, (float)x, (float)y + h, z - r2, 0.0f, -r, 0 );
+	}
+	else if ( dir == 4 )
+	{
+		tesselateTorch( tt, (float)x, (float)y + h, (float)z + r2, 0.0f, +r, 0 );
+	}
+	else
+	{
+		tesselateTorch( tt, (float)x, (float)y, (float)z, 0.0f, 0.0f, 0 );
+	}
+	return true;
+
+}
+
+bool TileRenderer::tesselateDiodeInWorld(DiodeTile *tt, int x, int y, int z)
+{
+	Tesselator *t = Tesselator::getInstance();
+
+	tesselateDiodeInWorld(tt, x, y, z, level->getData(x, y, z) & DiodeTile::DIRECTION_MASK);
+
+	return true;
+}
+
+void TileRenderer::tesselateDiodeInWorld( DiodeTile* tt, int x, int y, int z, int dir )
+{
+	// render half-block edges
+	tesselateBlockInWorld( tt, x, y, z );
+
+	Tesselator* t = Tesselator::getInstance();
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		t->color( 1.0f, 1.0f, 1.0f );
+	}
+	else
+	{
+		float br = tt->getBrightness( level, x, y, z );
+		if ( Tile::lightEmission[tt->id] > 0 ) br = 1.0f;
+		t->color( br, br, br );
+	}
+
+	int data = level->getData(x, y, z);
+
+	// 4J Stu - This block gets moved in a later version, but we don't need that yet
+	// BEGIN TORCH SECTION
+	{
+		int			dir = data & DiodeTile::DIRECTION_MASK;
+		int			delay = ( data & DiodeTile::DELAY_MASK ) >> DiodeTile::DELAY_SHIFT;
+		float		h = -3.0f / 16.0f;
+		float		transmitterX = 0.0f;
+		float		transmitterZ = 0.0f;
+		float		receiverX = 0.0f;
+		float		receiverZ = 0.0f;
+
+		switch ( dir )
+		{
+			case Direction::SOUTH:
+				receiverZ = -5.0f / 16.0f;
+				transmitterZ = DiodeTile::DELAY_RENDER_OFFSETS[delay];
+				break;
+			case Direction::NORTH:
+				receiverZ = 5.0f / 16.0f;
+				transmitterZ = -DiodeTile::DELAY_RENDER_OFFSETS[delay];
+				break;
+			case Direction::EAST:
+				receiverX = -5.0f / 16.0f;
+				transmitterX = DiodeTile::DELAY_RENDER_OFFSETS[delay];
+				break;
+			case Direction::WEST:
+				receiverX = 5.0f / 16.0f;
+				transmitterX = -DiodeTile::DELAY_RENDER_OFFSETS[delay];
+				break;
+		}
+
+		// render transmitter
+		tesselateTorch( tt, x + transmitterX, y + h, z + transmitterZ, 0.0f, 0.0f, 0 );
+		// render receiver
+		tesselateTorch( tt, x + receiverX, y + h, z + receiverZ, 0.0f, 0.0f, 0 );
+	}
+	// END TORCH SECTION
+
+	Icon *tex = getTexture(tt, Facing::UP, data);
+	float u0 = tex->getU0(true);
+	float u1 = tex->getU1(true);
+	float v0 = tex->getV0(true);
+	float v1 = tex->getV1(true);
+
+	float		r = 2.0f / 16.0f;
+
+	float		x0 = ( float )( x + 1.0f );
+	float		x1 = ( float )( x + 1.0f );
+	float		x2 = ( float )( x + 0.0f );
+	float		x3 = ( float )( x + 0.0f );
+
+	float		z0 = ( float )( z + 0.0f );
+	float		z1 = ( float )( z + 1.0f );
+	float		z2 = ( float )( z + 1.0f );
+	float		z3 = ( float )( z + 0.0f );
+
+	float		y0 = ( float )( y + r );
+
+	if ( dir == Direction::NORTH )
+	{
+		// rotate 180 degrees
+		x0 = x1 = ( float )( x + 0.0f );
+		x2 = x3 = ( float )( x + 1.0f );
+		z0 = z3 = ( float )( z + 1.0f );
+		z1 = z2 = ( float )( z + 0.0f );
+	}
+	else if ( dir == Direction::EAST )
+	{
+		// rotate 90 degrees counter-clockwise
+		x0 = x3 = ( float )( x + 0.0f );
+		x1 = x2 = ( float )( x + 1.0f );
+		z0 = z1 = ( float )( z + 0.0f );
+		z2 = z3 = ( float )( z + 1.0f );
+	}
+	else if ( dir == Direction::WEST )
+	{
+		// rotate 90 degrees clockwise
+		x0 = x3 = ( float )( x + 1.0f );
+		x1 = x2 = ( float )( x + 0.0f );
+		z0 = z1 = ( float )( z + 1.0f );
+		z2 = z3 = ( float )( z + 0.0f );
+	}
+
+	t->vertexUV( x3 , y0 , z3 , u0 , v0  );
+	t->vertexUV( x2 , y0 , z2 , u0 , v1  );
+	t->vertexUV( x1 , y0 , z1 , u1 , v1  );
+	t->vertexUV( x0 , y0 , z0 , u1 , v0  );
+}
+
+void TileRenderer::tesselatePistonBaseForceExtended( Tile* tile, int x, int y, int z, int forceData )	// 4J added forceData param
+{
+	noCulling = true;
+	tesselatePistonBaseInWorld( tile, x, y, z, true, forceData );
+	noCulling = false;
+}
+
+bool TileRenderer::tesselatePistonBaseInWorld( Tile* tt, int x, int y, int z, bool forceExtended, int forceData ) // 4J added forceData param
+{
+	int			data = ( forceData == -1 ) ? level->getData( x, y, z ) : forceData;
+	bool		extended = forceExtended || ( data & PistonBaseTile::EXTENDED_BIT ) != 0;
+	int			facing = PistonBaseTile::getFacing( data );
+
+	const float thickness = PistonBaseTile::PLATFORM_THICKNESS / 16.0f;
+
+	if ( extended )
+	{
+		switch ( facing )
+		{
+			case Facing::DOWN:
+				northFlip = FLIP_180;
+				southFlip = FLIP_180;
+				eastFlip = FLIP_180;
+				westFlip = FLIP_180;
+				setShape( 0.0f, thickness, 0.0f, 1.0f, 1.0f, 1.0f );
+				break;
+			case Facing::UP:
+				setShape( 0.0f, 0.0f, 0.0f, 1.0f, 1.0f - thickness, 1.0f );
+				break;
+			case Facing::NORTH:
+				eastFlip = FLIP_CW;
+				westFlip = FLIP_CCW;
+				setShape( 0.0f, 0.0f, thickness, 1.0f, 1.0f, 1.0f );
+				break;
+			case Facing::SOUTH:
+				eastFlip = FLIP_CCW;
+				westFlip = FLIP_CW;
+				upFlip = FLIP_180;
+				downFlip = FLIP_180;
+				setShape( 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f - thickness );
+				break;
+			case Facing::WEST:
+				northFlip = FLIP_CW;
+				southFlip = FLIP_CCW;
+				upFlip = FLIP_CCW;
+				downFlip = FLIP_CW;
+				setShape( thickness, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f );
+				break;
+			case Facing::EAST:
+				northFlip = FLIP_CCW;
+				southFlip = FLIP_CW;
+				upFlip = FLIP_CW;
+				downFlip = FLIP_CCW;
+				setShape( 0.0f, 0.0f, 0.0f, 1.0f - thickness, 1.0f, 1.0f );
+				break;
+		}
+		// weird way of telling the piston to use the
+		// "inside" texture for the forward-facing edge
+		((PistonBaseTile *) tt)->updateShape((float) tileShapeX0, (float) tileShapeY0, (float) tileShapeZ0, (float) tileShapeX1, (float) tileShapeY1, (float) tileShapeZ1);
+		tesselateBlockInWorld( tt, x, y, z );
+		northFlip = FLIP_NONE;
+		southFlip = FLIP_NONE;
+		eastFlip = FLIP_NONE;
+		westFlip = FLIP_NONE;
+		upFlip = FLIP_NONE;
+		downFlip = FLIP_NONE;
+		((PistonBaseTile *) tt)->updateShape((float) tileShapeX0, (float) tileShapeY0, (float) tileShapeZ0, (float) tileShapeX1, (float) tileShapeY1, (float) tileShapeZ1);
+	}
+	else
+	{
+		switch ( facing )
+		{
+			case Facing::DOWN:
+				northFlip = FLIP_180;
+				southFlip = FLIP_180;
+				eastFlip = FLIP_180;
+				westFlip = FLIP_180;
+				break;
+			case Facing::UP:
+				break;
+			case Facing::NORTH:
+				eastFlip = FLIP_CW;
+				westFlip = FLIP_CCW;
+				break;
+			case Facing::SOUTH:
+				eastFlip = FLIP_CCW;
+				westFlip = FLIP_CW;
+				upFlip = FLIP_180;
+				downFlip = FLIP_180;
+				break;
+			case Facing::WEST:
+				northFlip = FLIP_CW;
+				southFlip = FLIP_CCW;
+				upFlip = FLIP_CCW;
+				downFlip = FLIP_CW;
+				break;
+			case Facing::EAST:
+				northFlip = FLIP_CCW;
+				southFlip = FLIP_CW;
+				upFlip = FLIP_CW;
+				downFlip = FLIP_CCW;
+				break;
+		}
+		tesselateBlockInWorld( tt, x, y, z );
+		northFlip = FLIP_NONE;
+		southFlip = FLIP_NONE;
+		eastFlip = FLIP_NONE;
+		westFlip = FLIP_NONE;
+		upFlip = FLIP_NONE;
+		downFlip = FLIP_NONE;
+	}
+
+	return true;
+
+}
+
+void TileRenderer::renderPistonArmUpDown( float x0, float x1, float y0, float y1, float z0, float z1, float br,
+										  float armLengthPixels )
+{
+	Icon *armTex = PistonBaseTile::getTexture(PistonBaseTile::EDGE_TEX);
+	if (hasFixedTexture()) armTex = fixedTexture;
+
+	Tesselator*		t = Tesselator::getInstance();
+
+	// upwards arm
+	float u00 = armTex->getU0(true);
+	float v00 = armTex->getV0(true);
+	float u11 = armTex->getU(armLengthPixels, true);
+	float v11 = armTex->getV(PistonBaseTile::PLATFORM_THICKNESS, true);
+
+	t->color( br, br, br );
+
+	t->vertexUV( x0, y1, z0, u11, v00 );
+	t->vertexUV( x0, y0, z0, u00, v00 );
+	t->vertexUV( x1, y0, z1, u00, v11 );
+	t->vertexUV( x1, y1, z1, u11, v11 );
+
+}
+
+void TileRenderer::renderPistonArmNorthSouth( float x0, float x1, float y0, float y1, float z0, float z1,
+											  float br, float armLengthPixels )
+{
+	Icon *armTex = PistonBaseTile::getTexture(PistonBaseTile::EDGE_TEX);
+	if (hasFixedTexture()) armTex = fixedTexture;
+
+	Tesselator*		t = Tesselator::getInstance();
+
+	// upwards arm
+	float u00 = armTex->getU0(true);
+	float v00 = armTex->getV0(true);
+	float u11 = armTex->getU(armLengthPixels, true);
+	float v11 = armTex->getV(PistonBaseTile::PLATFORM_THICKNESS, true);
+
+	t->color( br, br, br );
+
+	t->vertexUV( x0, y0, z1, u11, v00 );
+	t->vertexUV( x0, y0, z0, u00, v00 );
+	t->vertexUV( x1, y1, z0, u00, v11 );
+	t->vertexUV( x1, y1, z1, u11, v11 );
+}
+
+void TileRenderer::renderPistonArmEastWest( float x0, float x1, float y0, float y1, float z0, float z1, float br,
+											float armLengthPixels )
+{
+	Icon *armTex = PistonBaseTile::getTexture(PistonBaseTile::EDGE_TEX);
+	if (hasFixedTexture()) armTex = fixedTexture;
+
+	Tesselator*		t = Tesselator::getInstance();
+
+	// upwards arm
+	float u00 = armTex->getU0(true);
+	float v00 = armTex->getV0(true);
+	float u11 = armTex->getU(armLengthPixels, true);
+	float v11 = armTex->getV(PistonBaseTile::PLATFORM_THICKNESS, true);
+
+	t->color( br, br, br );
+
+	t->vertexUV( x1, y0, z0, u11, v00 );
+	t->vertexUV( x0, y0, z0, u00, v00 );
+	t->vertexUV( x0, y1, z1, u00, v11 );
+	t->vertexUV( x1, y1, z1, u11, v11 );
+}
+
+void TileRenderer::tesselatePistonArmNoCulling( Tile* tile, int x, int y, int z, bool fullArm, int forceData )		// 4J added forceData param
+{
+	noCulling = true;
+	tesselatePistonExtensionInWorld( tile, x, y, z, fullArm );
+	noCulling = false;
+}
+
+bool TileRenderer::tesselatePistonExtensionInWorld( Tile* tt, int x, int y, int z, bool fullArm, int forceData )	// 4J added forceData param
+{
+	int				data = ( forceData == -1 ) ? level->getData( x, y, z ) : forceData;
+	int				facing = PistonExtensionTile::getFacing( data );
+
+	const float		thickness = PistonBaseTile::PLATFORM_THICKNESS / 16.0f;
+	const float		leftEdge = ( 8.0f - ( PistonBaseTile::PLATFORM_THICKNESS / 2.0f ) ) / 16.0f;
+	const float		rightEdge = ( 8.0f + ( PistonBaseTile::PLATFORM_THICKNESS / 2.0f ) ) / 16.0f;
+	const float		br = tt->getBrightness( level, x, y, z );
+	const float		armLength = fullArm ? 1.0f : 0.5f;
+	const float		armLengthPixels = fullArm ? 16.0f : 8.0f;
+
+	Tesselator*		t = Tesselator::getInstance();
+	switch ( facing )
+	{
+		case Facing::DOWN:
+			northFlip = FLIP_180;
+			southFlip = FLIP_180;
+			eastFlip = FLIP_180;
+			westFlip = FLIP_180;
+			setShape( 0.0f, 0.0f, 0.0f, 1.0f, thickness, 1.0f );
+			tesselateBlockInWorld( tt, x, y, z );
+
+			t->tex2( getLightColor(tt,  level, x, y , z ) );		// 4J added - renderPistonArmDown doesn't set its own tex2 so just inherited from previous tesselateBlockInWorld
+			renderPistonArmUpDown( x + leftEdge, x + rightEdge, y + thickness, y + thickness + armLength,
+								   z + rightEdge, z + rightEdge, br * 0.8f, armLengthPixels );
+			renderPistonArmUpDown( x + rightEdge, x + leftEdge, y + thickness, y + thickness + armLength, z + leftEdge,
+								   z + leftEdge, br * 0.8f, armLengthPixels );
+			renderPistonArmUpDown( x + leftEdge, x + leftEdge, y + thickness, y + thickness + armLength, z + leftEdge,
+								   z + rightEdge, br * 0.6f, armLengthPixels );
+			renderPistonArmUpDown( x + rightEdge, x + rightEdge, y + thickness, y + thickness + armLength,
+								   z + rightEdge, z + leftEdge, br * 0.6f, armLengthPixels );
+
+			break;
+		case Facing::UP:
+			setShape( 0.0f, 1.0f - thickness, 0.0f, 1.0f, 1.0f, 1.0f );
+			tesselateBlockInWorld( tt, x, y, z );
+
+			t->tex2( getLightColor(tt,  level, x, y , z ) );		// 4J added - renderPistonArmDown doesn't set its own tex2 so just inherited from previous tesselateBlockInWorld
+			renderPistonArmUpDown( x + leftEdge, x + rightEdge, y - thickness + 1.0f - armLength, y - thickness + 1.0f,
+								   z + rightEdge, z + rightEdge, br * 0.8f, armLengthPixels );
+			renderPistonArmUpDown( x + rightEdge, x + leftEdge, y - thickness + 1.0f - armLength, y - thickness + 1.0f,
+								   z + leftEdge, z + leftEdge, br * 0.8f, armLengthPixels );
+			renderPistonArmUpDown( x + leftEdge, x + leftEdge, y - thickness + 1.0f - armLength, y - thickness + 1.0f,
+								   z + leftEdge, z + rightEdge, br * 0.6f, armLengthPixels );
+			renderPistonArmUpDown( x + rightEdge, x + rightEdge, y - thickness + 1.0f - armLength,
+								   y - thickness + 1.0f, z + rightEdge, z + leftEdge, br * 0.6f, armLengthPixels );
+			break;
+		case Facing::NORTH:
+			eastFlip = FLIP_CW;
+			westFlip = FLIP_CCW;
+			setShape( 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, thickness );
+			tesselateBlockInWorld( tt, x, y, z );
+
+			t->tex2( getLightColor(tt,  level, x, y , z ) );		// 4J added - renderPistonArmDown doesn't set its own tex2 so just inherited from previous tesselateBlockInWorld
+			renderPistonArmNorthSouth( x + leftEdge, x + leftEdge, y + rightEdge, y + leftEdge, z + thickness,
+									   z + thickness + armLength, br * 0.6f, armLengthPixels );
+			renderPistonArmNorthSouth( x + rightEdge, x + rightEdge, y + leftEdge, y + rightEdge, z + thickness,
+									   z + thickness + armLength, br * 0.6f, armLengthPixels );
+			renderPistonArmNorthSouth( x + leftEdge, x + rightEdge, y + leftEdge, y + leftEdge, z + thickness,
+									   z + thickness + armLength, br * 0.5f, armLengthPixels );
+			renderPistonArmNorthSouth( x + rightEdge, x + leftEdge, y + rightEdge, y + rightEdge, z + thickness,
+									   z + thickness + armLength, br, armLengthPixels );
+			break;
+		case Facing::SOUTH:
+			eastFlip = FLIP_CCW;
+			westFlip = FLIP_CW;
+			upFlip = FLIP_180;
+			downFlip = FLIP_180;
+			setShape( 0.0f, 0.0f, 1.0f - thickness, 1.0f, 1.0f, 1.0f );
+			tesselateBlockInWorld( tt, x, y, z );
+
+			t->tex2( getLightColor(tt,  level, x, y , z ) );		// 4J added - renderPistonArmDown doesn't set its own tex2 so just inherited from previous tesselateBlockInWorld
+			renderPistonArmNorthSouth( x + leftEdge, x + leftEdge, y + rightEdge, y + leftEdge,
+									   z - thickness + 1.0f - armLength, z - thickness + 1.0f, br * 0.6f,
+									   armLengthPixels );
+			renderPistonArmNorthSouth( x + rightEdge, x + rightEdge, y + leftEdge, y + rightEdge,
+									   z - thickness + 1.0f - armLength, z - thickness + 1.0f, br * 0.6f,
+									   armLengthPixels );
+			renderPistonArmNorthSouth( x + leftEdge, x + rightEdge, y + leftEdge, y + leftEdge,
+									   z - thickness + 1.0f - armLength, z - thickness + 1.0f, br * 0.5f,
+									   armLengthPixels );
+			renderPistonArmNorthSouth( x + rightEdge, x + leftEdge, y + rightEdge, y + rightEdge,
+									   z - thickness + 1.0f - armLength, z - thickness + 1.0f, br, armLengthPixels );
+			break;
+		case Facing::WEST:
+			northFlip = FLIP_CW;
+			southFlip = FLIP_CCW;
+			upFlip = FLIP_CCW;
+			downFlip = FLIP_CW;
+			setShape( 0.0f, 0.0f, 0.0f, thickness, 1.0f, 1.0f );
+			tesselateBlockInWorld( tt, x, y, z );					// 4J added - renderPistonArmDown doesn't set its own tex2 so just inherited from previous tesselateBlockInWorld
+
+			t->tex2( getLightColor(tt,  level, x, y , z ) );
+			renderPistonArmEastWest( x + thickness, x + thickness + armLength, y + leftEdge, y + leftEdge,
+									 z + rightEdge, z + leftEdge, br * 0.5f, armLengthPixels );
+			renderPistonArmEastWest( x + thickness, x + thickness + armLength, y + rightEdge, y + rightEdge,
+									 z + leftEdge, z + rightEdge, br, armLengthPixels );
+			renderPistonArmEastWest( x + thickness, x + thickness + armLength, y + leftEdge, y + rightEdge,
+									 z + leftEdge, z + leftEdge, br * 0.6f, armLengthPixels );
+			renderPistonArmEastWest( x + thickness, x + thickness + armLength, y + rightEdge, y + leftEdge,
+									 z + rightEdge, z + rightEdge, br * 0.6f, armLengthPixels );
+			break;
+		case Facing::EAST:
+			northFlip = FLIP_CCW;
+			southFlip = FLIP_CW;
+			upFlip = FLIP_CW;
+			downFlip = FLIP_CCW;
+			setShape( 1.0f - thickness, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f );
+			tesselateBlockInWorld( tt, x, y, z );
+
+			t->tex2( getLightColor(tt,  level, x, y , z ) );			// 4J added - renderPistonArmDown doesn't set its own tex2 so just inherited from previous tesselateBlockInWorld
+			renderPistonArmEastWest( x - thickness + 1.0f - armLength, x - thickness + 1.0f, y + leftEdge,
+									 y + leftEdge, z + rightEdge, z + leftEdge, br * 0.5f, armLengthPixels );
+			renderPistonArmEastWest( x - thickness + 1.0f - armLength, x - thickness + 1.0f, y + rightEdge,
+									 y + rightEdge, z + leftEdge, z + rightEdge, br, armLengthPixels );
+			renderPistonArmEastWest( x - thickness + 1.0f - armLength, x - thickness + 1.0f, y + leftEdge,
+									 y + rightEdge, z + leftEdge, z + leftEdge, br * 0.6f, armLengthPixels );
+			renderPistonArmEastWest( x - thickness + 1.0f - armLength, x - thickness + 1.0f, y + rightEdge,
+									 y + leftEdge, z + rightEdge, z + rightEdge, br * 0.6f, armLengthPixels );
+			break;
+	}
+	northFlip = FLIP_NONE;
+	southFlip = FLIP_NONE;
+	eastFlip = FLIP_NONE;
+	westFlip = FLIP_NONE;
+	upFlip = FLIP_NONE;
+	downFlip = FLIP_NONE;
+	setShape( 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f );
+
+	return true;
+
+}
+
+bool TileRenderer::tesselateLeverInWorld( Tile* tt, int x, int y, int z )
+{
+	int			data = level->getData( x, y, z );
+
+	int			dir = data & 7;
+	bool		flipped = ( data & 8 ) > 0;
+
+	Tesselator* t = Tesselator::getInstance();
+
+	bool hadFixed = hasFixedTexture();
+	if (!hadFixed) this->setFixedTexture(getTexture(Tile::stoneBrick));
+	float		w1 = 4.0f / 16.0f;
+	float		w2 = 3.0f / 16.0f;
+	float		h = 3.0f / 16.0f;
+
+	if ( dir == 5 )
+	{
+		setShape( 0.5f - w2, 0.0f, 0.5f - w1, 0.5f + w2, h, 0.5f + w1 );
+	}
+	else if ( dir == 6 )
+	{
+		setShape( 0.5f - w1, 0.0f, 0.5f - w2, 0.5f + w1, h, 0.5f + w2 );
+	}
+	else if ( dir == 4 )
+	{
+		setShape( 0.5f - w2, 0.5f - w1, 1.0f - h, 0.5f + w2, 0.5f + w1, 1.0f );
+	}
+	else if ( dir == 3 )
+	{
+		setShape( 0.5f - w2, 0.5f - w1, 0, 0.5f + w2, 0.5f + w1, h );
+	}
+	else if ( dir == 2 )
+	{
+		setShape( 1.0f - h, 0.5f - w1, 0.5f - w2, 1.0f, 0.5f + w1, 0.5f + w2 );
+	}
+	else if ( dir == 1 )
+	{
+		setShape( 0, 0.5f - w1, 0.5f - w2, h, 0.5f + w1, 0.5f + w2 );
+	}
+	else if (dir == 0)
+	{
+		setShape(0.5f - w1, 1 - h, 0.5f - w2, 0.5f + w1, 1, 0.5f + w2);
+	}
+	else if (dir == 7)
+	{
+		setShape(0.5f - w2, 1 - h, 0.5f - w1, 0.5f + w2, 1, 0.5f + w1);
+	}
+	this->tesselateBlockInWorld( tt, x, y, z );
+
+	if ( !hadFixed ) this->clearFixedTexture();
+
+	float		br;
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		br = 1;
+	}
+	else
+	{
+		br = tt->getBrightness( level, x, y, z );
+	}
+	if ( Tile::lightEmission[tt->id] > 0 ) br = 1.0f;
+	t->color( br, br, br );
+	Icon *tex = getTexture(tt, 0);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+
+	Vec3*		corners[8];
+	float		xv = 1.0f / 16.0f;
+	float		zv = 1.0f / 16.0f;
+	float		yv = 10.0f / 16.0f;
+	corners[0] = Vec3::newTemp( -xv, -0, -zv );
+	corners[1] = Vec3::newTemp( +xv, -0, -zv );
+	corners[2] = Vec3::newTemp( +xv, -0, +zv );
+	corners[3] = Vec3::newTemp( -xv, -0, +zv );
+	corners[4] = Vec3::newTemp( -xv, +yv, -zv );
+	corners[5] = Vec3::newTemp( +xv, +yv, -zv );
+	corners[6] = Vec3::newTemp( +xv, +yv, +zv );
+	corners[7] = Vec3::newTemp( -xv, +yv, +zv );
+
+	for ( int i = 0; i < 8; i++ )
+	{
+		if ( flipped )
+		{
+			corners[i]->z -= 1 / 16.0f;
+			corners[i]->xRot( 40 * PI / 180 );
+		}
+		else
+		{
+			corners[i]->z += 1 / 16.0f;
+			corners[i]->xRot( -40 * PI / 180 );
+		}
+		if (dir == 0 || dir == 7)
+		{
+			corners[i]->zRot(180 * PI / 180);
+		}
+		if ( dir == 6 || dir == 0 )
+		{
+			corners[i]->yRot( 90 * PI / 180 );
+		}
+
+		if ( dir > 0 && dir < 5 )
+		{
+			corners[i]->y -= 6 / 16.0f;
+			corners[i]->xRot( 90 * PI / 180 );
+
+			if ( dir == 4 ) corners[i]->yRot( 0 * PI / 180 );
+			if ( dir == 3 ) corners[i]->yRot( 180 * PI / 180 );
+			if ( dir == 2 ) corners[i]->yRot( 90 * PI / 180 );
+			if ( dir == 1 ) corners[i]->yRot( -90 * PI / 180 );
+
+			corners[i]->x += x + 0.5;
+			corners[i]->y += y + 8 / 16.0f;
+			corners[i]->z += z + 0.5;
+		}
+		else if (dir == 0 || dir == 7)
+		{
+			corners[i]->x += x + 0.5;
+			corners[i]->y += y + 14 / 16.0f;
+			corners[i]->z += z + 0.5;
+		}
+		else
+		{
+			corners[i]->x += x + 0.5;
+			corners[i]->y += y + 2 / 16.0f;
+			corners[i]->z += z + 0.5;
+		}
+	}
+
+	Vec3*		c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL;
+	for ( int i = 0; i < 6; i++ )
+	{
+		if ( i == 0 )
+		{
+			u0 = tex->getU(7, true);
+			v0 = tex->getV(6, true);
+			u1 = tex->getU(9, true);
+			v1 = tex->getV(8, true);
+		}
+		else if ( i == 2 )
+		{
+			u0 = tex->getU(7, true);
+			v0 = tex->getV(6, true);
+			u1 = tex->getU(9, true);
+			v1 = tex->getV1(true);
+		}
+		if ( i == 0 )
+		{
+			c0 = corners[0];
+			c1 = corners[1];
+			c2 = corners[2];
+			c3 = corners[3];
+		}
+		else if ( i == 1 )
+		{
+			c0 = corners[7];
+			c1 = corners[6];
+			c2 = corners[5];
+			c3 = corners[4];
+		}
+		else if ( i == 2 )
+		{
+			c0 = corners[1];
+			c1 = corners[0];
+			c2 = corners[4];
+			c3 = corners[5];
+		}
+		else if ( i == 3 )
+		{
+			c0 = corners[2];
+			c1 = corners[1];
+			c2 = corners[5];
+			c3 = corners[6];
+		}
+		else if ( i == 4 )
+		{
+			c0 = corners[3];
+			c1 = corners[2];
+			c2 = corners[6];
+			c3 = corners[7];
+		}
+		else if ( i == 5 )
+		{
+			c0 = corners[0];
+			c1 = corners[3];
+			c2 = corners[7];
+			c3 = corners[4];
+		}
+		t->vertexUV( ( float )( c0->x ), ( float )( c0->y ), ( float )( c0->z ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( c1->x ), ( float )( c1->y ), ( float )( c1->z ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( c2->x ), ( float )( c2->y ), ( float )( c2->z ), ( float )( u1 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( c3->x ), ( float )( c3->y ), ( float )( c3->z ), ( float )( u0 ), ( float )( v0 ) );
+	}
+	return true;
+
+}
+
+bool TileRenderer::tesselateTripwireSourceInWorld(Tile *tt, int x, int y, int z)
+{
+	Tesselator *t = Tesselator::getInstance();
+	int data = level->getData(x, y, z);
+	int dir = data & TripWireSourceTile::MASK_DIR;
+	bool attached = (data & TripWireSourceTile::MASK_ATTACHED) == TripWireSourceTile::MASK_ATTACHED;
+	bool powered = (data & TripWireSourceTile::MASK_POWERED) == TripWireSourceTile::MASK_POWERED;
+	bool suspended = !level->isTopSolidBlocking(x, y - 1, z);
+
+	bool hadFixed = hasFixedTexture();
+	if (!hadFixed) this->setFixedTexture(getTexture(Tile::wood));
+
+	float boxHeight = 4 / 16.0f;
+	float boxWidth = 2 / 16.0f;
+	float boxDepth = 2 / 16.0f;
+
+	float boxy0 = 0.3f - boxHeight;
+	float boxy1 = 0.3f + boxHeight;
+	if (dir == Direction::NORTH)
+	{
+		setShape(0.5f - boxWidth, boxy0, 1 - boxDepth, 0.5f + boxWidth, boxy1, 1);
+	}
+	else if (dir == Direction::SOUTH)
+	{
+		setShape(0.5f - boxWidth, boxy0, 0, 0.5f + boxWidth, boxy1, boxDepth);
+	}
+	else if (dir == Direction::WEST)
+	{
+		setShape(1 - boxDepth, boxy0, 0.5f - boxWidth, 1, boxy1, 0.5f + boxWidth);
+	}
+	else if (dir == Direction::EAST)
+	{
+		setShape(0, boxy0, 0.5f - boxWidth, boxDepth, boxy1, 0.5f + boxWidth);
+	}
+
+	this->tesselateBlockInWorld(tt, x, y, z);
+	if (!hadFixed) this->clearFixedTexture();
+
+	float brightness;
+	if (SharedConstants::TEXTURE_LIGHTING)
+	{
+		t->tex2(tt->getLightColor(level, x, y, z));
+		brightness = 1;
+	}
+	else
+	{
+		brightness = tt->getBrightness(level, x, y, z);
+	}
+	if (Tile::lightEmission[tt->id] > 0) brightness = 1.0f;
+	t->color(brightness, brightness, brightness);
+	Icon *tex = getTexture(tt, 0);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	double u0 = tex->getU0();
+	double v0 = tex->getV0();
+	double u1 = tex->getU1();
+	double v1 = tex->getV1();
+
+	Vec3 *corners[8];
+	float stickWidth = 0.75f / 16.0f;
+	float stickHeight = 0.75f / 16.0f;
+	float stickLength = 5 / 16.0f;
+	corners[0] = Vec3::newTemp(-stickWidth, -0, -stickHeight);
+	corners[1] = Vec3::newTemp(+stickWidth, -0, -stickHeight);
+	corners[2] = Vec3::newTemp(+stickWidth, -0, +stickHeight);
+	corners[3] = Vec3::newTemp(-stickWidth, -0, +stickHeight);
+	corners[4] = Vec3::newTemp(-stickWidth, +stickLength, -stickHeight);
+	corners[5] = Vec3::newTemp(+stickWidth, +stickLength, -stickHeight);
+	corners[6] = Vec3::newTemp(+stickWidth, +stickLength, +stickHeight);
+	corners[7] = Vec3::newTemp(-stickWidth, +stickLength, +stickHeight);
+
+	for (int i = 0; i < 8; i++)
+	{
+		corners[i]->z += 1 / 16.0f;
+
+		if (powered)
+		{
+			corners[i]->xRot(30 * PI / 180);
+			corners[i]->y -= 7 / 16.0f;
+		}
+		else if (attached)
+		{
+			corners[i]->xRot(5 * PI / 180);
+			corners[i]->y -= 7 / 16.0f;
+		}
+		else
+		{
+			corners[i]->xRot(-40 * PI / 180);
+			corners[i]->y -= 6 / 16.0f;
+		}
+
+		corners[i]->xRot(90 * PI / 180);
+
+		if (dir == Direction::NORTH) corners[i]->yRot(0 * PI / 180);
+		if (dir == Direction::SOUTH) corners[i]->yRot(180 * PI / 180);
+		if (dir == Direction::WEST) corners[i]->yRot(90 * PI / 180);
+		if (dir == Direction::EAST) corners[i]->yRot(-90 * PI / 180);
+
+		corners[i]->x += x + 0.5;
+		corners[i]->y += y + 5 / 16.0f;
+		corners[i]->z += z + 0.5;
+	}
+
+	Vec3 *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL;
+	int stickX0 = 7;
+	int stickX1 = 9;
+	int stickY0 = 9;
+	int stickY1 = 16;
+
+	for (int i = 0; i < 6; i++)
+	{
+		if (i == 0)
+		{
+			c0 = corners[0];
+			c1 = corners[1];
+			c2 = corners[2];
+			c3 = corners[3];
+			u0 = tex->getU(stickX0);
+			v0 = tex->getV(stickY0);
+			u1 = tex->getU(stickX1);
+			v1 = tex->getV(stickY0 + 2);
+		}
+		else if (i == 1)
+		{
+			c0 = corners[7];
+			c1 = corners[6];
+			c2 = corners[5];
+			c3 = corners[4];
+		}
+		else if (i == 2)
+		{
+			c0 = corners[1];
+			c1 = corners[0];
+			c2 = corners[4];
+			c3 = corners[5];
+			u0 = tex->getU(stickX0);
+			v0 = tex->getV(stickY0);
+			u1 = tex->getU(stickX1);
+			v1 = tex->getV(stickY1);
+		}
+		else if (i == 3)
+		{
+			c0 = corners[2];
+			c1 = corners[1];
+			c2 = corners[5];
+			c3 = corners[6];
+		}
+		else if (i == 4)
+		{
+			c0 = corners[3];
+			c1 = corners[2];
+			c2 = corners[6];
+			c3 = corners[7];
+		}
+		else if (i == 5)
+		{
+			c0 = corners[0];
+			c1 = corners[3];
+			c2 = corners[7];
+			c3 = corners[4];
+		}
+		t->vertexUV(c0->x, c0->y, c0->z, u0, v1);
+		t->vertexUV(c1->x, c1->y, c1->z, u1, v1);
+		t->vertexUV(c2->x, c2->y, c2->z, u1, v0);
+		t->vertexUV(c3->x, c3->y, c3->z, u0, v0);
+	}
+
+
+	float hoopWidth = 1.5f / 16.0f;
+	float hoopHeight = 1.5f / 16.0f;
+	float hoopLength = 0.5f / 16.0f;
+	corners[0] = Vec3::newTemp(-hoopWidth, -0, -hoopHeight);
+	corners[1] = Vec3::newTemp(+hoopWidth, -0, -hoopHeight);
+	corners[2] = Vec3::newTemp(+hoopWidth, -0, +hoopHeight);
+	corners[3] = Vec3::newTemp(-hoopWidth, -0, +hoopHeight);
+	corners[4] = Vec3::newTemp(-hoopWidth, +hoopLength, -hoopHeight);
+	corners[5] = Vec3::newTemp(+hoopWidth, +hoopLength, -hoopHeight);
+	corners[6] = Vec3::newTemp(+hoopWidth, +hoopLength, +hoopHeight);
+	corners[7] = Vec3::newTemp(-hoopWidth, +hoopLength, +hoopHeight);
+
+	for (int i = 0; i < 8; i++)
+	{
+		corners[i]->z += 3.5f / 16.0f;
+
+		if (powered)
+		{
+			corners[i]->y -= 1.5 / 16.0f;
+			corners[i]->z -= 2.6 / 16.0f;
+			corners[i]->xRot(0 * PI / 180);
+		}
+		else if (attached)
+		{
+			corners[i]->y += 0.25 / 16.0f;
+			corners[i]->z -= 2.75 / 16.0f;
+			corners[i]->xRot(10 * PI / 180);
+		}
+		else
+		{
+			corners[i]->xRot(50 * PI / 180);
+		}
+
+		if (dir == Direction::NORTH) corners[i]->yRot(0 * PI / 180);
+		if (dir == Direction::SOUTH) corners[i]->yRot(180 * PI / 180);
+		if (dir == Direction::WEST) corners[i]->yRot(90 * PI / 180);
+		if (dir == Direction::EAST) corners[i]->yRot(-90 * PI / 180);
+
+		corners[i]->x += x + 0.5;
+		corners[i]->y += y + 5 / 16.0f;
+		corners[i]->z += z + 0.5;
+	}
+
+	int hoopX0 = 5;
+	int hoopX1 = 11;
+	int hoopY0 = 3;
+	int hoopY1 = 9;
+
+	for (int i = 0; i < 6; i++)
+	{
+		if (i == 0)
+		{
+			c0 = corners[0];
+			c1 = corners[1];
+			c2 = corners[2];
+			c3 = corners[3];
+			u0 = tex->getU(hoopX0);
+			v0 = tex->getV(hoopY0);
+			u1 = tex->getU(hoopX1);
+			v1 = tex->getV(hoopY1);
+		}
+		else if (i == 1)
+		{
+			c0 = corners[7];
+			c1 = corners[6];
+			c2 = corners[5];
+			c3 = corners[4];
+		}
+		else if (i == 2)
+		{
+			c0 = corners[1];
+			c1 = corners[0];
+			c2 = corners[4];
+			c3 = corners[5];
+			u0 = tex->getU(hoopX0);
+			v0 = tex->getV(hoopY0);
+			u1 = tex->getU(hoopX1);
+			v1 = tex->getV(hoopY0 + 2);
+		}
+		else if (i == 3)
+		{
+			c0 = corners[2];
+			c1 = corners[1];
+			c2 = corners[5];
+			c3 = corners[6];
+		}
+		else if (i == 4)
+		{
+			c0 = corners[3];
+			c1 = corners[2];
+			c2 = corners[6];
+			c3 = corners[7];
+		}
+		else if (i == 5)
+		{
+			c0 = corners[0];
+			c1 = corners[3];
+			c2 = corners[7];
+			c3 = corners[4];
+		}
+		t->vertexUV(c0->x, c0->y, c0->z, u0, v1);
+		t->vertexUV(c1->x, c1->y, c1->z, u1, v1);
+		t->vertexUV(c2->x, c2->y, c2->z, u1, v0);
+		t->vertexUV(c3->x, c3->y, c3->z, u0, v0);
+	}
+
+	if (attached)
+	{
+		double hoopBottomY = corners[0]->y;
+		float width = 0.5f / 16.0f;
+		float top = 0.5f - (width / 2);
+		float bottom = top + width;
+		Icon *wireTex = getTexture(Tile::tripWire);
+		double wireX0 = wireTex->getU0();
+		double wireY0 = wireTex->getV(attached ? 2 : 0);
+		double wireX1 = wireTex->getU1();
+		double wireY1 = wireTex->getV(attached ? 4 : 2);
+		double floating = (suspended ? 3.5f : 1.5f) / 16.0;
+
+		brightness = tt->getBrightness(level, x, y, z) * 0.75f;
+		t->color(brightness, brightness, brightness);
+
+		if (dir == Direction::NORTH)
+		{
+			t->vertexUV(x + top, y + floating, z + 0.25, wireX0, wireY0);
+			t->vertexUV(x + bottom, y + floating, z + 0.25, wireX0, wireY1);
+			t->vertexUV(x + bottom, y + floating, z, wireX1, wireY1);
+			t->vertexUV(x + top, y + floating, z, wireX1, wireY0);
+
+			t->vertexUV(x + top, hoopBottomY, z + 0.5, wireX0, wireY0);
+			t->vertexUV(x + bottom, hoopBottomY, z + 0.5, wireX0, wireY1);
+			t->vertexUV(x + bottom, y + floating, z + 0.25, wireX1, wireY1);
+			t->vertexUV(x + top, y + floating, z + 0.25, wireX1, wireY0);
+		}
+		else if (dir == Direction::SOUTH)
+		{
+			t->vertexUV(x + top, y + floating, z + 0.75, wireX0, wireY0);
+			t->vertexUV(x + bottom, y + floating, z + 0.75, wireX0, wireY1);
+			t->vertexUV(x + bottom, hoopBottomY, z + 0.5, wireX1, wireY1);
+			t->vertexUV(x + top, hoopBottomY, z + 0.5, wireX1, wireY0);
+
+			t->vertexUV(x + top, y + floating, z + 1, wireX0, wireY0);
+			t->vertexUV(x + bottom, y + floating, z + 1, wireX0, wireY1);
+			t->vertexUV(x + bottom, y + floating, z + 0.75, wireX1, wireY1);
+			t->vertexUV(x + top, y + floating, z + 0.75, wireX1, wireY0);
+		}
+		else if (dir == Direction::WEST)
+		{
+			t->vertexUV(x, y + floating, z + bottom, wireX0, wireY1);
+			t->vertexUV(x + 0.25, y + floating, z + bottom, wireX1, wireY1);
+			t->vertexUV(x + 0.25, y + floating, z + top, wireX1, wireY0);
+			t->vertexUV(x, y + floating, z + top, wireX0, wireY0);
+
+			t->vertexUV(x + 0.25, y + floating, z + bottom, wireX0, wireY1);
+			t->vertexUV(x + 0.5, hoopBottomY, z + bottom, wireX1, wireY1);
+			t->vertexUV(x + 0.5, hoopBottomY, z + top, wireX1, wireY0);
+			t->vertexUV(x + 0.25, y + floating, z + top, wireX0, wireY0);
+		}
+		else
+		{
+			t->vertexUV(x + 0.5, hoopBottomY, z + bottom, wireX0, wireY1);
+			t->vertexUV(x + 0.75, y + floating, z + bottom, wireX1, wireY1);
+			t->vertexUV(x + 0.75, y + floating, z + top, wireX1, wireY0);
+			t->vertexUV(x + 0.5, hoopBottomY, z + top, wireX0, wireY0);
+
+			t->vertexUV(x + 0.75, y + floating, z + bottom, wireX0, wireY1);
+			t->vertexUV(x + 1, y + floating, z + bottom, wireX1, wireY1);
+			t->vertexUV(x + 1, y + floating, z + top, wireX1, wireY0);
+			t->vertexUV(x + 0.75, y + floating, z + top, wireX0, wireY0);
+		}
+	}
+
+	return true;
+}
+
+bool TileRenderer::tesselateTripwireInWorld(Tile *tt, int x, int y, int z)
+{
+	Tesselator *t = Tesselator::getInstance();
+	Icon *tex = getTexture(tt, 0);
+	int data = level->getData(x, y, z);
+	bool attached = (data & TripWireTile::MASK_ATTACHED) == TripWireTile::MASK_ATTACHED;
+	bool suspended = (data & TripWireTile::MASK_SUSPENDED) == TripWireTile::MASK_SUSPENDED;
+
+	if (hasFixedTexture()) tex = fixedTexture;
+
+	float brightness;
+	if (SharedConstants::TEXTURE_LIGHTING)
+	{
+		t->tex2(tt->getLightColor(level, x, y, z));
+	}
+	brightness = tt->getBrightness(level, x, y, z) * 0.75f;
+	t->color(brightness, brightness, brightness);
+
+	double wireX0 = tex->getU0();
+	double wireY0 = tex->getV(attached ? 2 : 0);
+	double wireX1 = tex->getU1();
+	double wireY1 = tex->getV(attached ? 4 : 2);
+	double floating = (suspended ? 3.5f : 1.5f) / 16.0;
+
+	bool w = TripWireTile::shouldConnectTo(level, x, y, z, data, Direction::WEST);
+	bool e = TripWireTile::shouldConnectTo(level, x, y, z, data, Direction::EAST);
+	bool n = TripWireTile::shouldConnectTo(level, x, y, z, data, Direction::NORTH);
+	bool s = TripWireTile::shouldConnectTo(level, x, y, z, data, Direction::SOUTH);
+
+	float width = 0.5f / 16.0f;
+	float top = 0.5f - (width / 2);
+	float bottom = top + width;
+
+	if (!n && !e && !s && !w)
+	{
+		n = true;
+		s = true;
+	}
+
+	if (n)
+	{
+		t->vertexUV(x + top, y + floating, z + 0.25, wireX0, wireY0);
+		t->vertexUV(x + bottom, y + floating, z + 0.25, wireX0, wireY1);
+		t->vertexUV(x + bottom, y + floating, z, wireX1, wireY1);
+		t->vertexUV(x + top, y + floating, z, wireX1, wireY0);
+
+		t->vertexUV(x + top, y + floating, z, wireX1, wireY0);
+		t->vertexUV(x + bottom, y + floating, z, wireX1, wireY1);
+		t->vertexUV(x + bottom, y + floating, z + 0.25, wireX0, wireY1);
+		t->vertexUV(x + top, y + floating, z + 0.25, wireX0, wireY0);
+	}
+	if (n || (s && !e && !w))
+	{
+		t->vertexUV(x + top, y + floating, z + 0.5, wireX0, wireY0);
+		t->vertexUV(x + bottom, y + floating, z + 0.5, wireX0, wireY1);
+		t->vertexUV(x + bottom, y + floating, z + 0.25, wireX1, wireY1);
+		t->vertexUV(x + top, y + floating, z + 0.25, wireX1, wireY0);
+
+		t->vertexUV(x + top, y + floating, z + 0.25, wireX1, wireY0);
+		t->vertexUV(x + bottom, y + floating, z + 0.25, wireX1, wireY1);
+		t->vertexUV(x + bottom, y + floating, z + 0.5, wireX0, wireY1);
+		t->vertexUV(x + top, y + floating, z + 0.5, wireX0, wireY0);
+	}
+	if (s || (n && !e && !w))
+	{
+		t->vertexUV(x + top, y + floating, z + 0.75, wireX0, wireY0);
+		t->vertexUV(x + bottom, y + floating, z + 0.75, wireX0, wireY1);
+		t->vertexUV(x + bottom, y + floating, z + 0.5, wireX1, wireY1);
+		t->vertexUV(x + top, y + floating, z + 0.5, wireX1, wireY0);
+
+		t->vertexUV(x + top, y + floating, z + 0.5, wireX1, wireY0);
+		t->vertexUV(x + bottom, y + floating, z + 0.5, wireX1, wireY1);
+		t->vertexUV(x + bottom, y + floating, z + 0.75, wireX0, wireY1);
+		t->vertexUV(x + top, y + floating, z + 0.75, wireX0, wireY0);
+	}
+	if (s)
+	{
+		t->vertexUV(x + top, y + floating, z + 1, wireX0, wireY0);
+		t->vertexUV(x + bottom, y + floating, z + 1, wireX0, wireY1);
+		t->vertexUV(x + bottom, y + floating, z + 0.75, wireX1, wireY1);
+		t->vertexUV(x + top, y + floating, z + 0.75, wireX1, wireY0);
+
+		t->vertexUV(x + top, y + floating, z + 0.75, wireX1, wireY0);
+		t->vertexUV(x + bottom, y + floating, z + 0.75, wireX1, wireY1);
+		t->vertexUV(x + bottom, y + floating, z + 1, wireX0, wireY1);
+		t->vertexUV(x + top, y + floating, z + 1, wireX0, wireY0);
+	}
+
+	if (w)
+	{
+		t->vertexUV(x, y + floating, z + bottom, wireX0, wireY1);
+		t->vertexUV(x + 0.25, y + floating, z + bottom, wireX1, wireY1);
+		t->vertexUV(x + 0.25, y + floating, z + top, wireX1, wireY0);
+		t->vertexUV(x, y + floating, z + top, wireX0, wireY0);
+
+		t->vertexUV(x, y + floating, z + top, wireX0, wireY0);
+		t->vertexUV(x + 0.25, y + floating, z + top, wireX1, wireY0);
+		t->vertexUV(x + 0.25, y + floating, z + bottom, wireX1, wireY1);
+		t->vertexUV(x, y + floating, z + bottom, wireX0, wireY1);
+	}
+	if (w || (e && !n && !s))
+	{
+		t->vertexUV(x + 0.25, y + floating, z + bottom, wireX0, wireY1);
+		t->vertexUV(x + 0.5, y + floating, z + bottom, wireX1, wireY1);
+		t->vertexUV(x + 0.5, y + floating, z + top, wireX1, wireY0);
+		t->vertexUV(x + 0.25, y + floating, z + top, wireX0, wireY0);
+
+		t->vertexUV(x + 0.25, y + floating, z + top, wireX0, wireY0);
+		t->vertexUV(x + 0.5, y + floating, z + top, wireX1, wireY0);
+		t->vertexUV(x + 0.5, y + floating, z + bottom, wireX1, wireY1);
+		t->vertexUV(x + 0.25, y + floating, z + bottom, wireX0, wireY1);
+	}
+	if (e || (w && !n && !s))
+	{
+		t->vertexUV(x + 0.5, y + floating, z + bottom, wireX0, wireY1);
+		t->vertexUV(x + 0.75, y + floating, z + bottom, wireX1, wireY1);
+		t->vertexUV(x + 0.75, y + floating, z + top, wireX1, wireY0);
+		t->vertexUV(x + 0.5, y + floating, z + top, wireX0, wireY0);
+
+		t->vertexUV(x + 0.5, y + floating, z + top, wireX0, wireY0);
+		t->vertexUV(x + 0.75, y + floating, z + top, wireX1, wireY0);
+		t->vertexUV(x + 0.75, y + floating, z + bottom, wireX1, wireY1);
+		t->vertexUV(x + 0.5, y + floating, z + bottom, wireX0, wireY1);
+	}
+	if (e)
+	{
+		t->vertexUV(x + 0.75, y + floating, z + bottom, wireX0, wireY1);
+		t->vertexUV(x + 1, y + floating, z + bottom, wireX1, wireY1);
+		t->vertexUV(x + 1, y + floating, z + top, wireX1, wireY0);
+		t->vertexUV(x + 0.75, y + floating, z + top, wireX0, wireY0);
+
+		t->vertexUV(x + 0.75, y + floating, z + top, wireX0, wireY0);
+		t->vertexUV(x + 1, y + floating, z + top, wireX1, wireY0);
+		t->vertexUV(x + 1, y + floating, z + bottom, wireX1, wireY1);
+		t->vertexUV(x + 0.75, y + floating, z + bottom, wireX0, wireY1);
+	}
+
+	return true;
+}
+
+bool TileRenderer::tesselateFireInWorld( FireTile* tt, int x, int y, int z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	Icon *firstTex = tt->getTextureLayer(0);
+	Icon *secondTex = tt->getTextureLayer(1);
+	Icon *tex = firstTex;
+
+	if (hasFixedTexture()) tex = fixedTexture;
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->color( 1.0f, 1.0f, 1.0f );
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+	}
+	else
+	{
+		float br = tt->getBrightness( level, x, y, z );
+		t->color( br, br, br );
+	}
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+	float		h = 1.4f;
+
+	if ( level->isTopSolidBlocking( x, y - 1, z ) || Tile::fire->canBurn( level, x, y - 1, z ) )
+	{
+		float	x0 = x + 0.5f + 0.2f;
+		float	x1 = x + 0.5f - 0.2f;
+		float	z0 = z + 0.5f + 0.2f;
+		float	z1 = z + 0.5f - 0.2f;
+
+		float	x0_ = x + 0.5f - 0.3f;
+		float	x1_ = x + 0.5f + 0.3f;
+		float	z0_ = z + 0.5f - 0.3f;
+		float	z1_ = z + 0.5f + 0.3f;
+
+		t->vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z + 1 ), ( float )( u1 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z + 1 ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z + 0 ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z + 0 ), ( float )( u0 ), ( float )( v0 ) );
+
+		t->vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z + 0 ), ( float )( u1 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z + 0 ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z + 1 ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z + 1 ), ( float )( u0 ), ( float )( v0 ) );
+
+		tex = secondTex;
+		u0 = tex->getU0(true);
+		v0 = tex->getV0(true);
+		u1 = tex->getU1(true);
+		v1 = tex->getV1(true);
+
+		t->vertexUV( ( float )( x + 1 ), ( float )( y + h ), ( float )( z1_ ), ( float )( u1 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 0 ), ( float )( y + h ), ( float )( z1_ ), ( float )( u0 ), ( float )( v0 ) );
+
+		t->vertexUV( ( float )( x + 0 ), ( float )( y + h ), ( float )( z0_ ), ( float )( u1 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 1 ), ( float )( y + h ), ( float )( z0_ ), ( float )( u0 ), ( float )( v0 ) );
+
+		x0 = x + 0.5f - 0.5f;
+		x1 = x + 0.5f + 0.5f;
+		z0 = z + 0.5f - 0.5f;
+		z1 = z + 0.5f + 0.5f;
+
+		x0_ = x + 0.5f - 0.4f;
+		x1_ = x + 0.5f + 0.4f;
+		z0_ = z + 0.5f - 0.4f;
+		z1_ = z + 0.5f + 0.4f;
+
+		t->vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z + 0 ), ( float )( u0 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z + 0 ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z + 1 ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z + 1 ), ( float )( u1 ), ( float )( v0 ) );
+
+		t->vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z + 1 ), ( float )( u0 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z + 1 ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z + 0 ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z + 0 ), ( float )( u1 ), ( float )( v0 ) );
+
+		tex = firstTex;
+		u0 = tex->getU0(true);
+		v0 = tex->getV0(true);
+		u1 = tex->getU1(true);
+		v1 = tex->getV1(true);
+
+		t->vertexUV( ( float )( x + 0 ), ( float )( y + h ), ( float )( z1_ ), ( float )( u0 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 1 ), ( float )( y + h ), ( float )( z1_ ), ( float )( u1 ), ( float )( v0 ) );
+
+		t->vertexUV( ( float )( x + 1 ), ( float )( y + h ), ( float )( z0_ ), ( float )( u0 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 0 ), ( float )( y + h ), ( float )( z0_ ), ( float )( u1 ), ( float )( v0 ) );
+	}
+	else
+	{
+		float	r = 0.2f;
+		float	yo = 1 / 16.0f;
+		if ( ( ( x + y + z ) & 1 ) == 1 )
+		{
+			tex = secondTex;
+			u0 = tex->getU0(true);
+			v0 = tex->getV0(true);
+			u1 = tex->getU1(true);
+			v1 = tex->getV1(true);
+		}
+		if ( ( ( x / 2 + y / 2 + z / 2 ) & 1 ) == 1 )
+		{
+			float tmp = u1;
+			u1 = u0;
+			u0 = tmp;
+		}
+		if ( Tile::fire->canBurn( level, x - 1, y, z ) )
+		{
+			t->vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+
+			t->vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+		}
+		if ( Tile::fire->canBurn( level, x + 1, y, z ) )
+		{
+			t->vertexUV( ( float )( x + 1 - r ), ( float )( y + h + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+			t->vertexUV( ( float )( x + 1 - 0 ), ( float )( y + 0 + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 1 - 0 ), ( float )( y + 0 + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 1 - r ), ( float )( y + h + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+
+			t->vertexUV( ( float )( x + 1.0f - r ), ( float )( y + h + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+			t->vertexUV( ( float )( x + 1.0f - 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 1.0f - 0 ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 1.0f - r ), ( float )( y + h + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+		}
+		if ( Tile::fire->canBurn( level, x, y, z - 1 ) )
+		{
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z +
+						 r ), ( float )( u1 ), ( float )( v0 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z +
+						 r ), ( float )( u0 ), ( float )( v0 ) );
+
+			t->vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z +
+						 r ), ( float )( u0 ), ( float )( v0 ) );
+			t->vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z +
+						 r ), ( float )( u1 ), ( float )( v0 ) );
+		}
+		if ( Tile::fire->canBurn( level, x, y, z + 1 ) )
+		{
+			t->vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
+						 r ), ( float )( u0 ), ( float )( v0 ) );
+			t->vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
+						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
+						 r ), ( float )( u1 ), ( float )( v0 ) );
+
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
+						 r ), ( float )( u1 ), ( float )( v0 ) );
+			t->vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
+						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
+						 r ), ( float )( u0 ), ( float )( v0 ) );
+		}
+		if ( Tile::fire->canBurn( level, x, y + 1.0f, z ) )
+		{
+			double	x0 = x + 0.5f + 0.5f;
+			double	x1 = x + 0.5f - 0.5f;
+			double	z0 = z + 0.5f + 0.5f;
+			double	z1 = z + 0.5f - 0.5f;
+
+			double	x0_ = x + 0.5f - 0.5f;
+			double	x1_ = x + 0.5f + 0.5f;
+			double	z0_ = z + 0.5f - 0.5f;
+			double	z1_ = z + 0.5f + 0.5f;
+
+			tex = firstTex;
+			u0 = tex->getU0(true);
+			v0 = tex->getV0(true);
+			u1 = tex->getU1(true);
+			v1 = tex->getV1(true);
+
+			y += 1;
+			h = -0.2f;
+
+			if ( ( ( x + y + z ) & 1 ) == 0 )
+			{
+				t->vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z +
+							 0 ), ( float )( u1 ), ( float )( v0 ) );
+				t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z +
+							 0 ), ( float )( u1 ), ( float )( v1 ) );
+				t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z +
+							 1 ), ( float )( u0 ), ( float )( v1 ) );
+				t->vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z +
+							 1 ), ( float )( u0 ), ( float )( v0 ) );
+
+				tex = secondTex;
+				u0 = tex->getU0(true);
+				v0 = tex->getV0(true);
+				u1 = tex->getU1(true);
+				v1 = tex->getV1(true);
+
+				t->vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z +
+							 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+				t->vertexUV( ( float )( x1 ), ( float )( y + 0.0f ), ( float )( z +
+							 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+				t->vertexUV( ( float )( x1 ), ( float )( y + 0.0f ), ( float )( z +
+							 0 ), ( float )( u0 ), ( float )( v1 ) );
+				t->vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z +
+							 0 ), ( float )( u0 ), ( float )( v0 ) );
+			}
+			else
+			{
+				t->vertexUV( ( float )( x + 0.0f ), ( float )( y +
+							 h ), ( float )( z1_ ), ( float )( u1 ), ( float )( v0 ) );
+				t->vertexUV( ( float )( x + 0.0f ), ( float )( y +
+							 0.0f ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+				t->vertexUV( ( float )( x + 1.0f ), ( float )( y +
+							 0.0f ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+				t->vertexUV( ( float )( x + 1.0f ), ( float )( y +
+							 h ), ( float )( z1_ ), ( float )( u0 ), ( float )( v0 ) );
+
+				tex = secondTex;
+				u0 = tex->getU0(true);
+				v0 = tex->getV0(true);
+				u1 = tex->getU1(true);
+				v1 = tex->getV1(true);
+
+				t->vertexUV( ( float )( x + 1.0f ), ( float )( y +
+							 h ), ( float )( z0_ ), ( float )( u1 ), ( float )( v0 ) );
+				t->vertexUV( ( float )( x + 1.0f ), ( float )( y +
+							 0.0f ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+				t->vertexUV( ( float )( x + 0.0f ), ( float )( y +
+							 0.0f ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+				t->vertexUV( ( float )( x + 0.0f ), ( float )( y +
+							 h ), ( float )( z0_ ), ( float )( u0 ), ( float )( v0 ) );
+			}
+		}
+	}
+
+	return true;
+
+}
+
+bool TileRenderer::tesselateDustInWorld( Tile* tt, int x, int y, int z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	int			data = level->getData( x, y, z );
+	Icon *crossTexture = RedStoneDustTile::getTexture(RedStoneDustTile::TEXTURE_CROSS);
+	Icon *lineTexture = RedStoneDustTile::getTexture(RedStoneDustTile::TEXTURE_LINE);
+	Icon *crossTextureOverlay = RedStoneDustTile::getTexture(RedStoneDustTile::TEXTURE_CROSS_OVERLAY);
+	Icon *lineTextureOverlay = RedStoneDustTile::getTexture(RedStoneDustTile::TEXTURE_LINE_OVERLAY);
+
+	float		br;
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		br = 1;
+	}
+	else
+	{
+		br = tt->getBrightness( level, x, y, z );
+	}
+	// 4J Stu - not used any more
+	//float		pow = ( data / 15.0f );
+	//float		red = pow * 0.6f + 0.4f;
+	//if ( data == 0 ) red = 0.3f;
+
+	//float		green = pow * pow * 0.7f - 0.5f;
+	//float		blue = pow * pow * 0.6f - 0.7f;
+	//if ( green < 0 ) green = 0;
+	//if ( blue < 0 ) blue = 0;
+
+	unsigned int colour = 0;
+	if(data == 0)
+	{
+		colour = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Tile_RedstoneDustUnlit );
+	}
+	else
+	{
+		unsigned int minColour = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Tile_RedstoneDustLitMin );
+		unsigned int maxColour = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Tile_RedstoneDustLitMax );
+
+		byte redComponent = ((minColour>>16)&0xFF) + (( (maxColour>>16)&0xFF - (minColour>>16)&0xFF)*( (data-1)/14.0f));
+		byte greenComponent = ((minColour>>8)&0xFF) + (( (maxColour>>8)&0xFF - (minColour>>8)&0xFF)*( (data-1)/14.0f));
+		byte blueComponent = ((minColour)&0xFF) + (( (maxColour)&0xFF - (minColour)&0xFF)*( (data-1)/14.0f));
+
+		colour = redComponent<<16 | greenComponent<<8 | blueComponent;
+	}
+
+	float red = ((colour>>16)&0xFF)/255.0f;
+	float green = ((colour>>8)&0xFF)/255.0f;
+	float blue = (colour&0xFF)/255.0f;
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->color( red, green, blue );
+	}
+	else
+	{
+		t->color( br * red, br * green, br * blue );
+	}
+	const float dustOffset = 0.25f / 16.0f;
+	const float overlayOffset = 0.25f / 16.0f;
+
+	bool		w = RedStoneDustTile::shouldConnectTo( level, x - 1, y, z, Direction::WEST )
+		|| ( !level->isSolidBlockingTile( x - 1, y, z ) && RedStoneDustTile::shouldConnectTo( level, x - 1, y - 1, z,
+																							  Direction::UNDEFINED ) );
+	bool		e = RedStoneDustTile::shouldConnectTo( level, x + 1, y, z, Direction::EAST )
+		|| ( !level->isSolidBlockingTile( x + 1, y, z ) && RedStoneDustTile::shouldConnectTo( level, x + 1, y - 1, z,
+																							  Direction::UNDEFINED ) );
+	bool		n = RedStoneDustTile::shouldConnectTo( level, x, y, z - 1, Direction::NORTH )
+		|| ( !level->isSolidBlockingTile( x, y, z - 1 ) && RedStoneDustTile::shouldConnectTo( level, x, y - 1, z - 1,
+																							  Direction::UNDEFINED ) );
+	bool		s = RedStoneDustTile::shouldConnectTo( level, x, y, z + 1, Direction::SOUTH )
+		|| ( !level->isSolidBlockingTile( x, y, z + 1 ) && RedStoneDustTile::shouldConnectTo( level, x, y - 1, z + 1,
+																							  Direction::UNDEFINED ) );
+	if ( !level->isSolidBlockingTile( x, y + 1, z ) )
+	{
+		if ( level->isSolidBlockingTile( x - 1, y, z ) && RedStoneDustTile::shouldConnectTo( level, x - 1, y + 1, z,
+																							 Direction::UNDEFINED ) ) w
+				= true;
+		if ( level->isSolidBlockingTile( x + 1, y, z ) && RedStoneDustTile::shouldConnectTo( level, x + 1, y + 1, z,
+																							 Direction::UNDEFINED ) ) e
+				= true;
+		if ( level->isSolidBlockingTile( x, y, z - 1 ) && RedStoneDustTile::shouldConnectTo( level, x, y + 1, z - 1,
+																							 Direction::UNDEFINED ) ) n
+				= true;
+		if ( level->isSolidBlockingTile( x, y, z + 1 ) && RedStoneDustTile::shouldConnectTo( level, x, y + 1, z + 1,
+																							 Direction::UNDEFINED ) ) s
+				= true;
+	}
+	float		x0 = ( float )( x + 0.0f );
+	float		x1 = ( float )( x + 1.0f );
+	float		z0 = ( float )( z + 0.0f );
+	float		z1 = ( float )( z + 1.0f );
+
+	int			pic = 0;
+	if ( ( w || e ) && ( !n && !s ) ) pic = 1;
+	if ( ( n || s ) && ( !e && !w ) ) pic = 2;
+
+	if ( pic == 0 )
+	{
+//		if ( e || n || s || w )
+		int u0 = 0;
+		int v0 = 0;
+		int u1 = SharedConstants::WORLD_RESOLUTION;
+		int v1 = SharedConstants::WORLD_RESOLUTION;
+
+		int cutDistance = 5;
+		if (!w) x0 += cutDistance / (float) SharedConstants::WORLD_RESOLUTION;
+		if (!w) u0 += cutDistance;
+		if (!e) x1 -= cutDistance / (float) SharedConstants::WORLD_RESOLUTION;
+		if (!e) u1 -= cutDistance;
+		if (!n) z0 += cutDistance / (float) SharedConstants::WORLD_RESOLUTION;
+		if (!n) v0 += cutDistance;
+		if (!s) z1 -= cutDistance / (float) SharedConstants::WORLD_RESOLUTION;
+		if (!s) v1 -= cutDistance;
+		t->vertexUV( ( float )( x1 ), ( float )( y + dustOffset ), ( float )( z1 ), crossTexture->getU(u1, true), crossTexture->getV(v1) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + dustOffset ), ( float )( z0 ), crossTexture->getU(u1, true), crossTexture->getV(v0) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + dustOffset ), ( float )( z0 ), crossTexture->getU(u0, true), crossTexture->getV(v0) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + dustOffset ), ( float )( z1 ), crossTexture->getU(u0, true), crossTexture->getV(v1) );
+
+		t->color( br, br, br );
+		t->vertexUV( ( float )( x1 ), ( float )( y + dustOffset ), ( float )( z1 ), crossTextureOverlay->getU(u1, true), crossTextureOverlay->getV(v1, true) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + dustOffset ), ( float )( z0 ), crossTextureOverlay->getU(u1, true), crossTextureOverlay->getV(v0, true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + dustOffset ), ( float )( z0 ), crossTextureOverlay->getU(u0, true), crossTextureOverlay->getV(v0, true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + dustOffset ), ( float )( z1 ), crossTextureOverlay->getU(u0, true), crossTextureOverlay->getV(v1, true) );
+	}
+	else if ( pic == 1 )
+	{
+		t->vertexUV( ( float )( x1 ), ( float )( y + dustOffset ), ( float )( z1 ), lineTexture->getU1(true), lineTexture->getV1(true) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + dustOffset ), ( float )( z0 ), lineTexture->getU1(true), lineTexture->getV0(true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + dustOffset ), ( float )( z0 ), lineTexture->getU0(true), lineTexture->getV0(true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + dustOffset ), ( float )( z1 ), lineTexture->getU0(true), lineTexture->getV1(true) );
+
+		t->color( br, br, br );
+		t->vertexUV( ( float )( x1 ), ( float )( y + overlayOffset ), ( float )( z1 ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV1(true) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + overlayOffset ), ( float )( z0 ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV0(true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + overlayOffset ), ( float )( z0 ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV0(true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + overlayOffset ), ( float )( z1 ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV1(true) );
+	}
+	else
+	{
+		t->vertexUV( ( float )( x1 ), ( float )( y + dustOffset ), ( float )( z1 ), lineTexture->getU1(true), lineTexture->getV1(true) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + dustOffset ), ( float )( z0 ), lineTexture->getU0(true), lineTexture->getV1(true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + dustOffset ), ( float )( z0 ), lineTexture->getU0(true), lineTexture->getV0(true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + dustOffset ), ( float )( z1 ), lineTexture->getU1(true), lineTexture->getV0(true) );
+
+		t->color( br, br, br );
+		t->vertexUV( ( float )( x1 ), ( float )( y + overlayOffset ), ( float )( z1 ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV1(true) );
+		t->vertexUV( ( float )( x1 ), ( float )( y + overlayOffset ), ( float )( z0 ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV1(true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + overlayOffset ), ( float )( z0 ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV0(true) );
+		t->vertexUV( ( float )( x0 ), ( float )( y + overlayOffset ), ( float )( z1 ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV0(true) );
+	}
+
+	if ( !level->isSolidBlockingTile( x, y + 1, z ) )
+	{
+		const float yStretch = .35f / 16.0f;
+
+		if ( level->isSolidBlockingTile( x - 1, y, z ) && level->getTile( x - 1, y + 1, z ) == Tile::redStoneDust_Id )
+		{
+			t->color( br * red, br * green, br * blue );
+			t->vertexUV( ( float )( x + dustOffset ), ( float )( y + 1 + yStretch ), ( float )( z + 1 ), lineTexture->getU1(true), lineTexture->getV0(true) );
+			t->vertexUV( ( float )( x + dustOffset ), ( float )( y + 0 ), ( float )( z + 1 ), lineTexture->getU0(true), lineTexture->getV0(true) );
+			t->vertexUV( ( float )( x + dustOffset ), ( float )( y + 0 ), ( float )( z + 0 ), lineTexture->getU0(true), lineTexture->getV1(true) );
+			t->vertexUV( ( float )( x + dustOffset ), ( float )( y + 1 + yStretch ), ( float )( z +	 0 ), lineTexture->getU1(true), lineTexture->getV1(true) );
+
+			t->color( br, br, br );
+			t->vertexUV( ( float )( x + overlayOffset ), ( float )( y + 1 + yStretch ), ( float )( z + 1 ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV0(true) );
+			t->vertexUV( ( float )( x + overlayOffset ), ( float )( y + 0 ), ( float )( z + 1 ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV0(true) );
+			t->vertexUV( ( float )( x + overlayOffset ), ( float )( y + 0 ), ( float )( z +	 0 ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV1(true) );
+			t->vertexUV( ( float )( x + overlayOffset ), ( float )( y + 1 + yStretch ), ( float )( z + 0 ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV1(true) );
+		}
+		if ( level->isSolidBlockingTile( x + 1, y, z ) && level->getTile( x + 1, y + 1, z ) == Tile::redStoneDust_Id )
+		{
+			t->color( br * red, br * green, br * blue );
+			t->vertexUV( ( float )( x + 1 - dustOffset ), ( float )( y + 0 ), ( float )( z + 1 ), lineTexture->getU0(true), lineTexture->getV1(true) );
+			t->vertexUV( ( float )( x + 1 - dustOffset ), ( float )( y + 1 + yStretch ), ( float )( z + 1 ), lineTexture->getU1(true), lineTexture->getV1(true) );
+			t->vertexUV( ( float )( x + 1 - dustOffset ), ( float )( y + 1 + yStretch ), ( float )( z + 0 ), lineTexture->getU1(true), lineTexture->getV0(true) );
+			t->vertexUV( ( float )( x + 1 - dustOffset ), ( float )( y + 0 ), ( float )( z + 0 ), lineTexture->getU0(true), lineTexture->getV0(true) );
+
+			t->color( br, br, br );
+			t->vertexUV( ( float )( x + 1 - overlayOffset ), ( float )( y + 0 ), ( float )( z + 1 ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV1(true) );
+			t->vertexUV( ( float )( x + 1 - overlayOffset ), ( float )( y + 1 + yStretch ), ( float )( z + 1 ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV1(true) );
+			t->vertexUV( ( float )( x + 1 - overlayOffset ), ( float )( y + 1 + yStretch ), ( float )( z + 0 ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV0(true) );
+			t->vertexUV( ( float )( x + 1 - overlayOffset ), ( float )( y + 0 ), ( float )( z + 0 ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV0(true) );
+		}
+		if ( level->isSolidBlockingTile( x, y, z - 1 ) && level->getTile( x, y + 1, z - 1 ) == Tile::redStoneDust_Id )
+		{
+			t->color( br * red, br * green, br * blue );
+			t->vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z + dustOffset ), lineTexture->getU0(true), lineTexture->getV1(true) );
+			t->vertexUV( ( float )( x + 1 ), ( float )( y + 1 + yStretch ), ( float )( z + dustOffset ), lineTexture->getU1(true), lineTexture->getV1(true) );
+			t->vertexUV( ( float )( x + 0 ), ( float )( y + 1 + yStretch ), ( float )( z + dustOffset ), lineTexture->getU1(true), lineTexture->getV0(true) );
+			t->vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z + dustOffset ), lineTexture->getU0(true), lineTexture->getV0(true) );
+
+			t->color( br, br, br );
+			t->vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z + overlayOffset ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV1(true) );
+			t->vertexUV( ( float )( x + 1 ), ( float )( y + 1 + yStretch ), ( float )( z + overlayOffset ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV1(true) );
+			t->vertexUV( ( float )( x + 0 ), ( float )( y + 1 + yStretch ), ( float )( z + overlayOffset ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV0(true) );
+			t->vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z + overlayOffset ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV0(true) );
+		}
+		if ( level->isSolidBlockingTile( x, y, z + 1 ) && level->getTile( x, y + 1, z + 1 ) == Tile::redStoneDust_Id )
+		{
+			t->color( br * red, br * green, br * blue );
+			t->vertexUV( ( float )( x + 1 ), ( float )( y + 1 + yStretch ), ( float )( z + 1 - dustOffset ), lineTexture->getU1(true), lineTexture->getV0(true) );
+			t->vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z + 1 -	dustOffset ), lineTexture->getU0(true), lineTexture->getV0(true) );
+			t->vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z + 1 -	dustOffset ), lineTexture->getU0(true), lineTexture->getV1(true) );
+			t->vertexUV( ( float )( x + 0 ), ( float )( y + 1 + yStretch ), ( float )( z + 1 - dustOffset ), lineTexture->getU1(true), lineTexture->getV1(true) );
+
+			t->color( br, br, br );
+			t->vertexUV( ( float )( x + 1 ), ( float )( y + 1 + yStretch ), ( float )( z + 1 - overlayOffset ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV0(true) );
+			t->vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z + 1 - overlayOffset ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV0(true) );
+			t->vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z + 1 - overlayOffset ), lineTextureOverlay->getU0(true), lineTextureOverlay->getV1(true) );
+			t->vertexUV( ( float )( x + 0 ), ( float )( y + 1 + yStretch ), ( float )( z + 1 - overlayOffset ), lineTextureOverlay->getU1(true), lineTextureOverlay->getV1(true) );
+		}
+	}
+
+
+	return true;
+
+}
+
+bool TileRenderer::tesselateRailInWorld( RailTile* tt, int x, int y, int z )
+{
+	Tesselator* t = Tesselator::getInstance();
+	int			data = level->getData( x, y, z );
+
+	Icon *tex = getTexture(tt, 0, data);
+	if (hasFixedTexture()) tex = fixedTexture;
+
+	if ( tt->isUsesDataBit() )
+	{
+		data &= RailTile::RAIL_DIRECTION_MASK;
+	}
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		t->color( 1.0f, 1.0f, 1.0f );
+	}
+	else
+	{
+		float br = tt->getBrightness( level, x, y, z );
+		t->color( br, br, br );
+	}
+
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+
+	float		r = 1 / 16.0f;
+
+	float		x0 = ( float )( x + 1 );
+	float		x1 = ( float )( x + 1 );
+	float		x2 = ( float )( x + 0 );
+	float		x3 = ( float )( x + 0 );
+
+	float		z0 = ( float )( z + 0 );
+	float		z1 = ( float )( z + 1 );
+	float		z2 = ( float )( z + 1 );
+	float		z3 = ( float )( z + 0 );
+
+	float		y0 = ( float )( y + r );
+	float		y1 = ( float )( y + r );
+	float		y2 = ( float )( y + r );
+	float		y3 = ( float )( y + r );
+
+	if ( data == 1 || data == 2 || data == 3 || data == 7 )
+	{
+		x0 = x3 = ( float )( x + 1 );
+		x1 = x2 = ( float )( x + 0 );
+		z0 = z1 = ( float )( z + 1 );
+		z2 = z3 = ( float )( z + 0 );
+	}
+	else if ( data == 8 )
+	{
+		x0 = x1 = ( float )( x + 0 );
+		x2 = x3 = ( float )( x + 1 );
+		z0 = z3 = ( float )( z + 1 );
+		z1 = z2 = ( float )( z + 0 );
+	}
+	else if ( data == 9 )
+	{
+		x0 = x3 = ( float )( x + 0 );
+		x1 = x2 = ( float )( x + 1 );
+		z0 = z1 = ( float )( z + 0 );
+		z2 = z3 = ( float )( z + 1 );
+	}
+
+	if ( data == 2 || data == 4 )
+	{
+		y0 += 1;
+		y3 += 1;
+	}
+	else if ( data == 3 || data == 5 )
+	{
+		y1 += 1;
+		y2 += 1;
+	}
+
+	t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x2 ), ( float )( y2 ), ( float )( z2 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x3 ), ( float )( y3 ), ( float )( z3 ), ( float )( u0 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x3 ), ( float )( y3 ), ( float )( z3 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x2 ), ( float )( y2 ), ( float )( z2 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v0 ) );
+
+	return true;
+
+}
+
+bool TileRenderer::tesselateLadderInWorld( Tile* tt, int x, int y, int z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	Icon *tex = getTexture(tt, 0);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		float br = 1;
+		t->color( br, br, br );
+	}
+	else
+	{
+		float br = tt->getBrightness( level, x, y, z );
+		t->color( br, br, br );
+	}
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+
+	int			face = level->getData( x, y, z );
+
+	float		o = 0 / 16.0f;
+	float		r = 0.05f;
+	if ( face == 5 )
+	{
+		t->vertexUV( ( float )( x + r ), ( float )( y + 1 + o ), ( float )( z + 1 +
+					 o ), ( float )( u0 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + r ), ( float )( y + 0 - o ), ( float )( z + 1 +
+					 o ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + r ), ( float )( y + 0 - o ), ( float )( z + 0 -
+					 o ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + r ), ( float )( y + 1 + o ), ( float )( z + 0 -
+					 o ), ( float )( u1 ), ( float )( v0 ) );
+	}
+	if ( face == 4 )
+	{
+		t->vertexUV( ( float )( x + 1 - r ), ( float )( y + 0 - o ), ( float )( z + 1 +
+					 o ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 1 - r ), ( float )( y + 1 + o ), ( float )( z + 1 +
+					 o ), ( float )( u1 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + 1 - r ), ( float )( y + 1 + o ), ( float )( z + 0 -
+					 o ), ( float )( u0 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + 1 - r ), ( float )( y + 0 - o ), ( float )( z + 0 -
+					 o ), ( float )( u0 ), ( float )( v1 ) );
+	}
+	if ( face == 3 )
+	{
+		t->vertexUV( ( float )( x + 1 + o ), ( float )( y + 0 - o ), ( float )( z +
+					 r ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 1 + o ), ( float )( y + 1 + o ), ( float )( z +
+					 r ), ( float )( u1 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + 0 - o ), ( float )( y + 1 + o ), ( float )( z +
+					 r ), ( float )( u0 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + 0 - o ), ( float )( y + 0 - o ), ( float )( z +
+					 r ), ( float )( u0 ), ( float )( v1 ) );
+	}
+	if ( face == 2 )
+	{
+		t->vertexUV( ( float )( x + 1 + o ), ( float )( y + 1 + o ), ( float )( z + 1 -
+					 r ), ( float )( u0 ), ( float )( v0 ) );
+		t->vertexUV( ( float )( x + 1 + o ), ( float )( y + 0 - o ), ( float )( z + 1 -
+					 r ), ( float )( u0 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 0 - o ), ( float )( y + 0 - o ), ( float )( z + 1 -
+					 r ), ( float )( u1 ), ( float )( v1 ) );
+		t->vertexUV( ( float )( x + 0 - o ), ( float )( y + 1 + o ), ( float )( z + 1 -
+					 r ), ( float )( u1 ), ( float )( v0 ) );
+	}
+
+	return true;
+
+}
+
+bool TileRenderer::tesselateVineInWorld( Tile* tt, int x, int y, int z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	Icon *tex = getTexture(tt, 0);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+
+
+	float		br = 1;
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+	}
+	else
+	{
+		br = tt->getBrightness( level, x, y, z );
+	}
+	{
+		int		col = tt->getColor( level, x, y, z );
+		float	r = ( ( col >> 16 ) & 0xff ) / 255.0f;
+		float	g = ( ( col >> 8 ) & 0xff ) / 255.0f;
+		float	b = ( ( col )& 0xff ) / 255.0f;
+
+		t->color( br * r, br * g, br * b );
+	}
+
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+
+	float		r = 0.05f;
+	int			facings = level->getData( x, y, z );
+
+	if ( ( facings & VineTile::VINE_WEST ) != 0 )
+	{
+		t->vertexUV( x + r, y + 1, z + 1, u0, v0 );
+		t->vertexUV( x + r, y + 0, z + 1, u0, v1 );
+		t->vertexUV( x + r, y + 0, z + 0, u1, v1 );
+		t->vertexUV( x + r, y + 1, z + 0, u1, v0 );
+
+		t->vertexUV( x + r, y + 1, z + 0, u1, v0 );
+		t->vertexUV( x + r, y + 0, z + 0, u1, v1 );
+		t->vertexUV( x + r, y + 0, z + 1, u0, v1 );
+		t->vertexUV( x + r, y + 1, z + 1, u0, v0 );
+	}
+	if ( ( facings & VineTile::VINE_EAST ) != 0 )
+	{
+		t->vertexUV( x + 1 - r, y + 0, z + 1, u1, v1 );
+		t->vertexUV( x + 1 - r, y + 1, z + 1, u1, v0 );
+		t->vertexUV( x + 1 - r, y + 1, z + 0, u0, v0 );
+		t->vertexUV( x + 1 - r, y + 0, z + 0, u0, v1 );
+
+		t->vertexUV( x + 1 - r, y + 0, z + 0, u0, v1 );
+		t->vertexUV( x + 1 - r, y + 1, z + 0, u0, v0 );
+		t->vertexUV( x + 1 - r, y + 1, z + 1, u1, v0 );
+		t->vertexUV( x + 1 - r, y + 0, z + 1, u1, v1 );
+	}
+	if ( ( facings & VineTile::VINE_NORTH ) != 0 )
+	{
+		t->vertexUV( x + 1, y + 0, z + r, u1, v1 );
+		t->vertexUV( x + 1, y + 1, z + r, u1, v0 );
+		t->vertexUV( x + 0, y + 1, z + r, u0, v0 );
+		t->vertexUV( x + 0, y + 0, z + r, u0, v1 );
+
+		t->vertexUV( x + 0, y + 0, z + r, u0, v1 );
+		t->vertexUV( x + 0, y + 1, z + r, u0, v0 );
+		t->vertexUV( x + 1, y + 1, z + r, u1, v0 );
+		t->vertexUV( x + 1, y + 0, z + r, u1, v1 );
+	}
+	if ( ( facings & VineTile::VINE_SOUTH ) != 0 )
+	{
+		t->vertexUV( x + 1, y + 1, z + 1 - r, u0, v0 );
+		t->vertexUV( x + 1, y + 0, z + 1 - r, u0, v1 );
+		t->vertexUV( x + 0, y + 0, z + 1 - r, u1, v1 );
+		t->vertexUV( x + 0, y + 1, z + 1 - r, u1, v0 );
+
+		t->vertexUV( x + 0, y + 1, z + 1 - r, u1, v0 );
+		t->vertexUV( x + 0, y + 0, z + 1 - r, u1, v1 );
+		t->vertexUV( x + 1, y + 0, z + 1 - r, u0, v1 );
+		t->vertexUV( x + 1, y + 1, z + 1 - r, u0, v0 );
+	}
+	if ( level->isSolidBlockingTile( x, y + 1, z ) )
+	{
+		t->vertexUV( x + 1, y + 1 - r, z + 0, u0, v0 );
+		t->vertexUV( x + 1, y + 1 - r, z + 1, u0, v1 );
+		t->vertexUV( x + 0, y + 1 - r, z + 1, u1, v1 );
+		t->vertexUV( x + 0, y + 1 - r, z + 0, u1, v0 );
+	}
+
+	return true;
+}
+
+bool TileRenderer::tesselateThinFenceInWorld( ThinFenceTile* tt, int x, int y, int z )
+{
+	int				depth = level->getMaxBuildHeight();
+	Tesselator*		t = Tesselator::getInstance();
+
+	float			br;
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		br = 1;
+	}
+	else
+	{
+		br = tt->getBrightness( level, x, y, z );
+	}
+	int				col = tt->getColor( level, x, y, z );
+	float			r = ( ( col >> 16 ) & 0xff ) / 255.0f;
+	float			g = ( ( col >> 8 ) & 0xff ) / 255.0f;
+	float			b = ( ( col )& 0xff ) / 255.0f;
+
+	if ( GameRenderer::anaglyph3d )
+	{
+		float	cr = ( r * 30 + g * 59 + b * 11 ) / 100;
+		float	cg = ( r * 30 + g * 70 ) / ( 100 );
+		float	cb = ( r * 30 + b * 70 ) / ( 100 );
+
+		r = cr;
+		g = cg;
+		b = cb;
+	}
+	t->color( br * r, br * g, br * b );
+
+	Icon *tex;
+	Icon *edgeTex;
+
+	if ( hasFixedTexture() )
+	{
+		tex = fixedTexture;
+		edgeTex = fixedTexture;
+	}
+	else
+	{
+		int data = level->getData( x, y, z );
+		tex = getTexture( tt, 0, data );
+		edgeTex = tt->getEdgeTexture();
+	}
+
+	int xt = tex->getX();
+	int yt = tex->getY();
+	float u0 = tex->getU0(true);
+	float u1 = tex->getU(8, true);
+	float u2 = tex->getU1(true);
+	float v0 = tex->getV0(true);
+	float v2 = tex->getV1(true);
+
+	int xet = edgeTex->getX();
+	int yet = edgeTex->getY();
+
+	float iu0 = edgeTex->getU(7, true);
+	float iu1 = edgeTex->getU(9, true);
+	float iv0 = edgeTex->getV0(true);
+	float iv1 = edgeTex->getV(8, true);
+	float iv2 = edgeTex->getV1(true);
+
+	float			x0 = (float)x;
+	float			x1 = x + 0.5f;
+	float			x2 = x + 1.0f;
+	float			z0 = (float)z;
+	float			z1 = z + 0.5f;
+	float			z2 = z + 1.0f;
+	float			ix0 = x + 0.5f - 1.0f / 16.0f;
+	float			ix1 = x + 0.5f + 1.0f / 16.0f;
+	float			iz0 = z + 0.5f - 1.0f / 16.0f;
+	float			iz1 = z + 0.5f + 1.0f / 16.0f;
+
+	bool			n = tt->attachsTo( level->getTile( x, y, z - 1 ) );
+	bool			s = tt->attachsTo( level->getTile( x, y, z + 1 ) );
+	bool			w = tt->attachsTo( level->getTile( x - 1, y, z ) );
+	bool			e = tt->attachsTo( level->getTile( x + 1, y, z ) );
+
+	bool			up = tt->shouldRenderFace( level, x, y + 1, z, Facing::UP );
+	bool			down = tt->shouldRenderFace( level, x, y - 1, z, Facing::DOWN );
+
+	const float	noZFightingOffset = 0.01f;
+	const float noZFightingOffsetB = 0.005;
+
+	if ( ( w && e ) || ( !w && !e && !n && !s ) )
+	{
+		t->vertexUV( x0, y + 1, z1, u0, v0 );
+		t->vertexUV( x0, y + 0, z1, u0, v2 );
+		t->vertexUV( x2, y + 0, z1, u2, v2 );
+		t->vertexUV( x2, y + 1, z1, u2, v0 );
+
+		t->vertexUV( x2, y + 1, z1, u0, v0 );
+		t->vertexUV( x2, y + 0, z1, u0, v2 );
+		t->vertexUV( x0, y + 0, z1, u2, v2 );
+		t->vertexUV( x0, y + 1, z1, u2, v0 );
+
+		if ( up )
+		{
+			// small edge texture
+			t->vertexUV( x0, y + 1 + noZFightingOffset, iz1, iu1, iv2 );
+			t->vertexUV( x2, y + 1 + noZFightingOffset, iz1, iu1, iv0 );
+			t->vertexUV( x2, y + 1 + noZFightingOffset, iz0, iu0, iv0 );
+			t->vertexUV( x0, y + 1 + noZFightingOffset, iz0, iu0, iv2 );
+
+			t->vertexUV( x2, y + 1 + noZFightingOffset, iz1, iu1, iv2 );
+			t->vertexUV( x0, y + 1 + noZFightingOffset, iz1, iu1, iv0 );
+			t->vertexUV( x0, y + 1 + noZFightingOffset, iz0, iu0, iv0 );
+			t->vertexUV( x2, y + 1 + noZFightingOffset, iz0, iu0, iv2 );
+		}
+		else
+		{
+			if ( y < ( depth - 1 ) && level->isEmptyTile( x - 1, y + 1, z ) )
+			{
+				t->vertexUV( x0, y + 1 + noZFightingOffset, iz1, iu1, iv1 );
+				t->vertexUV( x1, y + 1 + noZFightingOffset, iz1, iu1, iv2 );
+				t->vertexUV( x1, y + 1 + noZFightingOffset, iz0, iu0, iv2 );
+				t->vertexUV( x0, y + 1 + noZFightingOffset, iz0, iu0, iv1 );
+
+				t->vertexUV( x1, y + 1 + noZFightingOffset, iz1, iu1, iv1 );
+				t->vertexUV( x0, y + 1 + noZFightingOffset, iz1, iu1, iv2 );
+				t->vertexUV( x0, y + 1 + noZFightingOffset, iz0, iu0, iv2 );
+				t->vertexUV( x1, y + 1 + noZFightingOffset, iz0, iu0, iv1 );
+			}
+			if ( y < ( depth - 1 ) && level->isEmptyTile( x + 1, y + 1, z ) )
+			{
+				t->vertexUV( x1, y + 1 + noZFightingOffset, iz1, iu1, iv0 );
+				t->vertexUV( x2, y + 1 + noZFightingOffset, iz1, iu1, iv1 );
+				t->vertexUV( x2, y + 1 + noZFightingOffset, iz0, iu0, iv1 );
+				t->vertexUV( x1, y + 1 + noZFightingOffset, iz0, iu0, iv0 );
+
+				t->vertexUV( x2, y + 1 + noZFightingOffset, iz1, iu1, iv0 );
+				t->vertexUV( x1, y + 1 + noZFightingOffset, iz1, iu1, iv1 );
+				t->vertexUV( x1, y + 1 + noZFightingOffset, iz0, iu0, iv1 );
+				t->vertexUV( x2, y + 1 + noZFightingOffset, iz0, iu0, iv0 );
+			}
+		}
+		if ( down )
+		{
+			// small edge texture
+			t->vertexUV( x0, y - noZFightingOffset, iz1, iu1, iv2 );
+			t->vertexUV( x2, y - noZFightingOffset, iz1, iu1, iv0 );
+			t->vertexUV( x2, y - noZFightingOffset, iz0, iu0, iv0 );
+			t->vertexUV( x0, y - noZFightingOffset, iz0, iu0, iv2 );
+
+			t->vertexUV( x2, y - noZFightingOffset, iz1, iu1, iv2 );
+			t->vertexUV( x0, y - noZFightingOffset, iz1, iu1, iv0 );
+			t->vertexUV( x0, y - noZFightingOffset, iz0, iu0, iv0 );
+			t->vertexUV( x2, y - noZFightingOffset, iz0, iu0, iv2 );
+		}
+		else
+		{
+			if ( y > 1 && level->isEmptyTile( x - 1, y - 1, z ) )
+			{
+				t->vertexUV( x0, y - noZFightingOffset, iz1, iu1, iv1 );
+				t->vertexUV( x1, y - noZFightingOffset, iz1, iu1, iv2 );
+				t->vertexUV( x1, y - noZFightingOffset, iz0, iu0, iv2 );
+				t->vertexUV( x0, y - noZFightingOffset, iz0, iu0, iv1 );
+
+				t->vertexUV( x1, y - noZFightingOffset, iz1, iu1, iv1 );
+				t->vertexUV( x0, y - noZFightingOffset, iz1, iu1, iv2 );
+				t->vertexUV( x0, y - noZFightingOffset, iz0, iu0, iv2 );
+				t->vertexUV( x1, y - noZFightingOffset, iz0, iu0, iv1 );
+			}
+			if ( y > 1 && level->isEmptyTile( x + 1, y - 1, z ) )
+			{
+				t->vertexUV( x1, y - noZFightingOffset, iz1, iu1, iv0 );
+				t->vertexUV( x2, y - noZFightingOffset, iz1, iu1, iv1 );
+				t->vertexUV( x2, y - noZFightingOffset, iz0, iu0, iv1 );
+				t->vertexUV( x1, y - noZFightingOffset, iz0, iu0, iv0 );
+
+				t->vertexUV( x2, y - noZFightingOffset, iz1, iu1, iv0 );
+				t->vertexUV( x1, y - noZFightingOffset, iz1, iu1, iv1 );
+				t->vertexUV( x1, y - noZFightingOffset, iz0, iu0, iv1 );
+				t->vertexUV( x2, y - noZFightingOffset, iz0, iu0, iv0 );
+			}
+		}
+	}
+	else if ( w && !e )
+	{
+		// half-step towards west
+		t->vertexUV( x0, y + 1, z1, u0, v0 );
+		t->vertexUV( x0, y + 0, z1, u0, v2 );
+		t->vertexUV( x1, y + 0, z1, u1, v2 );
+		t->vertexUV( x1, y + 1, z1, u1, v0 );
+
+		t->vertexUV( x1, y + 1, z1, u0, v0 );
+		t->vertexUV( x1, y + 0, z1, u0, v2 );
+		t->vertexUV( x0, y + 0, z1, u1, v2 );
+		t->vertexUV( x0, y + 1, z1, u1, v0 );
+
+		// small edge texture
+		if ( !s && !n )
+		{
+			t->vertexUV( x1, y + 1, iz1, iu0, iv0 );
+			t->vertexUV( x1, y + 0, iz1, iu0, iv2 );
+			t->vertexUV( x1, y + 0, iz0, iu1, iv2 );
+			t->vertexUV( x1, y + 1, iz0, iu1, iv0 );
+
+			t->vertexUV( x1, y + 1, iz0, iu0, iv0 );
+			t->vertexUV( x1, y + 0, iz0, iu0, iv2 );
+			t->vertexUV( x1, y + 0, iz1, iu1, iv2 );
+			t->vertexUV( x1, y + 1, iz1, iu1, iv0 );
+		}
+
+		if ( up || ( y < ( depth - 1 ) && level->isEmptyTile( x - 1, y + 1, z ) ) )
+		{
+			// small edge texture
+			t->vertexUV( x0, y + 1 + noZFightingOffset, iz1, iu1, iv1 );
+			t->vertexUV( x1, y + 1 + noZFightingOffset, iz1, iu1, iv2 );
+			t->vertexUV( x1, y + 1 + noZFightingOffset, iz0, iu0, iv2 );
+			t->vertexUV( x0, y + 1 + noZFightingOffset, iz0, iu0, iv1 );
+
+			t->vertexUV( x1, y + 1 + noZFightingOffset, iz1, iu1, iv1 );
+			t->vertexUV( x0, y + 1 + noZFightingOffset, iz1, iu1, iv2 );
+			t->vertexUV( x0, y + 1 + noZFightingOffset, iz0, iu0, iv2 );
+			t->vertexUV( x1, y + 1 + noZFightingOffset, iz0, iu0, iv1 );
+		}
+		if ( down || ( y > 1 && level->isEmptyTile( x - 1, y - 1, z ) ) )
+		{
+			// small edge texture
+			t->vertexUV( x0, y - noZFightingOffset, iz1, iu1, iv1 );
+			t->vertexUV( x1, y - noZFightingOffset, iz1, iu1, iv2 );
+			t->vertexUV( x1, y - noZFightingOffset, iz0, iu0, iv2 );
+			t->vertexUV( x0, y - noZFightingOffset, iz0, iu0, iv1 );
+
+			t->vertexUV( x1, y - noZFightingOffset, iz1, iu1, iv1 );
+			t->vertexUV( x0, y - noZFightingOffset, iz1, iu1, iv2 );
+			t->vertexUV( x0, y - noZFightingOffset, iz0, iu0, iv2 );
+			t->vertexUV( x1, y - noZFightingOffset, iz0, iu0, iv1 );
+		}
+
+	}
+	else if ( !w && e )
+	{
+		// half-step towards east
+		t->vertexUV( x1, y + 1, z1, u1, v0 );
+		t->vertexUV( x1, y + 0, z1, u1, v2 );
+		t->vertexUV( x2, y + 0, z1, u2, v2 );
+		t->vertexUV( x2, y + 1, z1, u2, v0 );
+
+		t->vertexUV( x2, y + 1, z1, u1, v0 );
+		t->vertexUV( x2, y + 0, z1, u1, v2 );
+		t->vertexUV( x1, y + 0, z1, u2, v2 );
+		t->vertexUV( x1, y + 1, z1, u2, v0 );
+
+		// small edge texture
+		if ( !s && !n )
+		{
+			t->vertexUV( x1, y + 1, iz0, iu0, iv0 );
+			t->vertexUV( x1, y + 0, iz0, iu0, iv2 );
+			t->vertexUV( x1, y + 0, iz1, iu1, iv2 );
+			t->vertexUV( x1, y + 1, iz1, iu1, iv0 );
+
+			t->vertexUV( x1, y + 1, iz1, iu0, iv0 );
+			t->vertexUV( x1, y + 0, iz1, iu0, iv2 );
+			t->vertexUV( x1, y + 0, iz0, iu1, iv2 );
+			t->vertexUV( x1, y + 1, iz0, iu1, iv0 );
+		}
+
+		if ( up || ( y < ( depth - 1 ) && level->isEmptyTile( x + 1, y + 1, z ) ) )
+		{
+			// small edge texture
+			t->vertexUV( x1, y + 1 + noZFightingOffset, iz1, iu1, iv0 );
+			t->vertexUV( x2, y + 1 + noZFightingOffset, iz1, iu1, iv1 );
+			t->vertexUV( x2, y + 1 + noZFightingOffset, iz0, iu0, iv1 );
+			t->vertexUV( x1, y + 1 + noZFightingOffset, iz0, iu0, iv0 );
+
+			t->vertexUV( x2, y + 1 + noZFightingOffset, iz1, iu1, iv0 );
+			t->vertexUV( x1, y + 1 + noZFightingOffset, iz1, iu1, iv1 );
+			t->vertexUV( x1, y + 1 + noZFightingOffset, iz0, iu0, iv1 );
+			t->vertexUV( x2, y + 1 + noZFightingOffset, iz0, iu0, iv0 );
+		}
+		if ( down || ( y > 1 && level->isEmptyTile( x + 1, y - 1, z ) ) )
+		{
+			// small edge texture
+			t->vertexUV( x1, y - noZFightingOffset, iz1, iu1, iv0 );
+			t->vertexUV( x2, y - noZFightingOffset, iz1, iu1, iv1 );
+			t->vertexUV( x2, y - noZFightingOffset, iz0, iu0, iv1 );
+			t->vertexUV( x1, y - noZFightingOffset, iz0, iu0, iv0 );
+
+			t->vertexUV( x2, y - noZFightingOffset, iz1, iu1, iv0 );
+			t->vertexUV( x1, y - noZFightingOffset, iz1, iu1, iv1 );
+			t->vertexUV( x1, y - noZFightingOffset, iz0, iu0, iv1 );
+			t->vertexUV( x2, y - noZFightingOffset, iz0, iu0, iv0 );
+		}
+
+	}
+
+	if ( ( n && s ) || ( !w && !e && !n && !s ) )
+	{
+		// straight north-south
+		t->vertexUV( x1, y + 1, z2, u0, v0 );
+		t->vertexUV( x1, y + 0, z2, u0, v2 );
+		t->vertexUV( x1, y + 0, z0, u2, v2 );
+		t->vertexUV( x1, y + 1, z0, u2, v0 );
+
+		t->vertexUV( x1, y + 1, z0, u0, v0 );
+		t->vertexUV( x1, y + 0, z0, u0, v2 );
+		t->vertexUV( x1, y + 0, z2, u2, v2 );
+		t->vertexUV( x1, y + 1, z2, u2, v0 );
+
+		if ( up )
+		{
+			// small edge texture
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z2, iu1, iv2 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z0, iu1, iv0 );
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z0, iu0, iv0 );
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z2, iu0, iv2 );
+
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z0, iu1, iv2 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z2, iu1, iv0 );
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z2, iu0, iv0 );
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z0, iu0, iv2 );
+		}
+		else
+		{
+			if ( y < ( depth - 1 ) && level->isEmptyTile( x, y + 1, z - 1 ) )
+			{
+				t->vertexUV( ix0, y + 1 + noZFightingOffset, z0, iu1, iv0 );
+				t->vertexUV( ix0, y + 1 + noZFightingOffset, z1, iu1, iv1 );
+				t->vertexUV( ix1, y + 1 + noZFightingOffset, z1, iu0, iv1 );
+				t->vertexUV( ix1, y + 1 + noZFightingOffset, z0, iu0, iv0 );
+
+				t->vertexUV( ix0, y + 1 + noZFightingOffset, z1, iu1, iv0 );
+				t->vertexUV( ix0, y + 1 + noZFightingOffset, z0, iu1, iv1 );
+				t->vertexUV( ix1, y + 1 + noZFightingOffset, z0, iu0, iv1 );
+				t->vertexUV( ix1, y + 1 + noZFightingOffset, z1, iu0, iv0 );
+			}
+			if ( y < ( depth - 1 ) && level->isEmptyTile( x, y + 1, z + 1 ) )
+			{
+				t->vertexUV( ix0, y + 1 + noZFightingOffset, z1, iu0, iv1 );
+				t->vertexUV( ix0, y + 1 + noZFightingOffset, z2, iu0, iv2 );
+				t->vertexUV( ix1, y + 1 + noZFightingOffset, z2, iu1, iv2 );
+				t->vertexUV( ix1, y + 1 + noZFightingOffset, z1, iu1, iv1 );
+
+				t->vertexUV( ix0, y + 1 + noZFightingOffset, z2, iu0, iv1 );
+				t->vertexUV( ix0, y + 1 + noZFightingOffset, z1, iu0, iv2 );
+				t->vertexUV( ix1, y + 1 + noZFightingOffset, z1, iu1, iv2 );
+				t->vertexUV( ix1, y + 1 + noZFightingOffset, z2, iu1, iv1 );
+			}
+		}
+		if ( down )
+		{
+			// small edge texture
+			t->vertexUV( ix1, y - noZFightingOffset, z2, iu1, iv2 );
+			t->vertexUV( ix1, y - noZFightingOffset, z0, iu1, iv0 );
+			t->vertexUV( ix0, y - noZFightingOffset, z0, iu0, iv0 );
+			t->vertexUV( ix0, y - noZFightingOffset, z2, iu0, iv2 );
+
+			t->vertexUV( ix1, y - noZFightingOffset, z0, iu1, iv2 );
+			t->vertexUV( ix1, y - noZFightingOffset, z2, iu1, iv0 );
+			t->vertexUV( ix0, y - noZFightingOffset, z2, iu0, iv0 );
+			t->vertexUV( ix0, y - noZFightingOffset, z0, iu0, iv2 );
+		}
+		else
+		{
+			if ( y > 1 && level->isEmptyTile( x, y - 1, z - 1 ) )
+			{
+				// north half-step
+				t->vertexUV( ix0, y - noZFightingOffset, z0, iu1, iv0 );
+				t->vertexUV( ix0, y - noZFightingOffset, z1, iu1, iv1 );
+				t->vertexUV( ix1, y - noZFightingOffset, z1, iu0, iv1 );
+				t->vertexUV( ix1, y - noZFightingOffset, z0, iu0, iv0 );
+
+				t->vertexUV( ix0, y - noZFightingOffset, z1, iu1, iv0 );
+				t->vertexUV( ix0, y - noZFightingOffset, z0, iu1, iv1 );
+				t->vertexUV( ix1, y - noZFightingOffset, z0, iu0, iv1 );
+				t->vertexUV( ix1, y - noZFightingOffset, z1, iu0, iv0 );
+			}
+			if ( y > 1 && level->isEmptyTile( x, y - 1, z + 1 ) )
+			{
+				// south half-step
+				t->vertexUV( ix0, y - noZFightingOffset, z1, iu0, iv1 );
+				t->vertexUV( ix0, y - noZFightingOffset, z2, iu0, iv2 );
+				t->vertexUV( ix1, y - noZFightingOffset, z2, iu1, iv2 );
+				t->vertexUV( ix1, y - noZFightingOffset, z1, iu1, iv1 );
+
+				t->vertexUV( ix0, y - noZFightingOffset, z2, iu0, iv1 );
+				t->vertexUV( ix0, y - noZFightingOffset, z1, iu0, iv2 );
+				t->vertexUV( ix1, y - noZFightingOffset, z1, iu1, iv2 );
+				t->vertexUV( ix1, y - noZFightingOffset, z2, iu1, iv1 );
+			}
+		}
+
+	}
+	else if ( n && !s )
+	{
+		// half-step towards north
+		t->vertexUV( x1, y + 1, z0, u0, v0 );
+		t->vertexUV( x1, y + 0, z0, u0, v2 );
+		t->vertexUV( x1, y + 0, z1, u1, v2 );
+		t->vertexUV( x1, y + 1, z1, u1, v0 );
+
+		t->vertexUV( x1, y + 1, z1, u0, v0 );
+		t->vertexUV( x1, y + 0, z1, u0, v2 );
+		t->vertexUV( x1, y + 0, z0, u1, v2 );
+		t->vertexUV( x1, y + 1, z0, u1, v0 );
+
+		// small edge texture
+		if ( !e && !w )
+		{
+			t->vertexUV( ix0, y + 1, z1, iu0, iv0 );
+			t->vertexUV( ix0, y + 0, z1, iu0, iv2 );
+			t->vertexUV( ix1, y + 0, z1, iu1, iv2 );
+			t->vertexUV( ix1, y + 1, z1, iu1, iv0 );
+
+			t->vertexUV( ix1, y + 1, z1, iu0, iv0 );
+			t->vertexUV( ix1, y + 0, z1, iu0, iv2 );
+			t->vertexUV( ix0, y + 0, z1, iu1, iv2 );
+			t->vertexUV( ix0, y + 1, z1, iu1, iv0 );
+		}
+
+		if ( up || ( y < ( depth - 1 ) && level->isEmptyTile( x, y + 1, z - 1 ) ) )
+		{
+			// small edge texture
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z0, iu1, iv0 );
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z1, iu1, iv1 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z1, iu0, iv1 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z0, iu0, iv0 );
+
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z1, iu1, iv0 );
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z0, iu1, iv1 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z0, iu0, iv1 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z1, iu0, iv0 );
+		}
+
+		if ( down || ( y > 1 && level->isEmptyTile( x, y - 1, z - 1 ) ) )
+		{
+			// small edge texture
+			t->vertexUV( ix0, y - noZFightingOffset, z0, iu1, iv0 );
+			t->vertexUV( ix0, y - noZFightingOffset, z1, iu1, iv1 );
+			t->vertexUV( ix1, y - noZFightingOffset, z1, iu0, iv1 );
+			t->vertexUV( ix1, y - noZFightingOffset, z0, iu0, iv0 );
+
+			t->vertexUV( ix0, y - noZFightingOffset, z1, iu1, iv0 );
+			t->vertexUV( ix0, y - noZFightingOffset, z0, iu1, iv1 );
+			t->vertexUV( ix1, y - noZFightingOffset, z0, iu0, iv1 );
+			t->vertexUV( ix1, y - noZFightingOffset, z1, iu0, iv0 );
+		}
+
+	}
+	else if ( !n && s )
+	{
+		// half-step towards south
+		t->vertexUV( x1, y + 1, z1, u1, v0 );
+		t->vertexUV( x1, y + 0, z1, u1, v2 );
+		t->vertexUV( x1, y + 0, z2, u2, v2 );
+		t->vertexUV( x1, y + 1, z2, u2, v0 );
+
+		t->vertexUV( x1, y + 1, z2, u1, v0 );
+		t->vertexUV( x1, y + 0, z2, u1, v2 );
+		t->vertexUV( x1, y + 0, z1, u2, v2 );
+		t->vertexUV( x1, y + 1, z1, u2, v0 );
+
+		// small edge texture
+		if ( !e && !w )
+		{
+			t->vertexUV( ix1, y + 1, z1, iu0, iv0 );
+			t->vertexUV( ix1, y + 0, z1, iu0, iv2 );
+			t->vertexUV( ix0, y + 0, z1, iu1, iv2 );
+			t->vertexUV( ix0, y + 1, z1, iu1, iv0 );
+
+			t->vertexUV( ix0, y + 1, z1, iu0, iv0 );
+			t->vertexUV( ix0, y + 0, z1, iu0, iv2 );
+			t->vertexUV( ix1, y + 0, z1, iu1, iv2 );
+			t->vertexUV( ix1, y + 1, z1, iu1, iv0 );
+		}
+
+		if ( up || ( y < ( depth - 1 ) && level->isEmptyTile( x, y + 1, z + 1 ) ) )
+		{
+			// small edge texture
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z1, iu0, iv1 );
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z2, iu0, iv2 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z2, iu1, iv2 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z1, iu1, iv1 );
+
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z2, iu0, iv1 );
+			t->vertexUV( ix0, y + 1 + noZFightingOffset, z1, iu0, iv2 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z1, iu1, iv2 );
+			t->vertexUV( ix1, y + 1 + noZFightingOffset, z2, iu1, iv1 );
+		}
+		if ( down || ( y > 1 && level->isEmptyTile( x, y - 1, z + 1 ) ) )
+		{
+			// small edge texture
+			t->vertexUV( ix0, y - noZFightingOffset, z1, iu0, iv1 );
+			t->vertexUV( ix0, y - noZFightingOffset, z2, iu0, iv2 );
+			t->vertexUV( ix1, y - noZFightingOffset, z2, iu1, iv2 );
+			t->vertexUV( ix1, y - noZFightingOffset, z1, iu1, iv1 );
+
+			t->vertexUV( ix0, y - noZFightingOffset, z2, iu0, iv1 );
+			t->vertexUV( ix0, y - noZFightingOffset, z1, iu0, iv2 );
+			t->vertexUV( ix1, y - noZFightingOffset, z1, iu1, iv2 );
+			t->vertexUV( ix1, y - noZFightingOffset, z2, iu1, iv1 );
+		}
+
+	}
+
+	return true;
+}
+
+bool TileRenderer::tesselateCrossInWorld( Tile* tt, int x, int y, int z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	float		br;
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		br = 1;
+	}
+	else
+	{
+		br = tt->getBrightness( level, x, y, z );
+	}
+
+	int			col = tt->getColor( level, x, y, z );
+	float		r = ( ( col >> 16 ) & 0xff ) / 255.0f;
+	float		g = ( ( col >> 8 ) & 0xff ) / 255.0f;
+	float		b = ( ( col )& 0xff ) / 255.0f;
+
+	if ( GameRenderer::anaglyph3d )
+	{
+		float	cr = ( r * 30 + g * 59 + b * 11 ) / 100;
+		float	cg = ( r * 30 + g * 70 ) / ( 100 );
+		float	cb = ( r * 30 + b * 70 ) / ( 100 );
+
+		r = cr;
+		g = cg;
+		b = cb;
+	}
+	t->color( br * r, br * g, br * b );
+
+	float		xt = (float)x;
+	float		yt = (float)y;
+	float		zt = (float)z;
+
+	if (tt == Tile::tallgrass)
+	{
+	    __int64 seed = (x * 3129871) ^ (z * 116129781l) ^ (y);
+	    seed = seed * seed * 42317861 + seed * 11;
+	
+		xt += ((((seed >> 16) & 0xf) / 15.0f) - 0.5f) * 0.5f;
+		yt += ((((seed >> 20) & 0xf) / 15.0f) - 1.0f) * 0.2f;
+		zt += ((((seed >> 24) & 0xf) / 15.0f) - 0.5f) * 0.5f;
+	}
+
+	tesselateCrossTexture( tt, level->getData( x, y, z ), xt, yt, zt, 1 );
+	return true;
+}
+
+bool TileRenderer::tesselateStemInWorld( Tile* _tt, int x, int y, int z )
+{
+	StemTile*	tt = ( StemTile* )_tt;
+	Tesselator* t = Tesselator::getInstance();
+
+	float		br;
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		br = 1;
+	}
+	else
+	{
+		br = tt->getBrightness( level, x, y, z );
+	}
+	int			col = tt->getColor( level, x, y, z );
+	float		r = ( ( col >> 16 ) & 0xff ) / 255.0f;
+	float		g = ( ( col >> 8 ) & 0xff ) / 255.0f;
+	float		b = ( ( col )& 0xff ) / 255.0f;
+
+	if ( GameRenderer::anaglyph3d )
+	{
+		float	cr = ( r * 30.0f + g * 59.0f + b * 11.0f ) / 100.0f;
+		float	cg = ( r * 30.0f + g * 70.0f ) / ( 100.0f );
+		float	cb = ( r * 30.0f + b * 70.0f ) / ( 100.0f );
+
+		r = cr;
+		g = cg;
+		b = cb;
+	}
+	t->color( br * r, br * g, br * b );
+
+	tt->updateShape( level, x, y, z );
+	int			dir = tt->getConnectDir( level, x, y, z );
+	if ( dir < 0 )
+	{
+		tesselateStemTexture( tt, level->getData( x, y, z ), tileShapeY1, x, y - 1 / 16.0f, z );
+	}
+	else
+	{
+		tesselateStemTexture( tt, level->getData( x, y, z ), 0.5f, x, y - 1 / 16.0f, z );
+		tesselateStemDirTexture( tt, level->getData( x, y, z ), dir, tileShapeY1, x, y - 1 / 16.0f, z );
+	}
+	return true;
+}
+
+bool TileRenderer::tesselateRowInWorld( Tile* tt, int x, int y, int z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+		t->color( 1.0f, 1.0f, 1.0f );
+	}
+	else
+	{
+		float br = tt->getBrightness( level, x, y, z );
+		t->color( br, br, br );
+	}
+
+	tesselateRowTexture( tt, level->getData( x, y, z ), x, y - 1.0f / 16.0f, z );
+	return true;
+}
+
+void TileRenderer::tesselateTorch( Tile* tt, float x, float y, float z, float xxa, float zza, int data )
+{
+	Tesselator* t = Tesselator::getInstance();
+	Icon *tex = getTexture(tt, Facing::DOWN, data);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+
+	float ut0 = tex->getU(7, true);
+	float vt0 = tex->getV(6, true);
+	float ut1 = tex->getU(9, true);
+	float vt1 = tex->getV(8, true);
+
+	float ub0 = tex->getU(7, true);
+	float vb0 = tex->getV(13, true);
+	float ub1 = tex->getU(9, true);
+	float vb1 = tex->getV(15, true);
+
+	x += 0.5f;
+	z += 0.5f;
+
+	float		x0 = x - 0.5f;
+	float		x1 = x + 0.5f;
+	float		z0 = z - 0.5f;
+	float		z1 = z + 0.5f;
+	float		r = 1 / 16.0f;
+
+	float		h = 10.0f / 16.0f;
+	t->vertexUV( ( float )( x + xxa * ( 1 - h ) - r ), ( float )( y + h ), ( float )( z + zza * ( 1 - h ) - r ), ut0, vt0 );
+	t->vertexUV( ( float )( x + xxa * ( 1 - h ) - r ), ( float )( y + h ), ( float )( z + zza * ( 1 - h ) + r ), ut0, vt1 );
+	t->vertexUV( ( float )( x + xxa * ( 1 - h ) + r ), ( float )( y + h ), ( float )( z + zza * ( 1 - h ) + r ), ut1, vt1 );
+	t->vertexUV( ( float )( x + xxa * ( 1 - h ) + r ), ( float )( y + h ), ( float )( z + zza * ( 1 - h ) - r ), ut1, vt0 );
+
+	t->vertexUV( (float)(x + r + xxa), (float) y, (float)(z - r + zza), ub1, vb0);
+	t->vertexUV( (float)(x + r + xxa), (float) y, (float)(z + r + zza), ub1, vb1);
+	t->vertexUV( (float)(x - r + xxa), (float) y, (float)(z + r + zza), ub0, vb1);
+	t->vertexUV( (float)(x - r + xxa), (float) y, (float)(z - r + zza), ub0, vb0);
+
+	t->vertexUV( ( float )( x - r ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x - r + xxa ), ( float )( y + 0 ), ( float )( z0 +
+				 zza ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x - r + xxa ), ( float )( y + 0 ), ( float )( z1 +
+				 zza ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x - r ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x + r ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x + xxa + r ), ( float )( y + 0 ), ( float )( z1 +
+				 zza ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x + xxa + r ), ( float )( y + 0 ), ( float )( z0 +
+				 zza ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x + r ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z + r ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x0 + xxa ), ( float )( y + 0 ), ( float )( z + r +
+				 zza ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 + xxa ), ( float )( y + 0 ), ( float )( z + r +
+				 zza ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z + r ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z - r ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x1 + xxa ), ( float )( y + 0 ), ( float )( z - r +
+				 zza ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 + xxa ), ( float )( y + 0 ), ( float )( z - r +
+				 zza ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z - r ), ( float )( u1 ), ( float )( v0 ) );
+}
+
+void TileRenderer::tesselateCrossTexture( Tile* tt, int data, float x, float y, float z, float scale )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	Icon *tex = getTexture(tt, 0, data);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+
+	float width = 0.45 * scale;
+	float x0 = x + 0.5 - width;
+	float x1 = x + 0.5 + width;
+	float z0 = z + 0.5 - width;
+	float z1 = z + 0.5 + width;
+
+	t->vertexUV( ( float )( x0 ), ( float )( y + scale ), ( float )( z0 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + scale ), ( float )( z1 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x1 ), ( float )( y + scale ), ( float )( z1 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + scale ), ( float )( z0 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x0 ), ( float )( y + scale ), ( float )( z1 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + scale ), ( float )( z0 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x1 ), ( float )( y + scale ), ( float )( z0 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + scale ), ( float )( z1 ), ( float )( u1 ), ( float )( v0 ) );
+
+}
+
+void TileRenderer::tesselateStemTexture( Tile* tt, int data, float h, float x, float y, float z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	Icon *tex = getTexture(tt, 0, data);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV(h * SharedConstants::WORLD_RESOLUTION, true);
+
+	float		x0 = x + 0.5f - 0.45f;
+	float		x1 = x + 0.5f + 0.45f;
+	float		z0 = z + 0.5f - 0.45f;
+	float		z1 = z + 0.5f + 0.45f;
+
+	t->vertexUV( x0, y + h, z0, u0, v0 );
+	t->vertexUV( x0, y + 0, z0, u0, v1 );
+	t->vertexUV( x1, y + 0, z1, u1, v1 );
+	t->vertexUV( x1, y + h, z1, u1, v0 );
+
+	t->vertexUV( x1, y + h, z1, u0, v0 );
+	t->vertexUV( x1, y + 0, z1, u0, v1 );
+	t->vertexUV( x0, y + 0, z0, u1, v1 );
+	t->vertexUV( x0, y + h, z0, u1, v0 );
+
+	t->vertexUV( x0, y + h, z1, u0, v0 );
+	t->vertexUV( x0, y + 0, z1, u0, v1 );
+	t->vertexUV( x1, y + 0, z0, u1, v1 );
+	t->vertexUV( x1, y + h, z0, u1, v0 );
+
+	t->vertexUV( x1, y + h, z0, u0, v0 );
+	t->vertexUV( x1, y + 0, z0, u0, v1 );
+	t->vertexUV( x0, y + 0, z1, u1, v1 );
+	t->vertexUV( x0, y + h, z1, u1, v0 );
+}
+
+bool TileRenderer::tesselateLilypadInWorld(Tile *tt, int x, int y, int z)
+{
+    Tesselator *t = Tesselator::getInstance();
+
+	Icon *tex = getTexture(tt, Facing::UP);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+    float h = 0.25f / 16.0f;
+
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+
+    __int64 seed = (x * 3129871) ^ (z * 116129781l) ^ (y);
+    seed = seed * seed * 42317861 + seed * 11;
+
+    int dir = (int) ((seed >> 16) & 0x3);
+
+
+
+    t->tex2(getLightColor(tt, level, x, y, z));
+
+    float xx = x + 0.5f;
+    float zz = z + 0.5f;
+    float c = ((dir & 1) * 0.5f) * (1 - dir / 2 % 2 * 2);
+    float s = (((dir + 1) & 1) * 0.5f) * (1 - (dir + 1) / 2 % 2 * 2);
+
+    t->color(tt->getColor());
+    t->vertexUV(xx + c - s, y + h, zz + c + s, u0, v0);
+    t->vertexUV(xx + c + s, y + h, zz - c + s, u1, v0);
+    t->vertexUV(xx - c + s, y + h, zz - c - s, u1, v1);
+    t->vertexUV(xx - c - s, y + h, zz + c - s, u0, v1);
+
+    t->color((tt->getColor() & 0xfefefe) >> 1);
+    t->vertexUV(xx - c - s, y + h, zz + c - s, u0, v1);
+    t->vertexUV(xx - c + s, y + h, zz - c - s, u1, v1);
+    t->vertexUV(xx + c + s, y + h, zz - c + s, u1, v0);
+    t->vertexUV(xx + c - s, y + h, zz + c + s, u0, v0);
+
+
+    return true;
+}
+
+void TileRenderer::tesselateStemDirTexture( StemTile* tt, int data, int dir, float h, float x, float y, float z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	Icon *tex = tt->getAngledTexture();
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+
+	float		x0 = x + 0.5f - 0.5f;
+	float		x1 = x + 0.5f + 0.5f;
+	float		z0 = z + 0.5f - 0.5f;
+	float		z1 = z + 0.5f + 0.5f;
+
+	float		xm = x + 0.5f;
+	float		zm = z + 0.5f;
+
+	if ( ( dir + 1 ) / 2 % 2 == 1 )
+	{
+		float tmp = u1;
+		u1 = u0;
+		u0 = tmp;
+	}
+
+	if ( dir < 2 )
+	{
+		t->vertexUV( x0, y + h, zm, u0, v0 );
+		t->vertexUV( x0, y + 0, zm, u0, v1 );
+		t->vertexUV( x1, y + 0, zm, u1, v1 );
+		t->vertexUV( x1, y + h, zm, u1, v0 );
+
+		t->vertexUV( x1, y + h, zm, u1, v0 );
+		t->vertexUV( x1, y + 0, zm, u1, v1 );
+		t->vertexUV( x0, y + 0, zm, u0, v1 );
+		t->vertexUV( x0, y + h, zm, u0, v0 );
+	}
+	else
+	{
+		t->vertexUV( xm, y + h, z1, u0, v0 );
+		t->vertexUV( xm, y + 0, z1, u0, v1 );
+		t->vertexUV( xm, y + 0, z0, u1, v1 );
+		t->vertexUV( xm, y + h, z0, u1, v0 );
+
+		t->vertexUV( xm, y + h, z0, u1, v0 );
+		t->vertexUV( xm, y + 0, z0, u1, v1 );
+		t->vertexUV( xm, y + 0, z1, u0, v1 );
+		t->vertexUV( xm, y + h, z1, u0, v0 );
+	}
+}
+
+
+void TileRenderer::tesselateRowTexture( Tile* tt, int data, float x, float y, float z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	Icon *tex = getTexture(tt, 0, data);
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	float u0 = tex->getU0(true);
+	float v0 = tex->getV0(true);
+	float u1 = tex->getU1(true);
+	float v1 = tex->getV1(true);
+
+	float		x0 = x + 0.5f - 0.25f;
+	float		x1 = x + 0.5f + 0.25f;
+	float		z0 = z + 0.5f - 0.5f;
+	float		z1 = z + 0.5f + 0.5f;
+
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u1 ), ( float )( v0 ) );
+
+	x0 = x + 0.5f - 0.5f;
+	x1 = x + 0.5f + 0.5f;
+	z0 = z + 0.5f - 0.25f;
+	z1 = z + 0.5f + 0.25f;
+
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z0 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u1 ), ( float )( v0 ) );
+
+	t->vertexUV( ( float )( x0 ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u0 ), ( float )( v0 ) );
+	t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+	t->vertexUV( ( float )( x1 ), ( float )( y + 1 ), ( float )( z1 ), ( float )( u1 ), ( float )( v0 ) );
+
+}
+
+bool TileRenderer::tesselateWaterInWorld( Tile* tt, int x, int y, int z )
+{
+	// 4J Java comment
+	// TODO: This all needs to change. Somehow.
+	Tesselator* t = Tesselator::getInstance();
+
+	int			col = tt->getColor( level, x, y, z );
+	float		r = ( col >> 16 & 0xff ) / 255.0f;
+	float		g = ( col >> 8 & 0xff ) / 255.0f;
+	float		b = ( col & 0xff ) / 255.0f;
+	bool		up = tt->shouldRenderFace( level, x, y + 1, z, 1 );
+	bool		down = tt->shouldRenderFace( level, x, y - 1, z, 0 );
+	bool		dirs[4];
+	dirs[0] = tt->shouldRenderFace( level, x, y, z - 1, 2 );
+	dirs[1] = tt->shouldRenderFace( level, x, y, z + 1, 3 );
+	dirs[2] = tt->shouldRenderFace( level, x - 1, y, z, 4 );
+	dirs[3] = tt->shouldRenderFace( level, x + 1, y, z, 5 );
+
+	if ( !up && !down && !dirs[0] && !dirs[1] && !dirs[2] && !dirs[3] ) return false;
+
+	bool		changed = false;
+	float		c10 = 0.5f;
+	float		c11 = 1;
+	float		c2 = 0.8f;
+	float		c3 = 0.6f;
+
+	double		yo0 = 0;
+	double		yo1 = 1;
+
+	Material*	m = tt->material;
+	int			data = level->getData( x, y, z );
+
+	float		h0 = getWaterHeight( x, y, z, m );
+	float		h1 = getWaterHeight( x, y, z + 1, m );
+	float		h2 = getWaterHeight( x + 1, y, z + 1, m );
+	float		h3 = getWaterHeight( x + 1, y, z, m );
+
+    float offs = 0.001f;
+	// 4J - added. Farm tiles often found beside water, but they consider themselves non-solid as they only extend up to 15.0f / 16.0f.
+	// If the max height of this water is below that level, don't bother rendering sides bordering onto farmland.
+	float		maxh = h0;
+	if ( h1 > maxh ) maxh = h1;
+	if ( h2 > maxh ) maxh = h2;
+	if ( h3 > maxh ) maxh = h3;
+	if ( maxh <= ( 15.0f / 16.0f ) )
+	{
+		if ( level->getTile( x, y, z - 1 ) == Tile::farmland_Id )
+		{
+			dirs[0] = false;
+		}
+		if ( level->getTile( x, y, z + 1 ) == Tile::farmland_Id )
+		{
+			dirs[1] = false;
+		}
+		if ( level->getTile( x - 1, y, z ) == Tile::farmland_Id )
+		{
+			dirs[2] = false;
+		}
+		if ( level->getTile( x + 1, y, z ) == Tile::farmland_Id )
+		{
+			dirs[3] = false;
+		}
+	}
+
+	if ( noCulling || up )
+	{
+		changed = true;
+		Icon *tex = getTexture( tt, 1, data );
+		float	angle = ( float )LiquidTile::getSlopeAngle( level, x, y, z, m );
+		if ( angle > -999 )
+		{
+			tex = getTexture( tt, 2, data );
+		}
+
+        h0 -= offs;
+        h1 -= offs;
+        h2 -= offs;
+        h3 -= offs;
+
+		float u00, u01, u10, u11;
+		float v00, v01, v10, v11;
+		if ( angle < -999 )
+		{
+			u00 = tex->getU(0, true);
+			v00 = tex->getV(0, true);
+			u01 = u00;
+			v01 = tex->getV(SharedConstants::WORLD_RESOLUTION, true);
+			u10 = tex->getU(SharedConstants::WORLD_RESOLUTION, true);
+			v10 = v01;
+			u11 = u10;
+			v11 = v00;
+		}
+		else
+		{
+			float s = Mth::sin(angle) * .25f;
+			float c = Mth::cos(angle) * .25f;
+			float cc = SharedConstants::WORLD_RESOLUTION * .5f;
+			u00 = tex->getU(cc + (-c - s) * SharedConstants::WORLD_RESOLUTION);
+			v00 = tex->getV(cc + (-c + s) * SharedConstants::WORLD_RESOLUTION);
+			u01 = tex->getU(cc + (-c + s) * SharedConstants::WORLD_RESOLUTION);
+			v01 = tex->getV(cc + (+c + s) * SharedConstants::WORLD_RESOLUTION);
+			u10 = tex->getU(cc + (+c + s) * SharedConstants::WORLD_RESOLUTION);
+			v10 = tex->getV(cc + (+c - s) * SharedConstants::WORLD_RESOLUTION);
+			u11 = tex->getU(cc + (+c - s) * SharedConstants::WORLD_RESOLUTION);
+			v11 = tex->getV(cc + (-c - s) * SharedConstants::WORLD_RESOLUTION);
+		}
+
+		float	br;
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( getLightColor(tt,  level, x, y, z ) );
+			br = 1;
+		}
+		else
+		{
+			br = tt->getBrightness( level, x, y, z );
+		}
+		t->color( c11 * br * r, c11 * br * g, c11 * br * b );
+		t->vertexUV( ( float )( x + 0.0f ), ( float )( y + h0 ), ( float )( z + 0.0f ), u00, v00 );
+		t->vertexUV( ( float )( x + 0.0f ), ( float )( y + h1 ), ( float )( z + 1.0f ), u01, v01 );
+		t->vertexUV( ( float )( x + 1.0f ), ( float )( y + h2 ), ( float )( z + 1.0f ), u10, v10 );
+		t->vertexUV( ( float )( x + 1.0f ), ( float )( y + h3 ), ( float )( z + 0.0f ), u11, v11 );
+	}
+
+	if ( noCulling || down )
+	{
+		float br;
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( getLightColor(tt,  level, x, y - 1, z ) );
+			br = 1;
+		}
+		else
+		{
+			br = tt->getBrightness( level, x, y - 1, z );
+		}
+		t->color( c10 * br, c10 * br, c10 * br );
+		renderFaceDown( tt, x, y + offs, z, getTexture( tt, 0 ) );
+		changed = true;
+	}
+
+	for ( int face = 0; face < 4; face++ )
+	{
+		int xt = x;
+		int yt = y;
+		int zt = z;
+
+		if ( face == 0 ) zt--;
+		if ( face == 1 ) zt++;
+		if ( face == 2 ) xt--;
+		if ( face == 3 ) xt++;
+
+		Icon *tex = getTexture(tt, face + 2, data);
+
+		if ( noCulling || dirs[face] )
+		{
+			float	hh0;
+			float	hh1;
+			float	x0, z0, x1, z1;
+			if ( face == 0 )
+			{
+				hh0 = ( float )( h0 );
+				hh1 = ( float )( h3 );
+				x0 = ( float )( x );
+				x1 = ( float )( x + 1 );
+				z0 = ( float )( z + offs);
+				z1 = ( float )( z + offs);
+			}
+			else if ( face == 1 )
+			{
+				hh0 = ( float )( h2 );
+				hh1 = ( float )( h1 );
+				x0 = ( float )( x + 1 );
+				x1 = ( float )( x );
+				z0 = ( float )( z + 1 - offs);
+				z1 = ( float )( z + 1 - offs);
+			}
+			else if ( face == 2 )
+			{
+				hh0 = ( float )( h1 );
+				hh1 = ( float )( h0 );
+				x0 = ( float )( x + offs);
+				x1 = ( float )( x + offs);
+				z0 = ( float )( z + 1 );
+				z1 = ( float )( z );
+			}
+			else
+			{
+				hh0 = ( float )( h3 );
+				hh1 = ( float )( h2 );
+				x0 = ( float )( x + 1 - offs);
+				x1 = ( float )( x + 1 - offs);
+				z0 = ( float )( z );
+				z1 = ( float )( z + 1 );
+			}
+
+
+			changed = true;
+			float u0 = tex->getU(0, true);
+			float u1 = tex->getU(SharedConstants::WORLD_RESOLUTION * .5f, true);
+
+			int yTex = tex->getY();
+			float v01 = tex->getV((1 - hh0) * SharedConstants::WORLD_RESOLUTION * .5f);
+			float v02 = tex->getV((1 - hh1) * SharedConstants::WORLD_RESOLUTION * .5f);
+			float v1 = tex->getV(SharedConstants::WORLD_RESOLUTION * .5f, true);
+
+			float	br;
+			if ( SharedConstants::TEXTURE_LIGHTING )
+			{
+				t->tex2( getLightColor(tt,  level, xt, yt, zt ) );
+				br = 1;
+			}
+			else
+			{
+				br = tt->getBrightness( level, xt, yt, zt );
+			}
+			if ( face < 2 ) br *= c2;
+			else
+				br *= c3;
+
+			t->color( c11 * br * r, c11 * br * g, c11 * br * b );
+			t->vertexUV( ( float )( x0 ), ( float )( y + hh0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v01 ) );
+			t->vertexUV( ( float )( x1 ), ( float )( y + hh1 ), ( float )( z1 ), ( float )( u1 ), ( float )( v02 ) );
+			t->vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+			t->vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+
+		}
+
+	}
+
+	tileShapeY0 = yo0;
+	tileShapeY1 = yo1;
+
+	return changed;
+
+}
+
+float TileRenderer::getWaterHeight( int x, int y, int z, Material* m )
+{
+	int		count = 0;
+	float	h = 0;
+	for ( int i = 0; i < 4; i++ )
+	{
+		int			xx = x - ( i & 1 );
+		int			yy = y;
+		int			zz = z - ( ( i >> 1 ) & 1 );
+		if ( level->getMaterial( xx, yy + 1, zz ) == m )
+		{
+			return 1;
+		}
+		Material*	tm = level->getMaterial( xx, yy, zz );
+		if ( tm == m )
+		{
+			int d = level->getData( xx, yy, zz );
+			if ( d >= 8 || d == 0 )
+			{
+				h += ( LiquidTile::getHeight( d ) )* 10;
+				count += 10;
+			}
+			h += LiquidTile::getHeight( d );
+			count++;
+		}
+		else if ( !tm->isSolid() )
+		{
+			h += 1;
+			count++;
+		}
+	}
+	return 1 - h / count;
+}
+
+void TileRenderer::renderBlock( Tile* tt, Level* level, int x, int y, int z )
+{
+	renderBlock(tt, level, x, y, z, 0);
+}
+
+void TileRenderer::renderBlock(Tile *tt, Level *level, int x, int y, int z, int data)
+{
+	float		c10 = 0.5f;
+	float		c11 = 1;
+	float		c2 = 0.8f;
+	float		c3 = 0.6f;
+
+	Tesselator* t = Tesselator::getInstance();
+	t->begin();
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( getLightColor(tt,  level, x, y, z ) );
+	}
+	float		center = SharedConstants::TEXTURE_LIGHTING ? 1 : tt->getBrightness( level, x, y, z );
+	float		br = SharedConstants::TEXTURE_LIGHTING ? 1 : tt->getBrightness( level, x, y - 1, z );
+
+	if ( br < center ) br = center;
+	t->color( c10 * br, c10 * br, c10 * br );
+	renderFaceDown( tt, -0.5f, -0.5f, -0.5f, getTexture( tt, 0, data ) );
+
+	br = SharedConstants::TEXTURE_LIGHTING ? 1 : tt->getBrightness( level, x, y + 1, z );
+	if ( br < center ) br = center;
+	t->color( c11 * br, c11 * br, c11 * br );
+	renderFaceUp( tt, -0.5f, -0.5f, -0.5f, getTexture( tt, 1, data ) );
+
+	br = SharedConstants::TEXTURE_LIGHTING ? 1 : tt->getBrightness( level, x, y, z - 1 );
+	if ( br < center ) br = center;
+	t->color( c2 * br, c2 * br, c2 * br );
+	renderNorth( tt, -0.5f, -0.5f, -0.5f, getTexture( tt, 2, data ) );
+
+	br = SharedConstants::TEXTURE_LIGHTING ? 1 : tt->getBrightness( level, x, y, z + 1 );
+	if ( br < center ) br = center;
+	t->color( c2 * br, c2 * br, c2 * br );
+	renderSouth( tt, -0.5f, -0.5f, -0.5f, getTexture( tt, 3, data ) );
+
+	br = SharedConstants::TEXTURE_LIGHTING ? 1 : tt->getBrightness( level, x - 1, y, z );
+	if ( br < center ) br = center;
+	t->color( c3 * br, c3 * br, c3 * br );
+	renderWest( tt, -0.5f, -0.5f, -0.5f, getTexture( tt, 4, data ) );
+
+	br = SharedConstants::TEXTURE_LIGHTING ? 1 : tt->getBrightness( level, x + 1, y, z );
+	if ( br < center ) br = center;
+	t->color( c3 * br, c3 * br, c3 * br );
+	renderEast( tt, -0.5f, -0.5f, -0.5f, getTexture( tt, 5, data ) );
+	t->end();
+
+}
+
+bool TileRenderer::tesselateBlockInWorld( Tile* tt, int x, int y, int z )
+{
+	int		col = tt->getColor( level, x, y, z );
+	float	r = ( ( col >> 16 ) & 0xff ) / 255.0f;
+	float	g = ( ( col >> 8 ) & 0xff ) / 255.0f;
+	float	b = ( ( col )& 0xff ) / 255.0f;
+
+	if ( GameRenderer::anaglyph3d )
+	{
+		float	cr = ( r * 30 + g * 59 + b * 11 ) / 100;
+		float	cg = ( r * 30 + g * 70 ) / ( 100 );
+		float	cb = ( r * 30 + b * 70 ) / ( 100 );
+
+		r = cr;
+		g = cg;
+		b = cb;
+	}
+
+	if ( Tile::lightEmission[tt->id] == 0 )//4J - TODO/remove (Minecraft::useAmbientOcclusion())
+	{
+		return tesselateBlockInWorldWithAmbienceOcclusionTexLighting( tt, x, y, z, r, g, b, 0 );
+	}
+	else
+	{
+		return tesselateBlockInWorld( tt, x, y, z, r, g, b );
+	}
+}
+
+// AP - added this version to be able to pass the face flags down
+bool TileRenderer::tesselateBlockInWorld( Tile* tt, int x, int y, int z, int faceFlags )
+{
+	int		col = tt->getColor( level, x, y, z );
+	float	r = ( ( col >> 16 ) & 0xff ) / 255.0f;
+	float	g = ( ( col >> 8 ) & 0xff ) / 255.0f;
+	float	b = ( ( col )& 0xff ) / 255.0f;
+
+	if ( GameRenderer::anaglyph3d )
+	{
+		float	cr = ( r * 30 + g * 59 + b * 11 ) / 100;
+		float	cg = ( r * 30 + g * 70 ) / ( 100 );
+		float	cb = ( r * 30 + b * 70 ) / ( 100 );
+
+		r = cr;
+		g = cg;
+		b = cb;
+	}
+
+	if ( Tile::lightEmission[tt->id] == 0 )//4J - TODO/remove (Minecraft::useAmbientOcclusion())
+	{
+		return tesselateBlockInWorldWithAmbienceOcclusionTexLighting( tt, x, y, z, r, g, b, faceFlags );
+	}
+	else
+	{
+		return tesselateBlockInWorld( tt, x, y, z, r, g, b );
+	}
+}
+
+bool TileRenderer::tesselateTreeInWorld(Tile *tt, int x, int y, int z)
+{
+	int data = level->getData(x, y, z);
+	int facing = data & TreeTile::MASK_FACING;
+
+	if (facing == TreeTile::FACING_X)
+	{
+		northFlip = FLIP_CW;
+		southFlip = FLIP_CW;
+		upFlip = FLIP_CW;
+		downFlip = FLIP_CW;
+	}
+	else if (facing == TreeTile::FACING_Z)
+	{
+		eastFlip = FLIP_CW;
+		westFlip = FLIP_CW;
+	}
+
+	bool result = tesselateBlockInWorld(tt, x, y, z);
+
+	eastFlip = 0;
+	northFlip = 0;
+	southFlip = 0;
+	westFlip = 0;
+	upFlip = 0;
+	downFlip = 0;
+
+	return result;
+}
+
+bool TileRenderer::tesselateQuartzInWorld(Tile *tt, int x, int y, int z)
+{
+	int data = level->getData(x, y, z);
+
+	if (data == QuartzBlockTile::TYPE_LINES_X)
+	{
+		northFlip = FLIP_CW;
+		southFlip = FLIP_CW;
+		upFlip = FLIP_CW;
+		downFlip = FLIP_CW;
+	}
+	else if (data == QuartzBlockTile::TYPE_LINES_Z)
+	{
+		eastFlip = FLIP_CW;
+		westFlip = FLIP_CW;
+	}
+
+	bool result = tesselateBlockInWorld(tt, x, y, z);
+
+	eastFlip = 0;
+	northFlip = 0;
+	southFlip = 0;
+	westFlip = 0;
+	upFlip = 0;
+	downFlip = 0;
+
+	return result;
+}
+
+bool TileRenderer::tesselateCocoaInWorld(CocoaTile *tt, int x, int y, int z)
+{
+	Tesselator *t = Tesselator::getInstance();
+
+	if (SharedConstants::TEXTURE_LIGHTING)
+	{
+		t->tex2(getLightColor(tt, level, x, y, z));
+		t->color(1.0f, 1.0f, 1.0f);
+	}
+	else
+	{
+		float br = tt->getBrightness(level, x, y, z);
+		if (Tile::lightEmission[tt->id] > 0) br = 1.0f;
+		t->color(br, br, br);
+	}
+
+	int data = level->getData(x, y, z);
+	int dir = DirectionalTile::getDirection(data);
+	int age = CocoaTile::getAge(data);
+	Icon *tex = tt->getTextureForAge(age);
+
+	int cocoaWidth = 4 + age * 2;
+	int cocoaHeight = 5 + age * 2;
+
+	double us = 15.0 - cocoaWidth;
+	double ue = 15.0;
+	double vs = 4.0;
+	double ve = 4.0 + cocoaHeight;
+	double u0 = tex->getU(us, true);
+	double u1 = tex->getU(ue, true);
+	double v0 = tex->getV(vs, true);
+	double v1 = tex->getV(ve, true);
+
+
+	double offX = 0;
+	double offZ = 0;
+
+	switch (dir)
+	{
+	case Direction::NORTH:
+		offX = 8.0 - cocoaWidth / 2;
+		offZ = 1.0;
+		break;
+	case Direction::SOUTH:
+		offX = 8.0 - cocoaWidth / 2;
+		offZ = 15.0 - cocoaWidth;
+		break;
+	case Direction::EAST:
+		offX = 15.0 - cocoaWidth;
+		offZ = 8.0 - cocoaWidth / 2;
+		break;
+	case Direction::WEST:
+		offX = 1.0;
+		offZ = 8.0 - cocoaWidth / 2;
+		break;
+	}
+
+	double x0 = x + offX / 16.0;
+	double x1 = x + (offX + cocoaWidth) / 16.0;
+	double y0 = y + (12.0 - cocoaHeight) / 16.0;
+	double y1 = y + 12.0 / 16.0;
+	double z0 = z + offZ / 16.0;
+	double z1 = z + (offZ + cocoaWidth) / 16.0;
+
+	// west
+	{
+		t->vertexUV(x0, y0, z0, u0, v1);
+		t->vertexUV(x0, y0, z1, u1, v1);
+		t->vertexUV(x0, y1, z1, u1, v0);
+		t->vertexUV(x0, y1, z0, u0, v0);
+	}
+	// east
+	{
+		t->vertexUV(x1, y0, z1, u0, v1);
+		t->vertexUV(x1, y0, z0, u1, v1);
+		t->vertexUV(x1, y1, z0, u1, v0);
+		t->vertexUV(x1, y1, z1, u0, v0);
+	}
+	// north
+	{
+		t->vertexUV(x1, y0, z0, u0, v1);
+		t->vertexUV(x0, y0, z0, u1, v1);
+		t->vertexUV(x0, y1, z0, u1, v0);
+		t->vertexUV(x1, y1, z0, u0, v0);
+	}
+	// south
+	{
+		t->vertexUV(x0, y0, z1, u0, v1);
+		t->vertexUV(x1, y0, z1, u1, v1);
+		t->vertexUV(x1, y1, z1, u1, v0);
+		t->vertexUV(x0, y1, z1, u0, v0);
+	}
+
+	int topWidth = cocoaWidth;
+	if (age >= 2)
+	{
+		// special case because the top piece didn't fit
+		topWidth--;
+	}
+
+	u0 = tex->getU0(true);
+	u1 = tex->getU(topWidth, true);
+	v0 = tex->getV0(true);
+	v1 = tex->getV(topWidth, true);
+
+	// top
+	{
+		t->vertexUV(x0, y1, z1, u0, v1);
+		t->vertexUV(x1, y1, z1, u1, v1);
+		t->vertexUV(x1, y1, z0, u1, v0);
+		t->vertexUV(x0, y1, z0, u0, v0);
+	}
+	// bottom
+	{
+		t->vertexUV(x0, y0, z0, u0, v0);
+		t->vertexUV(x1, y0, z0, u1, v0);
+		t->vertexUV(x1, y0, z1, u1, v1);
+		t->vertexUV(x0, y0, z1, u0, v1);
+	}
+
+	// stalk
+	u0 = tex->getU(12, true);
+	u1 = tex->getU1(true);
+	v0 = tex->getV0(true);
+	v1 = tex->getV(4, true);
+
+	offX = 8;
+	offZ = 0;
+
+	switch (dir)
+	{
+	case Direction::NORTH:
+		offX = 8.0;
+		offZ = 0.0;
+		break;
+	case Direction::SOUTH:
+		offX = 8;
+		offZ = 12;
+		{
+			double temp = u0;
+			u0 = u1;
+			u1 = temp;
+		}
+		break;
+	case Direction::EAST:
+		offX = 12.0;
+		offZ = 8.0;
+		{
+			double temp = u0;
+			u0 = u1;
+			u1 = temp;
+		}
+		break;
+	case Direction::WEST:
+		offX = 0.0;
+		offZ = 8.0;
+		break;
+	}
+
+	x0 = x + offX / 16.0;
+	x1 = x + (offX + 4.0) / 16.0;
+	y0 = y + 12.0 / 16.0;
+	y1 = y + 16.0 / 16.0;
+	z0 = z + offZ / 16.0;
+	z1 = z + (offZ + 4.0) / 16.0;
+	if (dir == Direction::NORTH || dir == Direction::SOUTH)
+	{
+		// west
+		{
+			t->vertexUV(x0, y0, z0, u1, v1);
+			t->vertexUV(x0, y0, z1, u0, v1);
+			t->vertexUV(x0, y1, z1, u0, v0);
+			t->vertexUV(x0, y1, z0, u1, v0);
+		}
+		// east
+		{
+			t->vertexUV(x0, y0, z1, u0, v1);
+			t->vertexUV(x0, y0, z0, u1, v1);
+			t->vertexUV(x0, y1, z0, u1, v0);
+			t->vertexUV(x0, y1, z1, u0, v0);
+		}
+	}
+	else if (dir == Direction::WEST || dir == Direction::EAST)
+	{
+		// north
+		{
+			t->vertexUV(x1, y0, z0, u0, v1);
+			t->vertexUV(x0, y0, z0, u1, v1);
+			t->vertexUV(x0, y1, z0, u1, v0);
+			t->vertexUV(x1, y1, z0, u0, v0);
+		}
+		// south
+		{
+			t->vertexUV(x0, y0, z0, u1, v1);
+			t->vertexUV(x1, y0, z0, u0, v1);
+			t->vertexUV(x1, y1, z0, u0, v0);
+			t->vertexUV(x0, y1, z0, u1, v0);
+		}
+	}
+
+
+	return true;
+}
+
+// 4J - brought changes forward from 1.8.2
+bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusionTexLighting( Tile* tt, int pX, int pY, int pZ,
+																		  float pBaseRed, float pBaseGreen,
+																		  float pBaseBlue, int faceFlags )
+{
+	// 4J - the texture is (originally) obtained for each face in the block, if those faces are visible. For a lot of blocks,
+	// the textures don't vary from face to face - this is particularly an issue for leaves as they not only don't vary between faces,
+	// but they also happen to draw a lot of faces, and the code for determining which texture to use is more complex than in most
+	// cases. Optimisation here then to store a uniform texture where appropriate (could be extended beyond leaves) that will stop
+	// any other faces being evaluated.
+	Icon *uniformTex = NULL;
+	int id = tt->id;
+	if( id == Tile::leaves_Id )
+	{
+		uniformTex = getTexture(tt, level, pX, pY, pZ, 0);
+	}
+	// 4J - added these faceFlags so we can detect whether this block is going to have no visible faces and early out
+	// the original code checked noCulling and shouldRenderFace directly where faceFlags is used now
+	// AP - I moved a copy of these face checks to have an even earlier out
+	// check if the faceFlags have indeed been set
+	if( faceFlags == 0 )
+	{
+		if ( noCulling )
+		{
+			faceFlags = 0x3f;
+		}
+		else
+		{
+			faceFlags |= tt->shouldRenderFace( level, pX, pY - 1, pZ, 0 ) ? 0x01 : 0;
+			faceFlags |= tt->shouldRenderFace( level, pX, pY + 1, pZ, 1 ) ? 0x02 : 0;
+			faceFlags |= tt->shouldRenderFace( level, pX, pY, pZ - 1, 2 ) ? 0x04 : 0;
+			faceFlags |= tt->shouldRenderFace( level, pX, pY, pZ + 1, 3 ) ? 0x08 : 0;
+			faceFlags |= tt->shouldRenderFace( level, pX - 1, pY, pZ, 4 ) ? 0x10 : 0;
+			faceFlags |= tt->shouldRenderFace( level, pX + 1, pY, pZ, 5 ) ? 0x20 : 0;
+		}
+		if ( faceFlags == 0 )
+		{
+			return false;
+		}
+	}
+	// If we are only rendering the bottom face and we're at the bottom of the world, we shouldn't be able to see this - don't render anything
+	if( ( faceFlags == 1 ) && ( pY == 0 ) )
+	{
+		return false;
+	}
+
+	applyAmbienceOcclusion = true;
+	float		ll1 = ll000;
+	float		ll2 = ll000;
+	float		ll3 = ll000;
+	float		ll4 = ll000;
+	bool		tint0 = true;
+	bool		tint1 = true;
+	bool		tint2 = true;
+	bool		tint3 = true;
+	bool		tint4 = true;
+	bool		tint5 = true;
+
+
+	ll000 = getShadeBrightness(tt, level, pX, pY, pZ );
+	llx00 = getShadeBrightness(tt, level, pX - 1, pY, pZ );
+	ll0y0 = getShadeBrightness(tt, level, pX, pY - 1, pZ );
+	ll00z = getShadeBrightness(tt, level, pX, pY, pZ - 1 );
+	llX00 = getShadeBrightness(tt, level, pX + 1, pY, pZ );
+	ll0Y0 = getShadeBrightness(tt, level, pX, pY + 1, pZ );
+	ll00Z = getShadeBrightness(tt, level, pX, pY, pZ + 1 );
+
+	// 4J - these changes brought forward from 1.2.3
+	int			centerColor = getLightColor(tt,  level, pX, pY, pZ );
+	int			ccx00 = centerColor;
+	int			cc0y0 = centerColor;
+	int			cc00z = centerColor;
+	int			ccX00 = centerColor;
+	int			cc0Y0 = centerColor;
+	int			cc00Z = centerColor;
+
+	if (tileShapeY0 <= 0 || !level->isSolidRenderTile(pX, pY - 1, pZ)) cc0y0 = getLightColor(tt, level, pX, pY - 1, pZ);
+	if (tileShapeY1 >= 1 || !level->isSolidRenderTile(pX, pY + 1, pZ)) cc0Y0 = getLightColor(tt, level, pX, pY + 1, pZ);
+	if (tileShapeX0 <= 0 || !level->isSolidRenderTile(pX - 1, pY, pZ)) ccx00 = getLightColor(tt, level, pX - 1, pY, pZ);
+	if (tileShapeX1 >= 1 || !level->isSolidRenderTile(pX + 1, pY, pZ)) ccX00 = getLightColor(tt, level, pX + 1, pY, pZ);
+	if (tileShapeZ0 <= 0 || !level->isSolidRenderTile(pX, pY, pZ - 1)) cc00z = getLightColor(tt, level, pX, pY, pZ - 1);
+	if (tileShapeZ1 >= 1 || !level->isSolidRenderTile(pX, pY, pZ + 1)) cc00Z = getLightColor(tt, level, pX, pY, pZ + 1);
+
+	Tesselator* t = Tesselator::getInstance();
+	t->tex2( 0xf000f );
+
+	llTransXY0 = isTranslucentAt( level, pX + 1, pY + 1, pZ );
+	llTransXy0 = isTranslucentAt( level, pX + 1, pY - 1, pZ );
+	llTransX0Z = isTranslucentAt( level, pX + 1, pY, pZ + 1 );
+	llTransX0z = isTranslucentAt( level, pX + 1, pY, pZ - 1 );
+	llTransxY0 = isTranslucentAt( level, pX - 1, pY + 1, pZ );
+	llTransxy0 = isTranslucentAt( level, pX - 1, pY - 1, pZ );
+	llTransx0z = isTranslucentAt( level, pX - 1, pY, pZ - 1 );
+	llTransx0Z = isTranslucentAt( level, pX - 1, pY, pZ + 1 );
+	llTrans0YZ = isTranslucentAt( level, pX, pY + 1, pZ + 1 );
+	llTrans0Yz = isTranslucentAt( level, pX, pY + 1, pZ - 1 );
+	llTrans0yZ = isTranslucentAt( level, pX, pY - 1, pZ + 1 );
+	llTrans0yz = isTranslucentAt( level, pX, pY - 1, pZ - 1 );
+
+	if( uniformTex == NULL )
+	{
+		if ( getTexture(tt)->getFlags() == Icon::IS_GRASS_TOP ) tint0 = tint2 = tint3 = tint4 = tint5 = false;
+	}
+	if ( hasFixedTexture() ) tint0 = tint2 = tint3 = tint4 = tint5 = false;
+
+	if ( faceFlags & 0x01 )
+	{
+		if ( blsmooth > 0 )
+		{
+			if ( tileShapeY0 <= 0 ) pY--;		// 4J - condition brought forward from 1.2.3
+
+			ccxy0 = getLightColor(tt,  level, pX - 1, pY, pZ );
+			cc0yz = getLightColor(tt,  level, pX, pY, pZ - 1 );
+			cc0yZ = getLightColor(tt,  level, pX, pY, pZ + 1 );
+			ccXy0 = getLightColor(tt,  level, pX + 1, pY, pZ );
+
+			llxy0 = getShadeBrightness(tt, level, pX - 1, pY, pZ );
+			ll0yz = getShadeBrightness(tt, level, pX, pY, pZ - 1 );
+			ll0yZ = getShadeBrightness(tt, level, pX, pY, pZ + 1 );
+			llXy0 = getShadeBrightness(tt, level, pX + 1, pY, pZ );
+
+			if ( llTrans0yz || llTransxy0 )
+			{
+				llxyz = getShadeBrightness(tt, level, pX - 1, pY, pZ - 1 );
+				ccxyz = getLightColor(tt,  level, pX - 1, pY, pZ - 1 );
+			}
+			else
+			{
+				llxyz = llxy0;
+				ccxyz = ccxy0;
+			}
+			if ( llTrans0yZ || llTransxy0 )
+			{
+				llxyZ = getShadeBrightness(tt, level, pX - 1, pY, pZ + 1 );
+				ccxyZ = getLightColor(tt,  level, pX - 1, pY, pZ + 1 );
+			}
+			else
+			{
+				llxyZ = llxy0;
+				ccxyZ = ccxy0;
+			}
+			if ( llTrans0yz || llTransXy0 )
+			{
+				llXyz = getShadeBrightness(tt, level, pX + 1, pY, pZ - 1 );
+				ccXyz = getLightColor(tt,  level, pX + 1, pY, pZ - 1 );
+			}
+			else
+			{
+				llXyz = llXy0;
+				ccXyz = ccXy0;
+			}
+			if ( llTrans0yZ || llTransXy0 )
+			{
+				llXyZ = getShadeBrightness(tt, level, pX + 1, pY, pZ + 1 );
+				ccXyZ = getLightColor(tt,  level, pX + 1, pY, pZ + 1 );
+			}
+			else
+			{
+				llXyZ = llXy0;
+				ccXyZ = ccXy0;
+			}
+
+			if ( tileShapeY0 <= 0 ) pY++;		// 4J - condition brought forward from 1.2.3
+			ll1 = ( llxyZ + llxy0 + ll0yZ + ll0y0 ) / 4.0f;
+			ll4 = ( ll0yZ + ll0y0 + llXyZ + llXy0 ) / 4.0f;
+			ll3 = ( ll0y0 + ll0yz + llXy0 + llXyz ) / 4.0f;
+			ll2 = ( llxy0 + llxyz + ll0y0 + ll0yz ) / 4.0f;
+
+			tc1 = blend( ccxyZ, ccxy0, cc0yZ, cc0y0 );
+			tc4 = blend( cc0yZ, ccXyZ, ccXy0, cc0y0 );
+			tc3 = blend( cc0yz, ccXy0, ccXyz, cc0y0 );
+			tc2 = blend( ccxy0, ccxyz, cc0yz, cc0y0 );
+		}
+		else
+		{
+			ll1 = ll2 = ll3 = ll4 = ll0y0;
+			tc1 = tc2 = tc3 = tc4 = ccxy0;
+		}
+		c1r = c2r = c3r = c4r = ( tint0 ? pBaseRed : 1.0f ) * 0.5f;
+		c1g = c2g = c3g = c4g = ( tint0 ? pBaseGreen : 1.0f ) * 0.5f;
+		c1b = c2b = c3b = c4b = ( tint0 ? pBaseBlue : 1.0f ) * 0.5f;
+		c1r *= ll1;
+		c1g *= ll1;
+		c1b *= ll1;
+		c2r *= ll2;
+		c2g *= ll2;
+		c2b *= ll2;
+		c3r *= ll3;
+		c3g *= ll3;
+		c3b *= ll3;
+		c4r *= ll4;
+		c4g *= ll4;
+		c4b *= ll4;
+
+		renderFaceDown( tt, ( double )pX, ( double )pY, ( double )pZ, uniformTex ? uniformTex : getTexture( tt, level, pX, pY, pZ, 0 ) );
+	}
+	if ( faceFlags & 0x02 )
+	{
+		if ( blsmooth > 0 )
+		{
+			if ( tileShapeY1 >= 1 ) pY++;		// 4J - condition brought forward from 1.2.3
+
+			ccxY0 = getLightColor(tt,  level, pX - 1, pY, pZ );
+			ccXY0 = getLightColor(tt,  level, pX + 1, pY, pZ );
+			cc0Yz = getLightColor(tt,  level, pX, pY, pZ - 1 );
+			cc0YZ = getLightColor(tt,  level, pX, pY, pZ + 1 );
+
+			llxY0 = getShadeBrightness(tt, level, pX - 1, pY, pZ );
+			llXY0 = getShadeBrightness(tt, level, pX + 1, pY, pZ );
+			ll0Yz = getShadeBrightness(tt, level, pX, pY, pZ - 1 );
+			ll0YZ = getShadeBrightness(tt, level, pX, pY, pZ + 1 );
+
+			if ( llTrans0Yz || llTransxY0 )
+			{
+				llxYz = getShadeBrightness(tt, level, pX - 1, pY, pZ - 1 );
+				ccxYz = getLightColor(tt,  level, pX - 1, pY, pZ - 1 );
+			}
+			else
+			{
+				llxYz = llxY0;
+				ccxYz = ccxY0;
+			}
+			if ( llTrans0Yz || llTransXY0 )
+			{
+				llXYz = getShadeBrightness(tt, level, pX + 1, pY, pZ - 1 );
+				ccXYz = getLightColor(tt,  level, pX + 1, pY, pZ - 1 );
+			}
+			else
+			{
+				llXYz = llXY0;
+				ccXYz = ccXY0;
+			}
+			if ( llTrans0YZ || llTransxY0 )
+			{
+				llxYZ = getShadeBrightness(tt, level, pX - 1, pY, pZ + 1 );
+				ccxYZ = getLightColor(tt,  level, pX - 1, pY, pZ + 1 );
+			}
+			else
+			{
+				llxYZ = llxY0;
+				ccxYZ = ccxY0;
+			}
+			if ( llTrans0YZ || llTransXY0 )
+			{
+				llXYZ = getShadeBrightness(tt, level, pX + 1, pY, pZ + 1 );
+				ccXYZ = getLightColor(tt,  level, pX + 1, pY, pZ + 1 );
+			}
+			else
+			{
+				llXYZ = llXY0;
+				ccXYZ = ccXY0;
+			}
+			if ( tileShapeY1 >= 1 ) pY--;		// 4J - condition brought forward from 1.2.3
+
+			ll4 = ( llxYZ + llxY0 + ll0YZ + ll0Y0 ) / 4.0f;
+			ll1 = ( ll0YZ + ll0Y0 + llXYZ + llXY0 ) / 4.0f;
+			ll2 = ( ll0Y0 + ll0Yz + llXY0 + llXYz ) / 4.0f;
+			ll3 = ( llxY0 + llxYz + ll0Y0 + ll0Yz ) / 4.0f;
+
+			tc4 = blend( ccxYZ, ccxY0, cc0YZ, cc0Y0 );
+			tc1 = blend( cc0YZ, ccXYZ, ccXY0, cc0Y0 );
+			tc2 = blend( cc0Yz, ccXY0, ccXYz, cc0Y0 );
+			tc3 = blend( ccxY0, ccxYz, cc0Yz, cc0Y0 );
+		}
+		else
+		{
+			ll1 = ll2 = ll3 = ll4 = ll0Y0;
+			tc1 = tc2 = tc3 = tc4 = cc0Y0;
+		}
+		c1r = c2r = c3r = c4r = ( tint1 ? pBaseRed : 1.0f );
+		c1g = c2g = c3g = c4g = ( tint1 ? pBaseGreen : 1.0f );
+		c1b = c2b = c3b = c4b = ( tint1 ? pBaseBlue : 1.0f );
+		c1r *= ll1;
+		c1g *= ll1;
+		c1b *= ll1;
+		c2r *= ll2;
+		c2g *= ll2;
+		c2b *= ll2;
+		c3r *= ll3;
+		c3g *= ll3;
+		c3b *= ll3;
+		c4r *= ll4;
+		c4g *= ll4;
+		c4b *= ll4;
+		renderFaceUp( tt, ( double )pX, ( double )pY, ( double )pZ, uniformTex ? uniformTex : getTexture( tt, level, pX, pY, pZ, 1 ) );
+	}
+	if ( faceFlags & 0x04 )
+	{
+		if ( blsmooth > 0 )
+		{
+			if ( tileShapeZ0 <= 0 ) pZ--;		// 4J - condition brought forward from 1.2.3
+			llx0z = getShadeBrightness(tt, level, pX - 1, pY, pZ );
+			ll0yz = getShadeBrightness(tt, level, pX, pY - 1, pZ );
+			ll0Yz = getShadeBrightness(tt, level, pX, pY + 1, pZ );
+			llX0z = getShadeBrightness(tt, level, pX + 1, pY, pZ );
+
+			ccx0z = getLightColor(tt,  level, pX - 1, pY, pZ );
+			cc0yz = getLightColor(tt,  level, pX, pY - 1, pZ );
+			cc0Yz = getLightColor(tt,  level, pX, pY + 1, pZ );
+			ccX0z = getLightColor(tt,  level, pX + 1, pY, pZ );
+
+			if ( llTransx0z || llTrans0yz )
+			{
+				llxyz = getShadeBrightness(tt, level, pX - 1, pY - 1, pZ );
+				ccxyz = getLightColor(tt,  level, pX - 1, pY - 1, pZ );
+			}
+			else
+			{
+				llxyz = llx0z;
+				ccxyz = ccx0z;
+			}
+			if ( llTransx0z || llTrans0Yz )
+			{
+				llxYz = getShadeBrightness(tt, level, pX - 1, pY + 1, pZ );
+				ccxYz = getLightColor(tt,  level, pX - 1, pY + 1, pZ );
+			}
+			else
+			{
+				llxYz = llx0z;
+				ccxYz = ccx0z;
+			}
+			if ( llTransX0z || llTrans0yz )
+			{
+				llXyz = getShadeBrightness(tt, level, pX + 1, pY - 1, pZ );
+				ccXyz = getLightColor(tt,  level, pX + 1, pY - 1, pZ );
+			}
+			else
+			{
+				llXyz = llX0z;
+				ccXyz = ccX0z;
+			}
+			if ( llTransX0z || llTrans0Yz )
+			{
+				llXYz = getShadeBrightness(tt, level, pX + 1, pY + 1, pZ );
+				ccXYz = getLightColor(tt,  level, pX + 1, pY + 1, pZ );
+			}
+			else
+			{
+				llXYz = llX0z;
+				ccXYz = ccX0z;
+			}
+			if ( tileShapeZ0 <= 0 ) pZ++;		// 4J - condition brought forward from 1.2.3
+
+			if (smoothShapeLighting && false) //minecraft->options->ambientOcclusion >= Options::AO_MAX)		// 4J - disabling AO_MAX until we work out exactly what its peformance implications are/what it fixes
+			{
+				float _ll1 = (llx0z + llxYz + ll00z + ll0Yz) / 4.0f;
+				float _ll2 = (ll00z + ll0Yz + llX0z + llXYz) / 4.0f;
+				float _ll3 = (ll0yz + ll00z + llXyz + llX0z) / 4.0f;
+				float _ll4 = (llxyz + llx0z + ll0yz + ll00z) / 4.0f;
+				ll1 = (float) (_ll1 * tileShapeY1 * (1.0 - tileShapeX0) + _ll2 * tileShapeY0 * tileShapeX0 + _ll3 * (1.0 - tileShapeY1) * tileShapeX0 + _ll4 * (1.0 - tileShapeY1)
+					* (1.0 - tileShapeX0));
+				ll2 = (float) (_ll1 * tileShapeY1 * (1.0 - tileShapeX1) + _ll2 * tileShapeY1 * tileShapeX1 + _ll3 * (1.0 - tileShapeY1) * tileShapeX1 + _ll4 * (1.0 - tileShapeY1)
+					* (1.0 - tileShapeX1));
+				ll3 = (float) (_ll1 * tileShapeY0 * (1.0 - tileShapeX1) + _ll2 * tileShapeY0 * tileShapeX1 + _ll3 * (1.0 - tileShapeY0) * tileShapeX1 + _ll4 * (1.0 - tileShapeY0)
+					* (1.0 - tileShapeX1));
+				ll4 = (float) (_ll1 * tileShapeY0 * (1.0 - tileShapeX0) + _ll2 * tileShapeY0 * tileShapeX0 + _ll3 * (1.0 - tileShapeY0) * tileShapeX0 + _ll4 * (1.0 - tileShapeY0)
+					* (1.0 - tileShapeX0));
+
+				int _tc1 = blend(ccx0z, ccxYz, cc0Yz, cc00z);
+				int _tc2 = blend(cc0Yz, ccX0z, ccXYz, cc00z);
+				int _tc3 = blend(cc0yz, ccXyz, ccX0z, cc00z);
+				int _tc4 = blend(ccxyz, ccx0z, cc0yz, cc00z);
+				tc1 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY1 * (1.0 - tileShapeX0), tileShapeY1 * tileShapeX0, (1.0 - tileShapeY1) * tileShapeX0, (1.0 - tileShapeY1) * (1.0 - tileShapeX0));
+				tc2 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY1 * (1.0 - tileShapeX1), tileShapeY1 * tileShapeX1, (1.0 - tileShapeY1) * tileShapeX1, (1.0 - tileShapeY1) * (1.0 - tileShapeX1));
+				tc3 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY0 * (1.0 - tileShapeX1), tileShapeY0 * tileShapeX1, (1.0 - tileShapeY0) * tileShapeX1, (1.0 - tileShapeY0) * (1.0 - tileShapeX1));
+				tc4 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY0 * (1.0 - tileShapeX0), tileShapeY0 * tileShapeX0, (1.0 - tileShapeY0) * tileShapeX0, (1.0 - tileShapeY0) * (1.0 - tileShapeX0));
+			} else {
+				ll1 = ( llx0z + llxYz + ll00z + ll0Yz ) / 4.0f;
+				ll2 = ( ll00z + ll0Yz + llX0z + llXYz ) / 4.0f;
+				ll3 = ( ll0yz + ll00z + llXyz + llX0z ) / 4.0f;
+				ll4 = ( llxyz + llx0z + ll0yz + ll00z ) / 4.0f;
+
+				tc1 = blend( ccx0z, ccxYz, cc0Yz, cc00z );
+				tc2 = blend( cc0Yz, ccX0z, ccXYz, cc00z );
+				tc3 = blend( cc0yz, ccXyz, ccX0z, cc00z );
+				tc4 = blend( ccxyz, ccx0z, cc0yz, cc00z );
+			}
+		}
+		else
+		{
+			ll1 = ll2 = ll3 = ll4 = ll00z;
+			tc1 = tc2 = tc3 = tc4 = cc00z;
+		}
+		c1r = c2r = c3r = c4r = ( tint2 ? pBaseRed : 1.0f ) * 0.8f;
+		c1g = c2g = c3g = c4g = ( tint2 ? pBaseGreen : 1.0f ) * 0.8f;
+		c1b = c2b = c3b = c4b = ( tint2 ? pBaseBlue : 1.0f ) * 0.8f;
+		c1r *= ll1;
+		c1g *= ll1;
+		c1b *= ll1;
+		c2r *= ll2;
+		c2g *= ll2;
+		c2b *= ll2;
+		c3r *= ll3;
+		c3g *= ll3;
+		c3b *= ll3;
+		c4r *= ll4;
+		c4g *= ll4;
+		c4b *= ll4;
+
+		Icon *tex = uniformTex ? uniformTex : getTexture(tt, level, pX, pY, pZ, 2);
+		renderNorth( tt, ( double )pX, ( double )pY, ( double )pZ, tex );
+
+		if ( fancy && (tex->getFlags() == Icon::IS_GRASS_SIDE) && !hasFixedTexture() )
+		{
+			c1r *= pBaseRed;
+			c2r *= pBaseRed;
+			c3r *= pBaseRed;
+			c4r *= pBaseRed;
+			c1g *= pBaseGreen;
+			c2g *= pBaseGreen;
+			c3g *= pBaseGreen;
+			c4g *= pBaseGreen;
+			c1b *= pBaseBlue;
+			c2b *= pBaseBlue;
+			c3b *= pBaseBlue;
+			c4b *= pBaseBlue;
+			bool prev = t->setMipmapEnable( false );	// 4J added - this is rendering the little bit of grass at the top of the side of dirt, don't mipmap it
+			renderNorth( tt, ( double )pX, ( double )pY, ( double )pZ, GrassTile::getSideTextureOverlay() );
+			t->setMipmapEnable( prev );
+		}
+	}
+	if ( faceFlags & 0x08 )
+	{
+		if ( blsmooth > 0 )
+		{
+			if ( tileShapeZ1 >= 1 ) pZ++;		// 4J - condition brought forward from 1.2.3
+
+			llx0Z = getShadeBrightness(tt, level, pX - 1, pY, pZ );
+			llX0Z = getShadeBrightness(tt, level, pX + 1, pY, pZ );
+			ll0yZ = getShadeBrightness(tt, level, pX, pY - 1, pZ );
+			ll0YZ = getShadeBrightness(tt, level, pX, pY + 1, pZ );
+
+			ccx0Z = getLightColor(tt,  level, pX - 1, pY, pZ );
+			ccX0Z = getLightColor(tt,  level, pX + 1, pY, pZ );
+			cc0yZ = getLightColor(tt,  level, pX, pY - 1, pZ );
+			cc0YZ = getLightColor(tt,  level, pX, pY + 1, pZ );
+
+			if ( llTransx0Z || llTrans0yZ )
+			{
+				llxyZ = getShadeBrightness(tt, level, pX - 1, pY - 1, pZ );
+				ccxyZ = getLightColor(tt,  level, pX - 1, pY - 1, pZ );
+			}
+			else
+			{
+				llxyZ = llx0Z;
+				ccxyZ = ccx0Z;
+			}
+			if ( llTransx0Z || llTrans0YZ )
+			{
+				llxYZ = getShadeBrightness(tt, level, pX - 1, pY + 1, pZ );
+				ccxYZ = getLightColor(tt,  level, pX - 1, pY + 1, pZ );
+			}
+			else
+			{
+				llxYZ = llx0Z;
+				ccxYZ = ccx0Z;
+			}
+			if ( llTransX0Z || llTrans0yZ )
+			{
+				llXyZ = getShadeBrightness(tt, level, pX + 1, pY - 1, pZ );
+				ccXyZ = getLightColor(tt,  level, pX + 1, pY - 1, pZ );
+			}
+			else
+			{
+				llXyZ = llX0Z;
+				ccXyZ = ccX0Z;
+			}
+			if ( llTransX0Z || llTrans0YZ )
+			{
+				llXYZ = getShadeBrightness(tt, level, pX + 1, pY + 1, pZ );
+				ccXYZ = getLightColor(tt,  level, pX + 1, pY + 1, pZ );
+			}
+			else
+			{
+				llXYZ = llX0Z;
+				ccXYZ = ccX0Z;
+			}
+			if ( tileShapeZ1 >= 1 ) pZ--;		// 4J - condition brought forward from 1.2.3
+			if (smoothShapeLighting && false)//minecraft->options->ambientOcclusion >= Options::AO_MAX)	// 4J - disabling AO_MAX until we work out exactly what its peformance implications are/what it fixes
+			{
+				float _ll1 = (llx0Z + llxYZ + ll00Z + ll0YZ) / 4.0f;
+				float _ll4 = (ll00Z + ll0YZ + llX0Z + llXYZ) / 4.0f;
+				float _ll3 = (ll0yZ + ll00Z + llXyZ + llX0Z) / 4.0f;
+				float _ll2 = (llxyZ + llx0Z + ll0yZ + ll00Z) / 4.0f;
+				ll1 = (float) (_ll1 * tileShapeY1 * (1.0 - tileShapeX0) + _ll4 * tileShapeY1 * tileShapeX0 + _ll3 * (1.0 - tileShapeY1) * tileShapeX0 + _ll2 * (1.0 - tileShapeY1)
+					* (1.0 - tileShapeX0));
+				ll2 = (float) (_ll1 * tileShapeY0 * (1.0 - tileShapeX0) + _ll4 * tileShapeY0 * tileShapeX0 + _ll3 * (1.0 - tileShapeY0) * tileShapeX0 + _ll2 * (1.0 - tileShapeY0)
+					* (1.0 - tileShapeX0));
+				ll3 = (float) (_ll1 * tileShapeY0 * (1.0 - tileShapeX1) + _ll4 * tileShapeY0 * tileShapeX1 + _ll3 * (1.0 - tileShapeY0) * tileShapeX1 + _ll2 * (1.0 - tileShapeY0)
+					* (1.0 - tileShapeX1));
+				ll4 = (float) (_ll1 * tileShapeY1 * (1.0 - tileShapeX1) + _ll4 * tileShapeY1 * tileShapeX1 + _ll3 * (1.0 - tileShapeY1) * tileShapeX1 + _ll2 * (1.0 - tileShapeY1)
+					* (1.0 - tileShapeX1));
+
+				int _tc1 = blend(ccx0Z, ccxYZ, cc0YZ, cc00Z);
+				int _tc4 = blend(cc0YZ, ccX0Z, ccXYZ, cc00Z);
+				int _tc3 = blend(cc0yZ, ccXyZ, ccX0Z, cc00Z);
+				int _tc2 = blend(ccxyZ, ccx0Z, cc0yZ, cc00Z);
+				tc1 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY1 * (1.0 - tileShapeX0), (1.0 - tileShapeY1) * (1.0 - tileShapeX0), (1.0 - tileShapeY1) * tileShapeX0, tileShapeY1 * tileShapeX0);
+				tc2 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY0 * (1.0 - tileShapeX0), (1.0 - tileShapeY0) * (1.0 - tileShapeX0), (1.0 - tileShapeY0) * tileShapeX0, tileShapeY0 * tileShapeX0);
+				tc3 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY0 * (1.0 - tileShapeX1), (1.0 - tileShapeY0) * (1.0 - tileShapeX1), (1.0 - tileShapeY0) * tileShapeX1, tileShapeY0 * tileShapeX1);
+				tc4 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY1 * (1.0 - tileShapeX1), (1.0 - tileShapeY1) * (1.0 - tileShapeX1), (1.0 - tileShapeY1) * tileShapeX1, tileShapeY1 * tileShapeX1);
+			}
+			else
+			{
+				ll1 = ( llx0Z + llxYZ + ll00Z + ll0YZ ) / 4.0f;
+				ll4 = ( ll00Z + ll0YZ + llX0Z + llXYZ ) / 4.0f;
+				ll3 = ( ll0yZ + ll00Z + llXyZ + llX0Z ) / 4.0f;
+				ll2 = ( llxyZ + llx0Z + ll0yZ + ll00Z ) / 4.0f;
+
+				tc1 = blend( ccx0Z, ccxYZ, cc0YZ, cc00Z );
+				tc4 = blend( cc0YZ, ccX0Z, ccXYZ, cc00Z );
+				tc3 = blend( cc0yZ, ccXyZ, ccX0Z, cc00Z );
+				tc2 = blend( ccxyZ, ccx0Z, cc0yZ, cc00Z );
+			}
+		}
+		else
+		{
+			ll1 = ll2 = ll3 = ll4 = ll00Z;
+			tc1 = tc2 = tc3 = tc4 = cc00Z;
+		}
+		c1r = c2r = c3r = c4r = ( tint3 ? pBaseRed : 1.0f ) * 0.8f;
+		c1g = c2g = c3g = c4g = ( tint3 ? pBaseGreen : 1.0f ) * 0.8f;
+		c1b = c2b = c3b = c4b = ( tint3 ? pBaseBlue : 1.0f ) * 0.8f;
+		c1r *= ll1;
+		c1g *= ll1;
+		c1b *= ll1;
+		c2r *= ll2;
+		c2g *= ll2;
+		c2b *= ll2;
+		c3r *= ll3;
+		c3g *= ll3;
+		c3b *= ll3;
+		c4r *= ll4;
+		c4g *= ll4;
+		c4b *= ll4;
+		Icon *tex = uniformTex ? uniformTex : getTexture(tt, level, pX, pY, pZ, 3);
+		renderSouth( tt, ( double )pX, ( double )pY, ( double )pZ, tex );
+		if ( fancy && (tex->getFlags() == Icon::IS_GRASS_SIDE) && !hasFixedTexture() )
+		{
+			c1r *= pBaseRed;
+			c2r *= pBaseRed;
+			c3r *= pBaseRed;
+			c4r *= pBaseRed;
+			c1g *= pBaseGreen;
+			c2g *= pBaseGreen;
+			c3g *= pBaseGreen;
+			c4g *= pBaseGreen;
+			c1b *= pBaseBlue;
+			c2b *= pBaseBlue;
+			c3b *= pBaseBlue;
+			c4b *= pBaseBlue;
+			bool prev = t->setMipmapEnable( false );	// 4J added - this is rendering the little bit of grass at the top of the side of dirt, don't mipmap it
+			renderSouth( tt, ( double )pX, ( double )pY, ( double )pZ, GrassTile::getSideTextureOverlay() );
+			t->setMipmapEnable( prev );
+		}
+	}
+	if ( faceFlags & 0x10 )
+	{
+		if ( blsmooth > 0 )
+		{
+			if ( tileShapeX0 <= 0 ) pX--;		// 4J - condition brought forward from 1.2.3
+			llxy0 = getShadeBrightness(tt, level, pX, pY - 1, pZ );
+			llx0z = getShadeBrightness(tt, level, pX, pY, pZ - 1 );
+			llx0Z = getShadeBrightness(tt, level, pX, pY, pZ + 1 );
+			llxY0 = getShadeBrightness(tt, level, pX, pY + 1, pZ );
+
+			ccxy0 = getLightColor(tt,  level, pX, pY - 1, pZ );
+			ccx0z = getLightColor(tt,  level, pX, pY, pZ - 1 );
+			ccx0Z = getLightColor(tt,  level, pX, pY, pZ + 1 );
+			ccxY0 = getLightColor(tt,  level, pX, pY + 1, pZ );
+
+			if ( llTransx0z || llTransxy0 )
+			{
+				llxyz = getShadeBrightness(tt, level, pX, pY - 1, pZ - 1 );
+				ccxyz = getLightColor(tt,  level, pX, pY - 1, pZ - 1 );
+			}
+			else
+			{
+				llxyz = llx0z;
+				ccxyz = ccx0z;
+			}
+			if ( llTransx0Z || llTransxy0 )
+			{
+				llxyZ = getShadeBrightness(tt, level, pX, pY - 1, pZ + 1 );
+				ccxyZ = getLightColor(tt,  level, pX, pY - 1, pZ + 1 );
+			}
+			else
+			{
+				llxyZ = llx0Z;
+				ccxyZ = ccx0Z;
+			}
+			if ( llTransx0z || llTransxY0 )
+			{
+				llxYz = getShadeBrightness(tt, level, pX, pY + 1, pZ - 1 );
+				ccxYz = getLightColor(tt,  level, pX, pY + 1, pZ - 1 );
+			}
+			else
+			{
+				llxYz = llx0z;
+				ccxYz = ccx0z;
+			}
+			if ( llTransx0Z || llTransxY0 )
+			{
+				llxYZ = getShadeBrightness(tt, level, pX, pY + 1, pZ + 1 );
+				ccxYZ = getLightColor(tt,  level, pX, pY + 1, pZ + 1 );
+			}
+			else
+			{
+				llxYZ = llx0Z;
+				ccxYZ = ccx0Z;
+			}
+			if ( tileShapeX0 <= 0 ) pX++;		// 4J - condition brought forward from 1.2.3
+			if (smoothShapeLighting && false)//minecraft->options->ambientOcclusion >= Options::AO_MAX) // 4J - disabling AO_MAX until we work out exactly what its peformance implications are/what it fixes
+			{
+				float _ll4 = (llxy0 + llxyZ + llx00 + llx0Z) / 4.0f;
+				float _ll1 = (llx00 + llx0Z + llxY0 + llxYZ) / 4.0f;
+				float _ll2 = (llx0z + llx00 + llxYz + llxY0) / 4.0f;
+				float _ll3 = (llxyz + llxy0 + llx0z + llx00) / 4.0f;
+				ll1 = (float) (_ll1 * tileShapeY1 * tileShapeZ1 + _ll2 * tileShapeY1 * (1.0 - tileShapeZ1) + _ll3 * (1.0 - tileShapeY1) * (1.0 - tileShapeZ1) + _ll4 * (1.0 - tileShapeY1)
+					* tileShapeZ1);
+				ll2 = (float) (_ll1 * tileShapeY1 * tileShapeZ0 + _ll2 * tileShapeY1 * (1.0 - tileShapeZ0) + _ll3 * (1.0 - tileShapeY1) * (1.0 - tileShapeZ0) + _ll4 * (1.0 - tileShapeY1)
+					* tileShapeZ0);
+				ll3 = (float) (_ll1 * tileShapeY0 * tileShapeZ0 + _ll2 * tileShapeY0 * (1.0 - tileShapeZ0) + _ll3 * (1.0 - tileShapeY0) * (1.0 - tileShapeZ0) + _ll4 * (1.0 - tileShapeY0)
+					* tileShapeZ0);
+				ll4 = (float) (_ll1 * tileShapeY0 * tileShapeZ1 + _ll2 * tileShapeY0 * (1.0 - tileShapeZ1) + _ll3 * (1.0 - tileShapeY0) * (1.0 - tileShapeZ1) + _ll4 * (1.0 - tileShapeY0)
+					* tileShapeZ1);
+
+				int _tc4 = blend(ccxy0, ccxyZ, ccx0Z, ccx00);
+				int _tc1 = blend(ccx0Z, ccxY0, ccxYZ, ccx00);
+				int _tc2 = blend(ccx0z, ccxYz, ccxY0, ccx00);
+				int _tc3 = blend(ccxyz, ccxy0, ccx0z, ccx00);
+				tc1 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY1 * tileShapeZ1, tileShapeY1 * (1.0 - tileShapeZ1), (1.0 - tileShapeY1) * (1.0 - tileShapeZ1), (1.0 - tileShapeY1) * tileShapeZ1);
+				tc2 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY1 * tileShapeZ0, tileShapeY1 * (1.0 - tileShapeZ0), (1.0 - tileShapeY1) * (1.0 - tileShapeZ0), (1.0 - tileShapeY1) * tileShapeZ0);
+				tc3 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY0 * tileShapeZ0, tileShapeY0 * (1.0 - tileShapeZ0), (1.0 - tileShapeY0) * (1.0 - tileShapeZ0), (1.0 - tileShapeY0) * tileShapeZ0);
+				tc4 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY0 * tileShapeZ1, tileShapeY0 * (1.0 - tileShapeZ1), (1.0 - tileShapeY0) * (1.0 - tileShapeZ1), (1.0 - tileShapeY0) * tileShapeZ1);
+			}
+			else
+			{
+				ll4 = ( llxy0 + llxyZ + llx00 + llx0Z ) / 4.0f;
+				ll1 = ( llx00 + llx0Z + llxY0 + llxYZ ) / 4.0f;
+				ll2 = ( llx0z + llx00 + llxYz + llxY0 ) / 4.0f;
+				ll3 = ( llxyz + llxy0 + llx0z + llx00 ) / 4.0f;
+
+				tc4 = blend( ccxy0, ccxyZ, ccx0Z, ccx00 );
+				tc1 = blend( ccx0Z, ccxY0, ccxYZ, ccx00 );
+				tc2 = blend( ccx0z, ccxYz, ccxY0, ccx00 );
+				tc3 = blend( ccxyz, ccxy0, ccx0z, ccx00 );
+			}
+		}
+		else
+		{
+			ll1 = ll2 = ll3 = ll4 = llx00;
+			tc1 = tc2 = tc3 = tc4 = ccx00;
+		}
+		c1r = c2r = c3r = c4r = ( tint4 ? pBaseRed : 1.0f ) * 0.6f;
+		c1g = c2g = c3g = c4g = ( tint4 ? pBaseGreen : 1.0f ) * 0.6f;
+		c1b = c2b = c3b = c4b = ( tint4 ? pBaseBlue : 1.0f ) * 0.6f;
+		c1r *= ll1;
+		c1g *= ll1;
+		c1b *= ll1;
+		c2r *= ll2;
+		c2g *= ll2;
+		c2b *= ll2;
+		c3r *= ll3;
+		c3g *= ll3;
+		c3b *= ll3;
+		c4r *= ll4;
+		c4g *= ll4;
+		c4b *= ll4;
+		Icon *tex = uniformTex ? uniformTex : getTexture(tt, level, pX, pY, pZ, 4);
+		renderWest( tt, ( double )pX, ( double )pY, ( double )pZ, tex );
+		if ( fancy && (tex->getFlags() == Icon::IS_GRASS_SIDE) && !hasFixedTexture() )
+		{
+			c1r *= pBaseRed;
+			c2r *= pBaseRed;
+			c3r *= pBaseRed;
+			c4r *= pBaseRed;
+			c1g *= pBaseGreen;
+			c2g *= pBaseGreen;
+			c3g *= pBaseGreen;
+			c4g *= pBaseGreen;
+			c1b *= pBaseBlue;
+			c2b *= pBaseBlue;
+			c3b *= pBaseBlue;
+			c4b *= pBaseBlue;
+			bool prev = t->setMipmapEnable( false );	// 4J added - this is rendering the little bit of grass at the top of the side of dirt, don't mipmap it
+			renderWest( tt, ( double )pX, ( double )pY, ( double )pZ, GrassTile::getSideTextureOverlay() );
+			t->setMipmapEnable( prev );
+		}
+	}
+	if ( faceFlags & 0x20 )
+	{
+		if ( blsmooth > 0 )
+		{
+			if ( tileShapeX1 >= 1 ) pX++;		// 4J - condition brought forward from 1.2.3
+			llXy0 = getShadeBrightness(tt, level, pX, pY - 1, pZ );
+			llX0z = getShadeBrightness(tt, level, pX, pY, pZ - 1 );
+			llX0Z = getShadeBrightness(tt, level, pX, pY, pZ + 1 );
+			llXY0 = getShadeBrightness(tt, level, pX, pY + 1, pZ );
+
+			ccXy0 = getLightColor(tt,  level, pX, pY - 1, pZ );
+			ccX0z = getLightColor(tt,  level, pX, pY, pZ - 1 );
+			ccX0Z = getLightColor(tt,  level, pX, pY, pZ + 1 );
+			ccXY0 = getLightColor(tt,  level, pX, pY + 1, pZ );
+
+			if ( llTransXy0 || llTransX0z )
+			{
+				llXyz = getShadeBrightness(tt, level, pX, pY - 1, pZ - 1 );
+				ccXyz = getLightColor(tt,  level, pX, pY - 1, pZ - 1 );
+			}
+			else
+			{
+				llXyz = llX0z;
+				ccXyz = ccX0z;
+			}
+			if ( llTransXy0 || llTransX0Z )
+			{
+				llXyZ = getShadeBrightness(tt, level, pX, pY - 1, pZ + 1 );
+				ccXyZ = getLightColor(tt,  level, pX, pY - 1, pZ + 1 );
+			}
+			else
+			{
+				llXyZ = llX0Z;
+				ccXyZ = ccX0Z;
+			}
+			if ( llTransXY0 || llTransX0z )
+			{
+				llXYz = getShadeBrightness(tt, level, pX, pY + 1, pZ - 1 );
+				ccXYz = getLightColor(tt,  level, pX, pY + 1, pZ - 1 );
+			}
+			else
+			{
+				llXYz = llX0z;
+				ccXYz = ccX0z;
+			}
+			if ( llTransXY0 || llTransX0Z )
+			{
+				llXYZ = getShadeBrightness(tt, level, pX, pY + 1, pZ + 1 );
+				ccXYZ = getLightColor(tt,  level, pX, pY + 1, pZ + 1 );
+			}
+			else
+			{
+				llXYZ = llX0Z;
+				ccXYZ = ccX0Z;
+			}
+			if ( tileShapeX1 >= 1 ) pX--;		// 4J - condition brought forward from 1.2.3
+			if (smoothShapeLighting && false)//minecraft->options->ambientOcclusion >= Options::AO_MAX) // 4J - disabling AO_MAX until we work out exactly what its peformance implications are/what it fixes
+			{
+				float _ll1 = (llXy0 + llXyZ + llX00 + llX0Z) / 4.0f;
+				float _ll2 = (llXyz + llXy0 + llX0z + llX00) / 4.0f;
+				float _ll3 = (llX0z + llX00 + llXYz + llXY0) / 4.0f;
+				float _ll4 = (llX00 + llX0Z + llXY0 + llXYZ) / 4.0f;
+				ll1 = (float) (_ll1 * (1.0 - tileShapeY0) * tileShapeZ1 + _ll2 * (1.0 - tileShapeY0) * (1.0 - tileShapeZ1) + _ll3 * tileShapeY0 * (1.0 - tileShapeZ1) + _ll4 * tileShapeY0
+					* tileShapeZ1);
+				ll2 = (float) (_ll1 * (1.0 - tileShapeY0) * tileShapeZ0 + _ll2 * (1.0 - tileShapeY0) * (1.0 - tileShapeZ0) + _ll3 * tileShapeY0 * (1.0 - tileShapeZ0) + _ll4 * tileShapeY0
+					* tileShapeZ0);
+				ll3 = (float) (_ll1 * (1.0 - tileShapeY1) * tileShapeZ0 + _ll2 * (1.0 - tileShapeY1) * (1.0 - tileShapeZ0) + _ll3 * tileShapeY1 * (1.0 - tileShapeZ0) + _ll4 * tileShapeY1
+					* tileShapeZ0);
+				ll4 = (float) (_ll1 * (1.0 - tileShapeY1) * tileShapeZ1 + _ll2 * (1.0 - tileShapeY1) * (1.0 - tileShapeZ1) + _ll3 * tileShapeY1 * (1.0 - tileShapeZ1) + _ll4 * tileShapeY1
+					* tileShapeZ1);
+
+				int _tc1 = blend(ccXy0, ccXyZ, ccX0Z, ccX00);
+				int _tc4 = blend(ccX0Z, ccXY0, ccXYZ, ccX00);
+				int _tc3 = blend(ccX0z, ccXYz, ccXY0, ccX00);
+				int _tc2 = blend(ccXyz, ccXy0, ccX0z, ccX00);
+				tc1 = blend(_tc1, _tc2, _tc3, _tc4, (1.0 - tileShapeY0) * tileShapeZ1, (1.0 - tileShapeY0) * (1.0 - tileShapeZ1), tileShapeY0 * (1.0 - tileShapeZ1), tileShapeY0 * tileShapeZ1);
+				tc2 = blend(_tc1, _tc2, _tc3, _tc4, (1.0 - tileShapeY0) * tileShapeZ0, (1.0 - tileShapeY0) * (1.0 - tileShapeZ0), tileShapeY0 * (1.0 - tileShapeZ0), tileShapeY0 * tileShapeZ0);
+				tc3 = blend(_tc1, _tc2, _tc3, _tc4, (1.0 - tileShapeY1) * tileShapeZ0, (1.0 - tileShapeY1) * (1.0 - tileShapeZ0), tileShapeY1 * (1.0 - tileShapeZ0), tileShapeY1 * tileShapeZ0);
+				tc4 = blend(_tc1, _tc2, _tc3, _tc4, (1.0 - tileShapeY1) * tileShapeZ1, (1.0 - tileShapeY1) * (1.0 - tileShapeZ1), tileShapeY1 * (1.0 - tileShapeZ1), tileShapeY1 * tileShapeZ1);
+			}
+			else
+			{
+				ll1 = (llXy0 + llXyZ + llX00 + llX0Z) / 4.0f;
+				ll2 = (llXyz + llXy0 + llX0z + llX00) / 4.0f;
+				ll3 = (llX0z + llX00 + llXYz + llXY0) / 4.0f;
+				ll4 = (llX00 + llX0Z + llXY0 + llXYZ) / 4.0f;
+
+				tc1 = blend(ccXy0, ccXyZ, ccX0Z, ccX00);
+				tc4 = blend(ccX0Z, ccXY0, ccXYZ, ccX00);
+				tc3 = blend(ccX0z, ccXYz, ccXY0, ccX00);
+				tc2 = blend(ccXyz, ccXy0, ccX0z, ccX00);
+			}
+		}
+		else
+		{
+			ll1 = ll2 = ll3 = ll4 = llX00;
+			tc1 = tc2 = tc3 = tc4 = ccX00;
+		}
+		c1r = c2r = c3r = c4r = ( tint5 ? pBaseRed : 1.0f ) * 0.6f;
+		c1g = c2g = c3g = c4g = ( tint5 ? pBaseGreen : 1.0f ) * 0.6f;
+		c1b = c2b = c3b = c4b = ( tint5 ? pBaseBlue : 1.0f ) * 0.6f;
+		c1r *= ll1;
+		c1g *= ll1;
+		c1b *= ll1;
+		c2r *= ll2;
+		c2g *= ll2;
+		c2b *= ll2;
+		c3r *= ll3;
+		c3g *= ll3;
+		c3b *= ll3;
+		c4r *= ll4;
+		c4g *= ll4;
+		c4b *= ll4;
+
+		Icon *tex = uniformTex ? uniformTex : getTexture(tt, level, pX, pY, pZ, 5);
+		renderEast( tt, ( double )pX, ( double )pY, ( double )pZ, tex );
+		if ( fancy && (tex->getFlags() == Icon::IS_GRASS_SIDE) && !hasFixedTexture())
+		{
+			c1r *= pBaseRed;
+			c2r *= pBaseRed;
+			c3r *= pBaseRed;
+			c4r *= pBaseRed;
+			c1g *= pBaseGreen;
+			c2g *= pBaseGreen;
+			c3g *= pBaseGreen;
+			c4g *= pBaseGreen;
+			c1b *= pBaseBlue;
+			c2b *= pBaseBlue;
+			c3b *= pBaseBlue;
+			c4b *= pBaseBlue;
+
+			bool prev = t->setMipmapEnable( false );	// 4J added - this is rendering the little bit of grass at the top of the side of dirt, don't mipmap it
+			renderEast( tt, ( double )pX, ( double )pY, ( double )pZ, GrassTile::getSideTextureOverlay() );
+			t->setMipmapEnable( prev );
+		}
+	}
+	applyAmbienceOcclusion = false;
+
+	return true;
+
+}
+
+// 4J - brought forward from 1.8.2
+int TileRenderer::blend( int a, int b, int c, int def )
+{
+	if ( a == 0 ) a = def;
+	if ( b == 0 ) b = def;
+	if ( c == 0 ) c = def;
+	return ( ( a + b + c + def ) >> 2 ) & 0xff00ff;
+}
+
+int TileRenderer::blend(int a, int b, int c, int d, double fa, double fb, double fc, double fd)
+{
+
+	int top = (int) ((double) ((a >> 16) & 0xff) * fa + (double) ((b >> 16) & 0xff) * fb + (double) ((c >> 16) & 0xff) * fc + (double) ((d >> 16) & 0xff) * fd) & 0xff;
+	int bottom = (int) ((double) (a & 0xff) * fa + (double) (b & 0xff) * fb + (double) (c & 0xff) * fc + (double) (d & 0xff) * fd) & 0xff;
+	return (top << 16) | bottom;
+}
+
+bool TileRenderer::tesselateBlockInWorld( Tile* tt, int x, int y, int z, float r, float g, float b )
+{
+	applyAmbienceOcclusion = false;
+
+	Tesselator* t = Tesselator::getInstance();
+
+	bool		changed = false;
+	float		c10 = 0.5f;
+	float		c11 = 1;
+	float		c2 = 0.8f;
+	float		c3 = 0.6f;
+
+	float		r11 = c11 * r;
+	float		g11 = c11 * g;
+	float		b11 = c11 * b;
+
+	float		r10 = c10;
+	float		r2 = c2;
+	float		r3 = c3;
+
+	float		g10 = c10;
+	float		g2 = c2;
+	float		g3 = c3;
+
+	float		b10 = c10;
+	float		b2 = c2;
+	float		b3 = c3;
+
+	if ( tt != Tile::grass )
+	{
+		r10 *= r;
+		r2 *= r;
+		r3 *= r;
+
+		g10 *= g;
+		g2 *= g;
+		g3 *= g;
+
+		b10 *= b;
+		b2 *= b;
+		b3 *= b;
+	}
+
+	int			centerColor = 0;
+	float		centerBrightness = 0.0f;
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		centerColor = getLightColor(tt,  level, x, y, z );
+	}
+	else
+	{
+		centerBrightness = tt->getBrightness( level, x, y, z );
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x, y - 1, z, Facing::DOWN ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeY0 > 0 ? centerColor : getLightColor(tt,  level, x, y - 1, z ) );
+			t->color( r10, g10, b10 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y - 1, z );
+			t->color( r10 * br, g10 * br, b10 * br );
+		}
+		renderFaceDown( tt, x, y, z, getTexture(tt, level, x, y, z, 0 ) );
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x, y + 1, z, Facing::UP ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeY1 < 1 ? centerColor : getLightColor(tt,  level, x, y + 1, z ) );
+			t->color( r11, g11, b11 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y + 1, z );
+			if ( tileShapeY1 != 1 && !tt->material->isLiquid() ) br = centerBrightness;
+			t->color( r11 * br, g11 * br, b11 * br );
+		}
+		renderFaceUp( tt, x, y, z, getTexture(tt, level, x, y, z, 1 ) );
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x, y, z - 1, Facing::NORTH ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ0 > 0 ? centerColor : getLightColor(tt,  level, x, y, z - 1 ) );
+			t->color( r2, g2, b2 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y, z - 1 );
+			if ( tileShapeZ0 > 0 ) br = centerBrightness;
+			t->color( r2 * br, g2 * br, b2 * br );
+		}
+
+		Icon *tex = getTexture(tt, level, x, y, z, 2);
+		renderNorth( tt, x, y, z, tex );
+		if ( fancy && (tex->getFlags() == Icon::IS_GRASS_SIDE) && !hasFixedTexture() )
+		{
+			t->color( r2 * r, g2 * g, b2 * b );
+			renderNorth( tt, x, y, z, GrassTile::getSideTextureOverlay() );
+		}
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x, y, z + 1, Facing::SOUTH ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ1 < 1 ? centerColor : getLightColor(tt,  level, x, y, z + 1 ) );
+			t->color( r2, g2, b2 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y, z + 1 );
+			if ( tileShapeZ1 < 1 ) br = centerBrightness;
+			t->color( r2 * br, g2 * br, b2 * br );
+		}
+		Icon *tex = getTexture(tt, level, x, y, z, 3);
+		renderSouth( tt, x, y, z, tex );
+		if ( fancy && (tex->getFlags() == Icon::IS_GRASS_SIDE) && !hasFixedTexture() )
+		{
+			t->color( r2 * r, g2 * g, b2 * b );
+			renderSouth( tt, x, y, z, GrassTile::getSideTextureOverlay() );
+		}
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x - 1, y, z, Facing::WEST ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeX0 > 0 ? centerColor : getLightColor(tt,  level, x - 1, y, z ) );
+			t->color( r3, g3, b3 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x - 1, y, z );
+			if ( tileShapeX0 > 0 ) br = centerBrightness;
+			t->color( r3 * br, g3 * br, b3 * br );
+		}
+		Icon *tex = getTexture(tt, level, x, y, z, 4);
+		renderWest( tt, x, y, z, tex );
+		if ( fancy && (tex->getFlags() == Icon::IS_GRASS_SIDE) && !hasFixedTexture() )
+		{
+			t->color( r3 * r, g3 * g, b3 * b );
+			renderWest( tt, x, y, z, GrassTile::getSideTextureOverlay() );
+		}
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x + 1, y, z, Facing::EAST ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeX1 < 1 ? centerColor : getLightColor(tt,  level, x + 1, y, z ) );
+			t->color( r3, g3, b3 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x + 1, y, z );
+			if ( tileShapeX1 < 1 ) br = centerBrightness;
+			t->color( r3 * br, g3 * br, b3 * br );
+		}
+		Icon *tex = getTexture(tt, level, x, y, z, 5);
+		renderEast( tt, x, y, z, tex );
+		if ( fancy && (tex->getFlags() == Icon::IS_GRASS_SIDE) && !hasFixedTexture() )
+		{
+			t->color( r3 * r, g3 * g, b3 * b );
+			renderEast( tt, x, y, z, GrassTile::getSideTextureOverlay() );
+		}
+		changed = true;
+	}
+
+	return changed;
+
+}
+
+bool TileRenderer::tesselateCactusInWorld( Tile* tt, int x, int y, int z )
+{
+	int		col = tt->getColor( level, x, y, z );
+	float	r = ( ( col >> 16 ) & 0xff ) / 255.0f;
+	float	g = ( ( col >> 8 ) & 0xff ) / 255.0f;
+	float	b = ( ( col )& 0xff ) / 255.0f;
+
+	if ( GameRenderer::anaglyph3d )
+	{
+		float	cr = ( r * 30 + g * 59 + b * 11 ) / 100;
+		float	cg = ( r * 30 + g * 70 ) / ( 100 );
+		float	cb = ( r * 30 + b * 70 ) / ( 100 );
+
+		r = cr;
+		g = cg;
+		b = cb;
+	}
+
+	return tesselateCactusInWorld( tt, x, y, z, r, g, b );
+}
+
+bool TileRenderer::tesselateCactusInWorld( Tile* tt, int x, int y, int z, float r, float g, float b )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	bool		changed = false;
+	float		c10 = 0.5f;
+	float		c11 = 1;
+	float		c2 = 0.8f;
+	float		c3 = 0.6f;
+
+	float		r10 = c10 * r;
+	float		r11 = c11 * r;
+	float		r2 = c2 * r;
+	float		r3 = c3 * r;
+
+	float		g10 = c10 * g;
+	float		g11 = c11 * g;
+	float		g2 = c2 * g;
+	float		g3 = c3 * g;
+
+	float		b10 = c10 * b;
+	float		b11 = c11 * b;
+	float		b2 = c2 * b;
+	float		b3 = c3 * b;
+
+	float		s = 1 / 16.0f;
+
+	float		centerBrightness = 0.0f;
+	int			centerColor = 0;
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		centerColor = getLightColor(tt,  level, x, y, z );
+	}
+	else
+	{
+		centerBrightness = tt->getBrightness( level, x, y, z );
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x, y - 1, z, 0 ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeY0 > 0 ? centerColor : getLightColor(tt,  level, x, y - 1, z ) );
+			t->color( r10, g10, b10 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y - 1, z );
+			t->color( r10 * br, g10 * br, b10 * br );
+		}
+		renderFaceDown( tt, x, y, z, getTexture( tt, level, x, y, z, 0 ) );
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x, y + 1, z, 1 ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeY1 < 1 ? centerColor : getLightColor(tt,  level, x, y + 1, z ) );
+			t->color( r11, g11, b11 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y + 1, z );
+			if ( tileShapeY1 != 1 && !tt->material->isLiquid() ) br = centerBrightness;
+			t->color( r11 * br, g11 * br, b11 * br );
+		}
+		renderFaceUp( tt, x, y, z, getTexture( tt, level, x, y, z, 1 ) );
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x, y, z - 1, 2 ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ0 > 0 ? centerColor : getLightColor(tt,  level, x, y, z - 1 ) );
+			t->color( r2, g2, b2 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y, z - 1 );
+			if ( tileShapeZ0 > 0 ) br = centerBrightness;
+			t->color( r2 * br, g2 * br, b2 * br );
+		}
+		t->addOffset( 0, 0, s );
+		renderNorth( tt, x, y, z, getTexture(tt, level, x, y, z, 2 ) );
+		t->addOffset( 0, 0, -s );
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x, y, z + 1, 3 ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ1 < 1 ? centerColor : getLightColor(tt,  level, x, y, z + 1 ) );
+			t->color( r2, g2, b2 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y, z + 1 );
+			if ( tileShapeZ1 < 1 ) br = centerBrightness;
+			t->color( r2 * br, g2 * br, b2 * br );
+		}
+
+		t->addOffset( 0, 0, -s );
+		renderSouth( tt, x, y, z, getTexture(tt, level, x, y, z, 3 ) );
+		t->addOffset( 0, 0, s );
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x - 1, y, z, 4 ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeX0 > 0 ? centerColor : getLightColor(tt,  level, x - 1, y, z ) );
+			t->color( r3, g3, b3 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x - 1, y, z );
+			if ( tileShapeX0 > 0 ) br = centerBrightness;
+			t->color( r3 * br, g3 * br, b3 * br );
+		}
+		t->addOffset( s, 0, 0 );
+		renderWest( tt, x, y, z, getTexture(tt, level, x, y, z, 4 ) );
+		t->addOffset( -s, 0, 0 );
+		changed = true;
+	}
+
+	if ( noCulling || tt->shouldRenderFace( level, x + 1, y, z, 5 ) )
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeX1 < 1 ? centerColor : getLightColor(tt,  level, x + 1, y, z ) );
+			t->color( r3, g3, b3 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x + 1, y, z );
+			if ( tileShapeX1 < 1 ) br = centerBrightness;
+			t->color( r3 * br, g3 * br, b3 * br );
+		}
+		t->addOffset( -s, 0, 0 );
+		renderEast( tt, x, y, z, getTexture(tt, level, x, y, z, 5 ) );
+		t->addOffset( s, 0, 0 );
+		changed = true;
+	}
+
+	return changed;
+
+}
+
+bool TileRenderer::tesselateFenceInWorld( FenceTile* tt, int x, int y, int z )
+{
+	bool	changed = false;
+
+	float	a = 6 / 16.0f;
+	float	b = 10 / 16.0f;
+
+	setShape( a, 0, a, b, 1, b );
+	tesselateBlockInWorld( tt, x, y, z );
+	changed = true;
+
+	bool	vertical = false;
+	bool	horizontal = false;
+
+	if (tt->connectsTo(level, x - 1, y, z) || tt->connectsTo(level, x + 1, y, z)) vertical = true;
+	if (tt->connectsTo(level, x, y, z - 1) || tt->connectsTo(level, x, y, z + 1)) horizontal = true;
+
+	bool l = tt->connectsTo(level, x - 1, y, z);
+	bool r = tt->connectsTo(level, x + 1, y, z);
+	bool u = tt->connectsTo(level, x, y, z - 1);
+	bool d = tt->connectsTo(level, x, y, z + 1);
+
+	if ( !vertical && !horizontal ) vertical = true;
+
+	a = 7 / 16.0f;
+	b = 9 / 16.0f;
+	float	h0 = 12 / 16.0f;
+	float	h1 = 15 / 16.0f;
+
+	float	x0 = l ? 0 : a;
+	float	x1 = r ? 1 : b;
+	float	z0 = u ? 0 : a;
+	float	z1 = d ? 1 : b;
+	if ( vertical )
+	{
+		setShape( x0, h0, a, x1, h1, b );
+		tesselateBlockInWorld( tt, x, y, z );
+		changed = true;
+	}
+	if ( horizontal )
+	{
+		setShape( a, h0, z0, b, h1, z1 );
+		tesselateBlockInWorld( tt, x, y, z );
+		changed = true;
+	}
+
+	h0 = 6 / 16.0f;
+	h1 = 9 / 16.0f;
+	if ( vertical )
+	{
+		setShape( x0, h0, a, x1, h1, b );
+		tesselateBlockInWorld( tt, x, y, z );
+		changed = true;
+	}
+	if ( horizontal )
+	{
+		setShape( a, h0, z0, b, h1, z1 );
+		tesselateBlockInWorld( tt, x, y, z );
+		changed = true;
+	}
+
+	tt->updateShape(level, x, y, z);
+
+	return changed;
+}
+
+bool TileRenderer::tesselateWallInWorld(WallTile *tt, int x, int y, int z)
+{
+	bool w = tt->connectsTo(level, x - 1, y, z);
+	bool e = tt->connectsTo(level, x + 1, y, z);
+	bool n = tt->connectsTo(level, x, y, z - 1);
+	bool s = tt->connectsTo(level, x, y, z + 1);
+
+	bool vertical = (n && s && !w && !e);
+	bool horizontal = (!n && !s && w && e);
+	bool emptyAbove = level->isEmptyTile(x, y + 1, z);
+
+	if ((!vertical && !horizontal) || !emptyAbove)
+	{
+		// center post
+		setShape(.5f - WallTile::POST_WIDTH, 0, .5f - WallTile::POST_WIDTH, .5f + WallTile::POST_WIDTH, WallTile::POST_HEIGHT, .5f + WallTile::POST_WIDTH);
+		tesselateBlockInWorld(tt, x, y, z);
+
+		if (w)
+		{
+			setShape(0, 0, .5f - WallTile::WALL_WIDTH, .5f - WallTile::POST_WIDTH, WallTile::WALL_HEIGHT, .5f + WallTile::WALL_WIDTH);
+			tesselateBlockInWorld(tt, x, y, z);
+		}
+		if (e)
+		{
+			setShape(.5f + WallTile::POST_WIDTH, 0, .5f - WallTile::WALL_WIDTH, 1, WallTile::WALL_HEIGHT, .5f + WallTile::WALL_WIDTH);
+			tesselateBlockInWorld(tt, x, y, z);
+		}
+		if (n)
+		{
+			setShape(.5f - WallTile::WALL_WIDTH, 0, 0, .5f + WallTile::WALL_WIDTH, WallTile::WALL_HEIGHT, .5f - WallTile::POST_WIDTH);
+			tesselateBlockInWorld(tt, x, y, z);
+		}
+		if (s)
+		{
+			setShape(.5f - WallTile::WALL_WIDTH, 0, .5f + WallTile::POST_WIDTH, .5f + WallTile::WALL_WIDTH, WallTile::WALL_HEIGHT, 1);
+			tesselateBlockInWorld(tt, x, y, z);
+		}
+	}
+	else if (vertical)
+	{
+		// north-south wall
+		setShape(.5f - WallTile::WALL_WIDTH, 0, 0, .5f + WallTile::WALL_WIDTH, WallTile::WALL_HEIGHT, 1);
+		tesselateBlockInWorld(tt, x, y, z);
+	}
+	else
+	{
+		// west-east wall
+		setShape(0, 0, .5f - WallTile::WALL_WIDTH, 1, WallTile::WALL_HEIGHT, .5f + WallTile::WALL_WIDTH);
+		tesselateBlockInWorld(tt, x, y, z);
+	}
+
+	tt->updateShape(level, x, y, z);
+	return true;
+}
+
+bool TileRenderer::tesselateEggInWorld(EggTile *tt, int x, int y, int z)
+{
+    bool changed = false;
+
+    int y0 = 0;
+    for (int i = 0; i < 8; i++)
+	{
+        int ww = 0;
+        int hh = 1;
+        if (i == 0) ww = 2;
+        if (i == 1) ww = 3;
+        if (i == 2) ww = 4;
+        if (i == 3)
+		{
+            ww = 5;
+            hh = 2;
+        }
+        if (i == 4)
+		{
+            ww = 6;
+            hh = 3;
+        }
+        if (i == 5)
+		{
+            ww = 7;
+            hh = 5;
+        }
+        if (i == 6)
+		{
+            ww = 6;
+            hh = 2;
+        }
+        if (i == 7) ww = 3;
+        float w = ww / 16.0f;
+        float yy1 = 1 - (y0 / 16.0f);
+        float yy0 = 1 - ((y0 + hh) / 16.0f);
+        y0 += hh;
+        setShape(0.5f - w, yy0, 0.5f - w, 0.5f + w, yy1, 0.5f + w);
+        tesselateBlockInWorld(tt, x, y, z);
+    }
+    changed = true;
+
+    setShape(0, 0, 0, 1, 1, 1);
+
+    return changed;
+}
+
+bool TileRenderer::tesselateFenceGateInWorld(FenceGateTile *tt, int x, int y, int z)
+{
+    bool changed = true;
+
+    int data = level->getData(x, y, z);
+    bool isOpen = FenceGateTile::isOpen(data);
+    int direction = DirectionalTile::getDirection(data);
+
+    float h00 = 6 / 16.0f;
+    float h01 = 9 / 16.0f;
+    float h10 = 12 / 16.0f;
+    float h11 = 15 / 16.0f;
+    float h20 = 5 / 16.0f;
+    float h21 = 16 / 16.0f;
+
+	if (((direction == Direction::NORTH || direction == Direction::SOUTH) && level->getTile(x - 1, y, z) == Tile::cobbleWall_Id && level->getTile(x + 1, y, z) == Tile::cobbleWall_Id)
+		|| ((direction == Direction::EAST || direction == Direction::WEST) && level->getTile(x, y, z - 1) == Tile::cobbleWall_Id && level->getTile(x, y, z + 1) == Tile::cobbleWall_Id))
+	{
+		h00 -= 3.0f / 16.0f;
+		h01 -= 3.0f / 16.0f;
+		h10 -= 3.0f / 16.0f;
+		h11 -= 3.0f / 16.0f;
+		h20 -= 3.0f / 16.0f;
+		h21 -= 3.0f / 16.0f;
+	}
+
+	noCulling = true;
+
+    // edge sticks
+    if (direction == Direction::EAST || direction == Direction::WEST)
+	{
+		upFlip = FLIP_CW;
+        float x0 = 7 / 16.0f;
+        float x1 = 9 / 16.0f;
+        float z0 = 0 / 16.0f;
+        float z1 = 2 / 16.0f;
+        setShape(x0, h20, z0, x1, h21, z1);
+        tesselateBlockInWorld(tt, x, y, z);
+
+        z0 = 14 / 16.0f;
+        z1 = 16 / 16.0f;
+        setShape(x0, h20, z0, x1, h21, z1);
+        tesselateBlockInWorld(tt, x, y, z);
+		upFlip = FLIP_NONE;
+    }
+	else
+	{
+        float x0 = 0 / 16.0f;
+        float x1 = 2 / 16.0f;
+        float z0 = 7 / 16.0f;
+        float z1 = 9 / 16.0f;
+        setShape(x0, h20, z0, x1, h21, z1);
+        tesselateBlockInWorld(tt, x, y, z);
+
+        x0 = 14 / 16.0f;
+        x1 = 16 / 16.0f;
+        setShape(x0, h20, z0, x1, h21, z1);
+        tesselateBlockInWorld(tt, x, y, z);
+    }
+	if (isOpen)
+	{
+		if (direction == Direction::NORTH || direction == Direction::SOUTH)
+		{
+			upFlip = FLIP_CW;
+		}
+		if (direction == Direction::EAST)
+		{
+
+			const float z00 = 0 / 16.0f;
+			const float z01 = 2 / 16.0f;
+			const float z10 = 14 / 16.0f;
+			const float z11 = 16 / 16.0f;
+
+			const float x0 = 9 / 16.0f;
+			const float x1 = 13 / 16.0f;
+			const float x2 = 15 / 16.0f;
+
+			setShape(x1, h00, z00, x2, h11, z01);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x1, h00, z10, x2, h11, z11);
+			tesselateBlockInWorld(tt, x, y, z);
+
+			setShape(x0, h00, z00, x1, h01, z01);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x0, h00, z10, x1, h01, z11);
+			tesselateBlockInWorld(tt, x, y, z);
+
+			setShape(x0, h10, z00, x1, h11, z01);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x0, h10, z10, x1, h11, z11);
+			tesselateBlockInWorld(tt, x, y, z);
+		}
+		else if (direction == Direction::WEST)
+		{
+			const float z00 = 0 / 16.0f;
+			const float z01 = 2 / 16.0f;
+			const float z10 = 14 / 16.0f;
+			const float z11 = 16 / 16.0f;
+
+			const float x0 = 1 / 16.0f;
+			const float x1 = 3 / 16.0f;
+			const float x2 = 7 / 16.0f;
+
+			setShape(x0, h00, z00, x1, h11, z01);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x0, h00, z10, x1, h11, z11);
+			tesselateBlockInWorld(tt, x, y, z);
+
+			setShape(x1, h00, z00, x2, h01, z01);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x1, h00, z10, x2, h01, z11);
+			tesselateBlockInWorld(tt, x, y, z);
+
+			setShape(x1, h10, z00, x2, h11, z01);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x1, h10, z10, x2, h11, z11);
+			tesselateBlockInWorld(tt, x, y, z);
+		}
+		else if (direction == Direction::SOUTH)
+		{
+
+			const float x00 = 0 / 16.0f;
+			const float x01 = 2 / 16.0f;
+			const float x10 = 14 / 16.0f;
+			const float x11 = 16 / 16.0f;
+
+			const float z0 = 9 / 16.0f;
+			const float z1 = 13 / 16.0f;
+			const float z2 = 15 / 16.0f;
+
+			setShape(x00, h00, z1, x01, h11, z2);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x10, h00, z1, x11, h11, z2);
+			tesselateBlockInWorld(tt, x, y, z);
+
+			setShape(x00, h00, z0, x01, h01, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x10, h00, z0, x11, h01, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+
+		setShape(x00, h10, z0, x01, h11, z1);
+		tesselateBlockInWorld(tt, x, y, z);
+		setShape(x10, h10, z0, x11, h11, z1);
+		tesselateBlockInWorld(tt, x, y, z);
+		}
+		else if (direction == Direction::NORTH)
+		{
+			const float x00 = 0 / 16.0f;
+			const float x01 = 2 / 16.0f;
+			const float x10 = 14 / 16.0f;
+			const float x11 = 16 / 16.0f;
+
+			const float z0 = 1 / 16.0f;
+			const float z1 = 3 / 16.0f;
+			const float z2 = 7 / 16.0f;
+
+			setShape(x00, h00, z0, x01, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x10, h00, z0, x11, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+
+			setShape(x00, h00, z1, x01, h01, z2);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x10, h00, z1, x11, h01, z2);
+			tesselateBlockInWorld(tt, x, y, z);
+
+			setShape(x00, h10, z1, x01, h11, z2);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x10, h10, z1, x11, h11, z2);
+			tesselateBlockInWorld(tt, x, y, z);
+		}
+	}
+	else
+	{
+		if (direction == Direction::EAST || direction == Direction::WEST)
+		{
+			upFlip = FLIP_CW;
+			float x0 = 7 / 16.0f;
+			float x1 = 9 / 16.0f;
+			float z0 = 6 / 16.0f;
+			float z1 = 8 / 16.0f;
+			setShape(x0, h00, z0, x1, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			z0 = 8 / 16.0f;
+			z1 = 10 / 16.0f;
+			setShape(x0, h00, z0, x1, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			z0 = 10 / 16.0f;
+			z1 = 14 / 16.0f;
+			setShape(x0, h00, z0, x1, h01, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x0, h10, z0, x1, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			z0 = 2 / 16.0f;
+			z1 = 6 / 16.0f;
+			setShape(x0, h00, z0, x1, h01, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x0, h10, z0, x1, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+		}
+		else
+		{
+			float x0 = 6 / 16.0f;
+			float x1 = 8 / 16.0f;
+			float z0 = 7 / 16.0f;
+			float z1 = 9 / 16.0f;
+			setShape(x0, h00, z0, x1, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			x0 = 8 / 16.0f;
+			x1 = 10 / 16.0f;
+			setShape(x0, h00, z0, x1, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			x0 = 10 / 16.0f;
+			x1 = 14 / 16.0f;
+			setShape(x0, h00, z0, x1, h01, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x0, h10, z0, x1, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			x0 = 2 / 16.0f;
+			x1 = 6 / 16.0f;
+			setShape(x0, h00, z0, x1, h01, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+			setShape(x0, h10, z0, x1, h11, z1);
+			tesselateBlockInWorld(tt, x, y, z);
+
+		}
+	}
+	noCulling = false;
+        upFlip = FLIP_NONE;
+
+    setShape(0, 0, 0, 1, 1, 1);
+
+    return changed;
+}
+
+bool TileRenderer::tesselateStairsInWorld( StairTile* tt, int x, int y, int z )
+{
+	tt->setBaseShape(level, x, y, z);
+	setShape(tt);
+	tesselateBlockInWorld(tt, x, y, z);
+
+	bool checkInnerPiece = tt->setStepShape(level, x, y, z);
+	setShape(tt);
+	tesselateBlockInWorld(tt, x, y, z);
+
+	if (checkInnerPiece)
+	{
+		if (tt->setInnerPieceShape(level, x, y, z))
+		{
+			setShape(tt);
+			tesselateBlockInWorld(tt, x, y, z);
+		}
+	}
+	return true;
+}
+
+bool TileRenderer::tesselateDoorInWorld( Tile* tt, int x, int y, int z )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	// skip rendering if the other half of the door is missing,
+	// to avoid rendering doors that are about to be removed
+	int data = level->getData(x, y, z);
+	if ((data & DoorTile::UPPER_BIT) != 0)
+	{
+		if (level->getTile(x, y - 1, z) != tt->id)
+		{
+			return false;
+		}
+	}
+	else {
+		if (level->getTile(x, y + 1, z) != tt->id)
+		{
+			return false;
+		}
+	}
+
+	bool		changed = false;
+	float		c10 = 0.5f;
+	float		c11 = 1;
+	float		c2 = 0.8f;
+	float		c3 = 0.6f;
+
+	int			centerColor = 0;
+	float		centerBrightness = 0.0f;
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		centerColor = getLightColor(tt,  level, x, y, z );
+	}
+	else
+	{
+		centerBrightness = tt->getBrightness( level, x, y, z );
+	}
+
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( tileShapeY0 > 0 ? centerColor : getLightColor(tt,  level, x, y - 1, z ) );
+		t->color( c10, c10, c10 );
+	}
+	else
+	{
+		float br = tt->getBrightness( level, x, y - 1, z );
+		if ( tileShapeY0 > 0 ) br = centerBrightness;
+		if ( Tile::lightEmission[tt->id] > 0 ) br = 1.0f;
+		t->color( c10 * br, c10 * br, c10 * br );
+	}
+	renderFaceDown( tt, x, y, z, getTexture(tt, level, x, y, z, 0 ) );
+	changed = true;
+
+	if ( SharedConstants::TEXTURE_LIGHTING )
+	{
+		t->tex2( tileShapeY1 < 1 ? centerColor : getLightColor(tt,  level, x, y + 1, z ) );
+		t->color( c11, c11, c11 );
+	}
+	else
+	{
+		float br = tt->getBrightness( level, x, y + 1, z );
+		if ( tileShapeY1 < 1 ) br = centerBrightness;
+		if ( Tile::lightEmission[tt->id] > 0 ) br = 1.0f;
+		t->color( c11 * br, c11 * br, c11 * br );
+	}
+	renderFaceUp( tt, x, y, z, getTexture(tt,  level, x, y, z, 1 ) );
+	changed = true;
+
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ0 > 0 ? centerColor : getLightColor(tt,  level, x, y, z - 1 ) );
+			t->color( c2, c2, c2 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y, z - 1 );
+			if ( tileShapeZ0 > 0 ) br = centerBrightness;
+			if ( Tile::lightEmission[tt->id] > 0 ) br = 1.0f;
+			t->color( c2 * br, c2 * br, c2 * br );
+		}
+		Icon *tex = getTexture(tt, level, x, y, z, 2 );
+		renderNorth( tt, x, y, z, tex );
+		changed = true;
+		xFlipTexture = false;
+	}
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeZ1 < 1 ? centerColor : getLightColor(tt,  level, x, y, z + 1 ) );
+			t->color( c2, c2, c2 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x, y, z + 1 );
+			if ( tileShapeZ1 < 1 ) br = centerBrightness;
+			if ( Tile::lightEmission[tt->id] > 0 ) br = 1.0f;
+			t->color( c2 * br, c2 * br, c2 * br );
+		}
+		Icon *tex = getTexture( tt, level, x, y, z, 3 );
+		renderSouth( tt, x, y, z, tex );
+		changed = true;
+		xFlipTexture = false;
+	}
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeX0 > 0 ? centerColor : getLightColor(tt,  level, x - 1, y, z ) );
+			t->color( c3, c3, c3 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x - 1, y, z );
+			if ( tileShapeX0 > 0 ) br = centerBrightness;
+			if ( Tile::lightEmission[tt->id] > 0 ) br = 1.0f;
+			t->color( c3 * br, c3 * br, c3 * br );
+		}
+		Icon *tex = getTexture(tt, level, x, y, z, 4 );
+		renderWest( tt, x, y, z, tex );
+		changed = true;
+		xFlipTexture = false;
+	}
+	{
+		if ( SharedConstants::TEXTURE_LIGHTING )
+		{
+			t->tex2( tileShapeX1 < 1 ? centerColor : getLightColor(tt,  level, x + 1, y, z ) );
+			t->color( c3, c3, c3 );
+		}
+		else
+		{
+			float br = tt->getBrightness( level, x + 1, y, z );
+			if ( tileShapeX1 < 1 ) br = centerBrightness;
+			if ( Tile::lightEmission[tt->id] > 0 ) br = 1.0f;
+			t->color( c3 * br, c3 * br, c3 * br );
+		}
+		Icon *tex = getTexture(tt, level, x, y, z, 5 );
+		renderEast( tt, x, y, z, tex );
+		changed = true;
+		xFlipTexture = false;
+	}
+	return changed;
+}
+
+void TileRenderer::renderFaceDown( Tile* tt, double x, double y, double z, Icon *tex )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	float u00 = tex->getU(tileShapeX0 * 16.0f, true);
+	float u11 = tex->getU(tileShapeX1 * 16.0f, true);
+	float v00 = tex->getV(tileShapeZ0 * 16.0f, true);
+	float v11 = tex->getV(tileShapeZ1 * 16.0f, true);
+
+	if ( tileShapeX0 < 0 || tileShapeX1 > 1 )
+	{
+		u00 = tex->getU0(true);
+		u11 = tex->getU1(true);
+	}
+	if ( tileShapeZ0 < 0 || tileShapeZ1 > 1 )
+	{
+		v00 = tex->getV0(true);
+		v11 = tex->getV1(true);
+	}
+
+	double		u01 = u11, u10 = u00, v01 = v00, v10 = v11;
+	if ( downFlip == FLIP_CCW )
+	{
+		u00 = tex->getU(tileShapeZ0 * 16.0f, true);
+		v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f, true);
+		u11 = tex->getU(tileShapeZ1 * 16.0f, true);
+		v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u01 = u00;
+		u10 = u11;
+		v00 = v11;
+		v11 = v01;
+	}
+	else if ( downFlip == FLIP_CW )
+	{
+		// reshape
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f, true);
+		v00 = tex->getV(tileShapeX0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f, true);
+		v11 = tex->getV(tileShapeX1 * 16.0f, true);
+
+		// rotate
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u00 = u01;
+		u11 = u10;
+		v01 = v11;
+		v10 = v00;
+	}
+	else if ( downFlip == FLIP_180 )
+	{
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f, true);
+		v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f, true);
+		v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+	}
+
+	double x0 = x + tileShapeX0;
+	double x1 = x + tileShapeX1;
+	double y0 = y + tileShapeY0;
+	double z0 = z + tileShapeZ0;
+	double z1 = z + tileShapeZ1;
+
+	if ( applyAmbienceOcclusion )
+	{
+#ifdef __PSVITA__
+		if( t->getCompactVertices() )
+		{
+			t->tileQuad(( float )( x0 ), ( float )( y0 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ), c1r, c1g, c1b, tc1,
+						( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ), c2r, c2g, c2b, tc2,
+						( float )( x1 ), ( float )( y0 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ), c3r, c3g, c3b, tc3,
+						( float )( x1 ), ( float )( y0 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ), c4r, c4g, c4b, tc4);
+			return;
+		}
+#endif
+
+		t->color( c1r, c1g, c1b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc1 );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ) );
+		t->color( c2r, c2g, c2b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc2 );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ) );
+		t->color( c3r, c3g, c3b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc3 );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ) );
+		t->color( c4r, c4g, c4b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc4 );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ) );
+	}
+	else
+	{
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ) );
+	}
+}
+
+void TileRenderer::renderFaceUp( Tile* tt, double x, double y, double z, Icon *tex )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	float u00 = tex->getU(tileShapeX0 * 16.0f, true);
+	float u11 = tex->getU(tileShapeX1 * 16.0f, true);
+	float v00 = tex->getV(tileShapeZ0 * 16.0f, true);
+	float v11 = tex->getV(tileShapeZ1 * 16.0f, true);
+
+	if ( tileShapeX0 < 0 || tileShapeX1 > 1 )
+	{
+		u00 = tex->getU0(true);
+		u11 = tex->getU1(true);
+	}
+	if ( tileShapeZ0 < 0 || tileShapeZ1 > 1 )
+	{
+		v00 = tex->getV0(true);
+		v11 = tex->getV1(true);
+	}
+
+	float u01 = u11, u10 = u00, v01 = v00, v10 = v11;
+
+	if ( upFlip == FLIP_CW )
+	{
+		u00 = tex->getU(tileShapeZ0 * 16.0f, true);
+		v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f, true);
+		u11 = tex->getU(tileShapeZ1 * 16.0f, true);
+		v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u01 = u00;
+		u10 = u11;
+		v00 = v11;
+		v11 = v01;
+	}
+	else if ( upFlip == FLIP_CCW )
+	{
+		// reshape
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f, true);
+		v00 = tex->getV(tileShapeX0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f, true);
+		v11 = tex->getV(tileShapeX1 * 16.0f, true);
+
+		// rotate
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u00 = u01;
+		u11 = u10;
+		v01 = v11;
+		v10 = v00;
+	}
+	else if ( upFlip == FLIP_180 )
+	{
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f, true);
+		v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f, true);
+		v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+	}
+
+
+	double x0 = x + tileShapeX0;
+	double x1 = x + tileShapeX1;
+	double y1 = y + tileShapeY1;
+	double z0 = z + tileShapeZ0;
+	double z1 = z + tileShapeZ1;
+
+	if ( applyAmbienceOcclusion )
+	{
+#ifdef __PSVITA__
+		if( t->getCompactVertices() )
+		{
+			t->tileQuad(( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ), c1r, c1g, c1b, tc1,
+						( float )( x1 ), ( float )( y1 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ), c2r, c2g, c2b, tc2,
+						( float )( x0 ), ( float )( y1 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ), c3r, c3g, c3b, tc3,
+						( float )( x0 ), ( float )( y1 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ), c4r, c4g, c4b, tc4);
+			return;
+		}
+#endif
+
+		t->color( c1r, c1g, c1b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc1 );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ) );
+		t->color( c2r, c2g, c2b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc2 );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ) );
+		t->color( c3r, c3g, c3b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc3 );
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ) );
+		t->color( c4r, c4g, c4b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc4 );
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ) );
+	}
+	else
+	{
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ) );
+	}
+
+}
+
+void TileRenderer::renderNorth( Tile* tt, double x, double y, double z, Icon *tex )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	double u00 = tex->getU(tileShapeX0 * 16.0f, true);
+	double u11 = tex->getU(tileShapeX1 * 16.0f, true);
+	double v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f, true);
+	double v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f, true);
+	if ( xFlipTexture )
+	{
+		double tmp = u00;
+		u00 = u11;
+		u11 = tmp;
+	}
+
+	if ( tileShapeX0 < 0 || tileShapeX1 > 1 )
+	{
+		u00 = tex->getU0(true);
+		u11 = tex->getU1(true);
+	}
+	if ( tileShapeY0 < 0 || tileShapeY1 > 1 )
+	{
+		v00 = tex->getV0(true);
+		v11 = tex->getV1(true);
+	}
+
+	double		u01 = u11, u10 = u00, v01 = v00, v10 = v11;
+
+	if ( northFlip == FLIP_CCW )
+	{
+		u00 = tex->getU(tileShapeY0 * 16.0f, true);
+		v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f, true);
+		u11 = tex->getU(tileShapeY1 * 16.0f, true);
+		v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u01 = u00;
+		u10 = u11;
+		v00 = v11;
+		v11 = v01;
+	}
+	else if ( northFlip == FLIP_CW )
+	{
+		// reshape
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f, true);
+		v00 = tex->getV(tileShapeX1 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f, true);
+		v11 = tex->getV(tileShapeX0 * 16.0f, true);
+
+		// rotate
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u00 = u01;
+		u11 = u10;
+		v01 = v11;
+		v10 = v00;
+	}
+	else if ( northFlip == FLIP_180 )
+	{
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f, true);
+		v00 = tex->getV(tileShapeY1 * 16.0f, true);
+		v11 = tex->getV(tileShapeY0 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+	}
+
+
+	double x0 = x + tileShapeX0;
+	double x1 = x + tileShapeX1;
+	double y0 = y + tileShapeY0;
+	double y1 = y + tileShapeY1;
+	double z0 = z + tileShapeZ0;
+
+	if ( applyAmbienceOcclusion )
+	{
+#ifdef __PSVITA__
+		if( t->getCompactVertices() )
+		{
+			t->tileQuad(( float )( x0 ), ( float )( y1 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ), c1r, c1g, c1b, tc1,
+						( float )( x1 ), ( float )( y1 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ), c2r, c2g, c2b, tc2,
+						( float )( x1 ), ( float )( y0 ), ( float )( z0 ), ( float )( u10 ), ( float )( v10 ), c3r, c3g, c3b, tc3,
+						( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u11 ), ( float )( v11 ), c4r, c4g, c4b, tc4);
+			return;
+		}
+#endif
+
+		t->color( c1r, c1g, c1b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc1 );
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ) );
+		t->color( c2r, c2g, c2b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc2 );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ) );
+		t->color( c3r, c3g, c3b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc3 );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z0 ), ( float )( u10 ), ( float )( v10 ) );
+		t->color( c4r, c4g, c4b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc4 );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u11 ), ( float )( v11 ) );
+	}
+	else
+	{
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z0 ), ( float )( u10 ), ( float )( v10 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u11 ), ( float )( v11 ) );
+	}
+
+}
+
+void TileRenderer::renderSouth( Tile* tt, double x, double y, double z, Icon *tex )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	double u00 = tex->getU(tileShapeX0 * 16.0f, true);
+	double u11 = tex->getU(tileShapeX1 * 16.0f, true);
+	double v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f, true);
+	double v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f, true);
+	if ( xFlipTexture )
+	{
+		double tmp = u00;
+		u00 = u11;
+		u11 = tmp;
+	}
+
+	if ( tileShapeX0 < 0 || tileShapeX1 > 1 )
+	{
+		u00 = tex->getU0(true);
+		u11 = tex->getU1(true);
+	}
+	if ( tileShapeY0 < 0 || tileShapeY1 > 1 )
+	{
+		v00 = tex->getV0(true);
+		v11 = tex->getV1(true);
+	}
+
+	double		u01 = u11, u10 = u00, v01 = v00, v10 = v11;
+
+	if ( southFlip == FLIP_CW )
+	{
+		u00 = tex->getU(tileShapeY0 * 16.0f, true);
+		v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f, true);
+		u11 = tex->getU(tileShapeY1 * 16.0f, true);
+		v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u01 = u00;
+		u10 = u11;
+		v00 = v11;
+		v11 = v01;
+	}
+	else if ( southFlip == FLIP_CCW )
+	{
+		// reshape
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f, true);
+		v00 = tex->getV(tileShapeX0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f, true);
+		v11 = tex->getV(tileShapeX1 * 16.0f, true);
+
+		// rotate
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u00 = u01;
+		u11 = u10;
+		v01 = v11;
+		v10 = v00;
+	}
+	else if ( southFlip == FLIP_180 )
+	{
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f, true);
+		v00 = tex->getV(tileShapeY1 * 16.0f, true);
+		v11 = tex->getV(tileShapeY0 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+	}
+
+
+	double x0 = x + tileShapeX0;
+	double x1 = x + tileShapeX1;
+	double y0 = y + tileShapeY0;
+	double y1 = y + tileShapeY1;
+	double z1 = z + tileShapeZ1;
+
+	if ( applyAmbienceOcclusion )
+	{
+#ifdef __PSVITA__
+		if( t->getCompactVertices() )
+		{
+			t->tileQuad(( float )( x0 ), ( float )( y1 ), ( float )( z1 ), ( float )( u00 ), ( float )( v00 ), c1r, c1g, c1b, tc1,
+						( float )( x0 ), ( float )( y0 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ), c2r, c2g, c2b, tc2,
+						( float )( x1 ), ( float )( y0 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ), c3r, c3g, c3b, tc3,
+						( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u01 ), ( float )( v01 ), c4r, c4g, c4b, tc4);
+			return;
+		}
+#endif
+
+		t->color( c1r, c1g, c1b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc1 );
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z1 ), ( float )( u00 ), ( float )( v00 ) );
+		t->color( c2r, c2g, c2b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc2 );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ) );
+		t->color( c3r, c3g, c3b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc3 );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ) );
+		t->color( c4r, c4g, c4b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc4 );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u01 ), ( float )( v01 ) );
+	}
+	else
+	{
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z1 ), ( float )( u00 ), ( float )( v00 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u01 ), ( float )( v01 ) );
+	}
+
+}
+
+void TileRenderer::renderWest( Tile* tt, double x, double y, double z, Icon *tex )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	double u00 = tex->getU(tileShapeZ0 * 16.0f, true);
+	double u11 = tex->getU(tileShapeZ1 * 16.0f, true);
+	double v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f, true);
+	double v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f, true);
+	if ( xFlipTexture )
+	{
+		double tmp = u00;
+		u00 = u11;
+		u11 = tmp;
+	}
+
+	if ( tileShapeZ0 < 0 || tileShapeZ1 > 1 )
+	{
+		u00 = tex->getU0(true);
+		u11 = tex->getU1(true);
+	}
+	if ( tileShapeY0 < 0 || tileShapeY1 > 1 )
+	{
+		v00 = tex->getV0(true);
+		v11 = tex->getV1(true);
+	}
+
+	double		u01 = u11, u10 = u00, v01 = v00, v10 = v11;
+
+	if ( westFlip == FLIP_CW )
+	{
+		u00 = tex->getU(tileShapeY0 * 16.0f, true);
+		v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f, true);
+		u11 = tex->getU(tileShapeY1 * 16.0f, true);
+		v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u01 = u00;
+		u10 = u11;
+		v00 = v11;
+		v11 = v01;
+	}
+	else if ( westFlip == FLIP_CCW )
+	{
+		// reshape
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f, true);
+		v00 = tex->getV(tileShapeZ0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f, true);
+		v11 = tex->getV(tileShapeZ1 * 16.0f, true);
+
+		// rotate
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u00 = u01;
+		u11 = u10;
+		v01 = v11;
+		v10 = v00;
+	}
+	else if ( westFlip == FLIP_180 )
+	{
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f, true);
+		v00 = tex->getV(tileShapeY1 * 16.0f, true);
+		v11 = tex->getV(tileShapeY0 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+	}
+
+	double x0 = x + tileShapeX0;
+	double y0 = y + tileShapeY0;
+	double y1 = y + tileShapeY1;
+	double z0 = z + tileShapeZ0;
+	double z1 = z + tileShapeZ1;
+
+	if ( applyAmbienceOcclusion )
+	{
+#ifdef __PSVITA__
+		if( t->getCompactVertices() )
+		{
+			t->tileQuad(( float )( x0 ), ( float )( y1 ), ( float )( z1 ), ( float )( u01 ), ( float )( v01 ), c1r, c1g, c1b, tc1,
+						( float )( x0 ), ( float )( y1 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ), c2r, c2g, c2b, tc2,
+						( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u10 ), ( float )( v10 ), c3r, c3g, c3b, tc3,
+						( float )( x0 ), ( float )( y0 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ), c4r, c4g, c4b, tc4);
+			return;
+		}
+#endif
+
+		t->color( c1r, c1g, c1b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc1 );
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z1 ), ( float )( u01 ), ( float )( v01 ) );
+		t->color( c2r, c2g, c2b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc2 );
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ) );
+		t->color( c3r, c3g, c3b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc3 );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u10 ), ( float )( v10 ) );
+		t->color( c4r, c4g, c4b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc4 );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ) );
+	}
+	else
+	{
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z1 ), ( float )( u01 ), ( float )( v01 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y1 ), ( float )( z0 ), ( float )( u00 ), ( float )( v00 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z0 ), ( float )( u10 ), ( float )( v10 ) );
+		t->vertexUV( ( float )( x0 ), ( float )( y0 ), ( float )( z1 ), ( float )( u11 ), ( float )( v11 ) );
+	}
+
+}
+
+void TileRenderer::renderEast( Tile* tt, double x, double y, double z, Icon *tex )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	if (hasFixedTexture()) tex = fixedTexture;
+	double u00 = tex->getU(tileShapeZ0 * 16.0f, true);
+	double u11 = tex->getU(tileShapeZ1 * 16.0f, true);
+	double v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f, true);
+	double v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f, true);
+	if ( xFlipTexture )
+	{
+		double tmp = u00;
+		u00 = u11;
+		u11 = tmp;
+	}
+
+	if ( tileShapeZ0 < 0 || tileShapeZ1 > 1 )
+	{
+		u00 = tex->getU0(true);
+		u11 = tex->getU1(true);
+	}
+	if ( tileShapeY0 < 0 || tileShapeY1 > 1 )
+	{
+		v00 = tex->getV0(true);
+		v11 = tex->getV1(true);
+	}
+
+	double		u01 = u11, u10 = u00, v01 = v00, v10 = v11;
+
+	if ( eastFlip == FLIP_CCW )
+	{
+		u00 = tex->getU(tileShapeY0 * 16.0f, true);
+		v00 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f, true);
+		u11 = tex->getU(tileShapeY1 * 16.0f, true);
+		v11 = tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u01 = u00;
+		u10 = u11;
+		v00 = v11;
+		v11 = v01;
+	}
+	else if ( eastFlip == FLIP_CW )
+	{
+		// reshape
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f, true);
+		v00 = tex->getV(tileShapeZ1 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f, true);
+		v11 = tex->getV(tileShapeZ0 * 16.0f, true);
+
+		// rotate
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+		u00 = u01;
+		u11 = u10;
+		v01 = v11;
+		v10 = v00;
+	}
+	else if ( eastFlip == FLIP_180 )
+	{
+		u00 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f, true);
+		u11 = tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f, true);
+		v00 = tex->getV(tileShapeY1 * 16.0f, true);
+		v11 = tex->getV(tileShapeY0 * 16.0f, true);
+
+		u01 = u11;
+		u10 = u00;
+		v01 = v00;
+		v10 = v11;
+	}
+
+	double x1 = x + tileShapeX1;
+	double y0 = y + tileShapeY0;
+	double y1 = y + tileShapeY1;
+	double z0 = z + tileShapeZ0;
+	double z1 = z + tileShapeZ1;
+
+	if ( applyAmbienceOcclusion )
+	{
+#ifdef __PSVITA__
+		if( t->getCompactVertices() )
+		{
+			t->tileQuad(( float )( x1 ), ( float )( y0 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ), c1r, c1g, c1b, tc1,
+						( float )( x1 ), ( float )( y0 ), ( float )( z0 ), ( float )( u11 ), ( float )( v11 ), c2r, c2g, c2b, tc2,
+						( float )( x1 ), ( float )( y1 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ), c3r, c3g, c3b, tc3,
+						( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u00 ), ( float )( v00 ), c4r, c4g, c4b, tc4);
+			return;
+		}
+#endif
+
+		t->color( c1r, c1g, c1b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc1 );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ) );
+		t->color( c2r, c2g, c2b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc2 );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z0 ), ( float )( u11 ), ( float )( v11 ) );
+		t->color( c3r, c3g, c3b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc3 );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ) );
+		t->color( c4r, c4g, c4b );
+		if ( SharedConstants::TEXTURE_LIGHTING ) t->tex2( tc4 );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u00 ), ( float )( v00 ) );
+	}
+	else
+	{
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z1 ), ( float )( u10 ), ( float )( v10 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y0 ), ( float )( z0 ), ( float )( u11 ), ( float )( v11 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z0 ), ( float )( u01 ), ( float )( v01 ) );
+		t->vertexUV( ( float )( x1 ), ( float )( y1 ), ( float )( z1 ), ( float )( u00 ), ( float )( v00 ) );
+	}
+
+}
+
+void TileRenderer::renderCube( Tile* tile, float alpha )
+{
+	int			shape = tile->getRenderShape();
+	Tesselator* t = Tesselator::getInstance();
+
+	if ( shape == Tile::SHAPE_BLOCK )
+	{
+		tile->updateDefaultShape();
+		glTranslatef( -0.5f, -0.5f, -0.5f );
+		float	c10 = 0.5f;
+		float	c11 = 1;
+		float	c2 = 0.8f;
+		float	c3 = 0.6f;
+
+		t->begin();
+		t->color( c11, c11, c11, alpha );
+		renderFaceDown( tile, 0, 0, 0,getTexture(tile, 0 ) );
+		t->color( c10, c10, c10, alpha );
+		renderFaceUp( tile, 0, 0, 0, getTexture(tile, 1 ) );
+		t->color( c2, c2, c2, alpha );
+		renderNorth( tile, 0, 0, 0, getTexture(tile, 2 ) );
+		renderSouth( tile, 0, 0, 0, getTexture(tile, 3 ) );
+		t->color( c3, c3, c3, alpha );
+		renderWest( tile, 0, 0, 0, getTexture(tile, 4 ) );
+		renderEast( tile, 0, 0, 0, getTexture(tile, 5 ) );
+
+		t->end();
+
+		glTranslatef( 0.5f, 0.5f, 0.5f );
+	}
+
+}
+
+void TileRenderer::renderTile( Tile* tile, int data, float brightness, float fAlpha, bool useCompiled )
+{
+	Tesselator* t = Tesselator::getInstance();
+
+	bool isGrass = tile->id == Tile::grass_Id;
+
+	if (tile == Tile::dispenser || tile == Tile::furnace) // || tile == Tile.dropper
+	{
+		data = 3;
+	}
+
+	if ( setColor )
+	{
+		int		col = tile->getColor( data );
+        if (isGrass)
+		{
+            col = 0xffffff;
+        }
+		float	red = ( ( col >> 16 ) & 0xff ) / 255.0f;
+		float	g = ( ( col >> 8 ) & 0xff ) / 255.0f;
+		float	b = ( ( col )& 0xff ) / 255.0f;
+
+		glColor4f( red * brightness, g * brightness, b * brightness, fAlpha );
+	}
+
+	int			shape = tile->getRenderShape();
+	setShape(tile);
+
+	t->setMipmapEnable( Tile::mipmapEnable[tile->id] );	// 4J added
+
+	if ( shape == Tile::SHAPE_BLOCK || shape == Tile::SHAPE_TREE || shape == Tile::SHAPE_QUARTZ || shape == Tile::SHAPE_PISTON_BASE || shape == Tile::SHAPE_PORTAL_FRAME )
+	{
+		if ( shape == Tile::SHAPE_PISTON_BASE )
+		{
+			data = Facing::UP;
+		}
+
+		tile->updateDefaultShape();	
+		setShape(tile);
+		glRotatef(90, 0, 1, 0);
+
+		glTranslatef( -0.5f, -0.5f, -0.5f );
+		t->begin();
+		t->normal( 0, -1, 0 );
+		renderFaceDown( tile, 0, 0, 0, getTexture(tile, 0, data ) );
+		t->end();
+
+        if (isGrass && setColor)
+		{
+            int col = tile->getColor(data);
+            float red = ((col >> 16) & 0xff) / 255.0f;
+            float g = ((col >> 8) & 0xff) / 255.0f;
+            float b = ((col) & 0xff) / 255.0f;
+
+            glColor4f(red * brightness, g * brightness, b * brightness, fAlpha);
+        }
+
+		t->begin();
+		t->normal( 0, 1, 0 );
+		renderFaceUp( tile, 0, 0, 0, getTexture(tile, 1, data ) );
+		t->end();
+
+        if (isGrass && setColor)
+		{
+            glColor4f(brightness, brightness, brightness, fAlpha);
+        }
+
+		t->begin();
+		t->normal( 0, 0, -1 );
+		renderNorth( tile, 0, 0, 0, getTexture(tile, 2, data ) );
+		t->end();
+
+		if (isGrass && setColor)
+		{
+            int col = tile->getColor(data);
+            float red = ((col >> 16) & 0xff) / 255.0f;
+            float g = ((col >> 8) & 0xff) / 255.0f;
+            float b = ((col) & 0xff) / 255.0f;
+
+            glColor4f(red * brightness, g * brightness, b * brightness, fAlpha);
+
+			t->begin();
+			t->normal( 0, 0, -1 );
+			renderNorth( tile, 0, 0, 0, GrassTile::getSideTextureOverlay() );
+			t->end();
+
+            glColor4f(brightness, brightness, brightness, fAlpha);
+        }
+
+		t->begin();
+		t->normal( 0, 0, 1 );
+		renderSouth( tile, 0, 0, 0, getTexture(tile, 3, data ) );
+		t->end();
+
+		if (isGrass && setColor)
+		{
+            int col = tile->getColor(data);
+            float red = ((col >> 16) & 0xff) / 255.0f;
+            float g = ((col >> 8) & 0xff) / 255.0f;
+            float b = ((col) & 0xff) / 255.0f;
+
+            glColor4f(red * brightness, g * brightness, b * brightness, fAlpha);
+
+			t->begin();
+			t->normal( 0, 0, 1 );
+			renderSouth( tile, 0, 0, 0, GrassTile::getSideTextureOverlay() );
+			t->end();
+
+            glColor4f(brightness, brightness, brightness, fAlpha);
+        }
+
+		t->begin();
+		t->normal( -1, 0, 0 );
+		renderWest( tile, 0, 0, 0, getTexture(tile, 4, data ) );
+		t->end();
+
+		if (isGrass && setColor)
+		{
+            int col = tile->getColor(data);
+            float red = ((col >> 16) & 0xff) / 255.0f;
+            float g = ((col >> 8) & 0xff) / 255.0f;
+            float b = ((col) & 0xff) / 255.0f;
+
+            glColor4f(red * brightness, g * brightness, b * brightness, fAlpha);
+
+			t->begin();
+			t->normal( -1, 0, 0 );
+			renderWest( tile, 0, 0, 0, GrassTile::getSideTextureOverlay() );
+			t->end();
+
+            glColor4f(brightness, brightness, brightness, fAlpha);
+        }
+
+		t->begin();
+		t->normal( 1, 0, 0 );
+		renderEast( tile, 0, 0, 0, getTexture(tile, 5, data ) );
+		t->end();
+
+		if (isGrass && setColor)
+		{
+            int col = tile->getColor(data);
+            float red = ((col >> 16) & 0xff) / 255.0f;
+            float g = ((col >> 8) & 0xff) / 255.0f;
+            float b = ((col) & 0xff) / 255.0f;
+
+			glColor4f(red * brightness, g * brightness, b * brightness, fAlpha);
+
+			t->begin();
+			t->normal( 1, 0, 0 );
+			renderEast( tile, 0, 0, 0, GrassTile::getSideTextureOverlay() );
+			t->end();
+
+            glColor4f(brightness, brightness, brightness, fAlpha);
+        }
+
+		glTranslatef( 0.5f, 0.5f, 0.5f );
+	}
+	else if ( shape == Tile::SHAPE_CROSS_TEXTURE )
+	{
+		t->begin();
+		t->normal( 0, -1, 0 );
+		tesselateCrossTexture( tile, data, -0.5f, -0.5f, -0.5f, 1 );
+		t->end();
+	}
+    else if (shape == Tile::SHAPE_STEM)
+	{
+		t->begin();
+		t->normal(0, -1, 0);
+		tile->updateDefaultShape();
+		tesselateStemTexture(tile, data, tileShapeY1, -0.5f, -0.5f, -0.5f);
+		t->end();
+	}
+    else if (shape == Tile::SHAPE_LILYPAD)
+	{
+        t->begin();
+        t->normal(0, -1, 0);
+        tile->updateDefaultShape();
+        t->end();
+	}
+	else if ( shape == Tile::SHAPE_CACTUS )
+	{
+		tile->updateDefaultShape();
+		glTranslatef( -0.5f, -0.5f, -0.5f );
+		float s = 1 / 16.0f;
+		t->begin();
+		t->normal( 0, -1, 0 );
+		renderFaceDown( tile, 0, 0, 0, getTexture(tile, 0 ) );
+		t->end();
+
+		t->begin();
+		t->normal( 0, 1, 0 );
+		renderFaceUp( tile, 0, 0, 0, getTexture(tile, 1 ) );
+		t->end();
+
+		t->begin();
+		t->normal( 0, 0, -1 );
+		t->addOffset( 0, 0, s );
+		renderNorth( tile, 0, 0, 0, getTexture(tile, 2 ) );
+		t->addOffset( 0, 0, -s );
+		t->end();
+
+		t->begin();
+		t->normal( 0, 0, 1 );
+		t->addOffset( 0, 0, -s );
+		renderSouth( tile, 0, 0, 0, getTexture(tile, 3 ) );
+		t->addOffset( 0, 0, s );
+		t->end();
+
+		t->begin();
+		t->normal( -1, 0, 0 );
+		t->addOffset( s, 0, 0 );
+		renderWest( tile, 0, 0, 0, getTexture(tile, 4 ) );
+		t->addOffset( -s, 0, 0 );
+		t->end();
+
+		t->begin();
+		t->normal( 1, 0, 0 );
+		t->addOffset( -s, 0, 0 );
+		renderEast( tile, 0, 0, 0, getTexture(tile, 5 ) );
+		t->addOffset( s, 0, 0 );
+		t->end();
+
+		glTranslatef( 0.5f, 0.5f, 0.5f );
+    }
+	else if (shape == Tile::SHAPE_ENTITYTILE_ANIMATED)
+	{
+			glRotatef(90, 0, 1, 0);
+			glTranslatef(-0.5f, -0.5f, -0.5f);
+			EntityTileRenderer::instance->render(tile, data, brightness, fAlpha, setColor, useCompiled);
+            glEnable(GL_RESCALE_NORMAL);
+	}
+	else if ( shape == Tile::SHAPE_ROWS )
+	{
+		t->begin();
+		t->normal( 0, -1, 0 );
+		tesselateRowTexture( tile, data, -0.5f, -0.5f, -0.5f );
+		t->end();
+	}
+	else if ( shape == Tile::SHAPE_TORCH )
+	{
+		t->begin();
+		t->normal( 0, -1, 0 );
+		tesselateTorch( tile, -0.5f, -0.5f, -0.5f, 0, 0, 0 );
+		t->end();
+	}
+	else if ( shape == Tile::SHAPE_STAIRS )
+	{
+		for ( int i = 0; i < 2; i++ )
+		{
+			if ( i == 0 ) setShape( 0, 0, 0, 1, 1, 0.5f );
+			if ( i == 1 ) setShape( 0, 0, 0.5f, 1, 0.5f, 1 );
+
+			glTranslatef( -0.5f, -0.5f, -0.5f );
+			t->begin();
+			t->normal( 0, -1, 0 );
+			renderFaceDown( tile, 0, 0, 0, getTexture(tile, 0 ) );
+			t->end();
+
+			t->begin();
+			t->normal( 0, 1, 0 );
+			renderFaceUp( tile, 0, 0, 0, getTexture(tile, 1 ) );
+			t->end();
+
+			t->begin();
+			t->normal( 0, 0, -1 );
+			renderNorth( tile, 0, 0, 0, getTexture(tile, 2 ) );
+			t->end();
+
+			t->begin();
+			t->normal( 0, 0, 1 );
+			renderSouth( tile, 0, 0, 0, getTexture(tile, 3 ) );
+			t->end();
+
+			t->begin();
+			t->normal( -1, 0, 0 );
+			renderWest( tile, 0, 0, 0, getTexture(tile, 4 ) );
+			t->end();
+
+			t->begin();
+			t->normal( 1, 0, 0 );
+			renderEast( tile, 0, 0, 0, getTexture(tile, 5 ) );
+			t->end();
+
+			glTranslatef( 0.5f, 0.5f, 0.5f );
+		}
+	}
+	else if (shape == Tile::SHAPE_EGG)
+	{
+        int y0 = 0;
+        glTranslatef(-0.5f, -0.5f, -0.5f);
+        t->begin();
+        for (int i = 0; i < 8; i++)
+		{
+            int ww = 0;
+            int hh = 1;
+            if (i == 0) ww = 2;
+            if (i == 1) ww = 3;
+            if (i == 2) ww = 4;
+            if (i == 3)
+			{
+                ww = 5;
+                hh = 2;
+            }
+            if (i == 4)
+			{
+                ww = 6;
+                hh = 3;
+            }
+            if (i == 5)
+			{
+                ww = 7;
+                hh = 5;
+            }
+            if (i == 6)
+			{
+                ww = 6;
+                hh = 2;
+            }
+            if (i == 7) ww = 3;
+            float w = ww / 16.0f;
+            float yy1 = 1 - (y0 / 16.0f);
+            float yy0 = 1 - ((y0 + hh) / 16.0f);
+            y0 += hh;
+            setShape(0.5f - w, yy0, 0.5f - w, 0.5f + w, yy1, 0.5f + w);
+            t->normal(0, -1, 0);
+            renderFaceDown(tile, 0, 0, 0, getTexture(tile,0));
+            t->normal(0, 1, 0);
+            renderFaceUp(tile, 0, 0, 0, getTexture(tile,1));
+            t->normal(0, 0, -1);
+            renderNorth(tile, 0, 0, 0, getTexture(tile,2));
+            t->normal(0, 0, 1);
+            renderSouth(tile, 0, 0, 0, getTexture(tile,3));
+            t->normal(-1, 0, 0);
+            renderWest(tile, 0, 0, 0, getTexture(tile,4));
+            t->normal(1, 0, 0);
+            renderEast(tile, 0, 0, 0, getTexture(tile,5));
+        }
+        t->end();
+        glTranslatef(0.5f, 0.5f, 0.5f);
+        setShape(0, 0, 0, 1, 1, 1);
+	}
+
+	else if ( shape == Tile::SHAPE_FENCE )
+	{
+		for ( int i = 0; i < 4; i++ )
+		{
+			float w = 2 / 16.0f;
+			if ( i == 0 ) setShape( 0.5f - w, 0, 0, 0.5f + w, 1, w * 2 );
+			if ( i == 1 ) setShape( 0.5f - w, 0, 1 - w * 2, 0.5f + w, 1, 1 );
+			w = 1 / 16.0f;
+			if ( i == 2 ) setShape( 0.5f - w, 1 - w * 3, -w * 2, 0.5f + w, 1 - w, 1 + w * 2 );
+			if ( i == 3 ) setShape( 0.5f - w, 0.5f - w * 3, -w * 2, 0.5f + w, 0.5f - w, 1 + w * 2 );
+
+			glTranslatef( -0.5f, -0.5f, -0.5f );
+			t->begin();
+			t->normal( 0, -1, 0 );
+			renderFaceDown( tile, 0, 0, 0, getTexture(tile, 0 ) );
+			t->end();
+
+			t->begin();
+			t->normal( 0, 1, 0 );
+			renderFaceUp( tile, 0, 0, 0, getTexture(tile, 1 ) );
+			t->end();
+
+			t->begin();
+			t->normal( 0, 0, -1 );
+			renderNorth( tile, 0, 0, 0, getTexture(tile, 2 ) );
+			t->end();
+
+			t->begin();
+			t->normal( 0, 0, 1 );
+			renderSouth( tile, 0, 0, 0, getTexture(tile, 3 ) );
+			t->end();
+
+			t->begin();
+			t->normal( -1, 0, 0 );
+			renderWest( tile, 0, 0, 0, getTexture(tile, 4 ) );
+			t->end();
+
+			t->begin();
+			t->normal( 1, 0, 0 );
+			renderEast( tile, 0, 0, 0, getTexture(tile, 5 ) );
+			t->end();
+
+			glTranslatef( 0.5f, 0.5f, 0.5f );
+		}
+		setShape( 0, 0, 0, 1, 1, 1 );
+    }
+	else if (shape == Tile::SHAPE_FENCE_GATE)
+	{
+        for (int i = 0; i < 3; i++)
+		{
+            float w = 1 / 16.0f;
+            if (i == 0) setShape(0.5f - w, .3f, 0, 0.5f + w, 1, w * 2);
+            if (i == 1) setShape(0.5f - w, .3f, 1 - w * 2, 0.5f + w, 1, 1);
+            w = 1 / 16.0f;
+            if (i == 2) setShape(0.5f - w, .5f, 0, 0.5f + w, 1 - w, 1);
+
+            glTranslatef(-0.5f, -0.5f, -0.5f);
+            t->begin();
+            t->normal(0, -1, 0);
+            renderFaceDown(tile, 0, 0, 0, getTexture(tile,0));
+            t->end();
+
+            t->begin();
+            t->normal(0, 1, 0);
+            renderFaceUp(tile, 0, 0, 0, getTexture(tile,1));
+            t->end();
+
+            t->begin();
+            t->normal(0, 0, -1);
+            renderNorth(tile, 0, 0, 0, getTexture(tile,2));
+            t->end();
+
+            t->begin();
+            t->normal(0, 0, 1);
+            renderSouth(tile, 0, 0, 0, getTexture(tile,3));
+            t->end();
+
+            t->begin();
+            t->normal(-1, 0, 0);
+            renderWest(tile, 0, 0, 0, getTexture(tile,4));
+            t->end();
+
+            t->begin();
+            t->normal(1, 0, 0);
+            renderEast(tile, 0, 0, 0, getTexture(tile,5));
+            t->end();
+
+            glTranslatef(0.5f, 0.5f, 0.5f);
+        }
+	}
+	else if (shape == Tile::SHAPE_WALL)
+	{
+		for (int i = 0; i < 2; i++)
+		{
+			if (i == 0) setShape(0, 0, .5f - WallTile::WALL_WIDTH, 1, WallTile::WALL_HEIGHT, .5f + WallTile::WALL_WIDTH);
+			if (i == 1) setShape(.5f - WallTile::POST_WIDTH, 0, .5f - WallTile::POST_WIDTH, .5f + WallTile::POST_WIDTH, WallTile::POST_HEIGHT, .5f + WallTile::POST_WIDTH);
+
+			glTranslatef(-0.5f, -0.5f, -0.5f);
+			t->begin();
+			t->normal(0, -1, 0);
+			renderFaceDown(tile, 0, 0, 0, tile->getTexture(0, data));
+			t->end();
+
+			t->begin();
+			t->normal(0, 1, 0);
+			renderFaceUp(tile, 0, 0, 0, tile->getTexture(1, data));
+			t->end();
+
+			t->begin();
+			t->normal(0, 0, -1);
+			renderNorth(tile, 0, 0, 0, tile->getTexture(2, data));
+			t->end();
+
+			t->begin();
+			t->normal(0, 0, 1);
+			renderSouth(tile, 0, 0, 0, tile->getTexture(3, data));
+			t->end();
+
+			t->begin();
+			t->normal(-1, 0, 0);
+			renderWest(tile, 0, 0, 0, tile->getTexture(4, data));
+			t->end();
+
+			t->begin();
+			t->normal(1, 0, 0);
+			renderEast(tile, 0, 0, 0, tile->getTexture(5, data));
+			t->end();
+
+			glTranslatef(0.5f, 0.5f, 0.5f);
+		}
+		setShape(0, 0, 0, 1, 1, 1);
+	}
+	else if (shape == Tile::SHAPE_ANVIL)
+	{
+		glTranslatef(-0.5f, -0.5f, -0.5f);
+		tesselateAnvilInWorld((AnvilTile *) tile, 0, 0, 0, data, true);
+		glTranslatef(0.5f, 0.5f, 0.5f);
+	}
+	else if ( shape == Tile::SHAPE_PORTAL_FRAME )
+	{
+		// 4J added
+		setShape(0, 0, 0, 1, 13.0f / 16.0f, 1);
+
+		glTranslatef( -0.5f, -0.5f, -0.5f );
+		t->begin();
+		t->normal( 0, -1, 0 );
+		renderFaceDown( tile, 0, 0, 0, getTexture(tile, 0, 0 ) );
+		t->end();
+
+		t->begin();
+		t->normal( 0, 1, 0 );
+		renderFaceUp( tile, 0, 0, 0, getTexture(tile, 1, 0 ) );
+		t->end();
+
+		t->begin();
+		t->normal( 0, 0, -1 );
+		renderNorth( tile, 0, 0, 0, getTexture(tile, 2, 0 ) );
+		t->end();
+
+		t->begin();
+		t->normal( 0, 0, 1 );
+		renderSouth( tile, 0, 0, 0, getTexture(tile, 3, 0 ) );
+		t->end();
+
+		t->begin();
+		t->normal( -1, 0, 0 );
+		renderWest( tile, 0, 0, 0, getTexture(tile, 4, 0 ) );
+		t->end();
+
+		t->begin();
+		t->normal( 1, 0, 0 );
+		renderEast( tile, 0, 0, 0, getTexture(tile, 5, 0 ) );
+		t->end();
+
+		glTranslatef( 0.5f, 0.5f, 0.5f );
+
+		tile->updateDefaultShape();
+
+	}
+	t->setMipmapEnable( true );	// 4J added
+}
+
+bool TileRenderer::canRender( int renderShape )
+{
+	if ( renderShape == Tile::SHAPE_BLOCK ) return true;
+	if ( renderShape == Tile::SHAPE_TREE ) return true;
+	if ( renderShape == Tile::SHAPE_QUARTZ) return true;
+	if ( renderShape == Tile::SHAPE_CACTUS ) return true;
+	if ( renderShape == Tile::SHAPE_STAIRS ) return true;
+	if ( renderShape == Tile::SHAPE_FENCE ) return true;
+	if ( renderShape == Tile::SHAPE_EGG) return true;
+    if ( renderShape == Tile::SHAPE_ENTITYTILE_ANIMATED) return true;
+    if ( renderShape == Tile::SHAPE_FENCE_GATE) return true;
+	if ( renderShape == Tile::SHAPE_PISTON_BASE ) return true;
+	if ( renderShape == Tile::SHAPE_PORTAL_FRAME ) return true;
+	if ( renderShape == Tile::SHAPE_WALL) return true;
+	if ( renderShape == Tile::SHAPE_ANVIL) return true;
+	return false;
+}
+
+Icon *TileRenderer::getTexture(Tile *tile, LevelSource *level, int x, int y, int z, int face)
+{
+	return getTextureOrMissing(tile->getTexture(level, x, y, z, face));
+}
+
+Icon *TileRenderer::getTexture(Tile *tile, int face, int data)
+{
+	return getTextureOrMissing(tile->getTexture(face, data));
+}
+
+Icon *TileRenderer::getTexture(Tile *tile, int face)
+{
+	return getTextureOrMissing(tile->getTexture(face));
+}
+
+Icon *TileRenderer::getTexture(Tile *tile)
+{
+	return getTextureOrMissing(tile->getTexture(Facing::UP));
+}
+
+Icon *TileRenderer::getTextureOrMissing(Icon *icon)
+{
+	if (icon == NULL) return minecraft->textures->getMissingIcon(Icon::TYPE_TERRAIN);
+
+#ifdef __PSVITA__
+	// AP - alpha cut out is expensive on vita. Pass on the Alpha Cut out flag to the tesselator
+	Tesselator* t = Tesselator::getInstance();
+	t->setAlphaCutOut( icon->getFlags() & Icon::IS_ALPHA_CUT_OUT );
+#endif
+
+	return icon;
+}