Initial commit

1 files changed, 899 insertions, 0 deletions

diff --git a/Minecraft.Client/PS3/SPU_Tasks/ChunkUpdate/Tile_SPU.cpp b/Minecraft.Client/PS3/SPU_Tasks/ChunkUpdate/Tile_SPU.cpp
new file mode 100644
index 00000000..f2dfeaac
--- /dev/null
+++ b/Minecraft.Client/PS3/SPU_Tasks/ChunkUpdate/Tile_SPU.cpp
@@ -0,0 +1,899 @@
+#include "stdafx.h"
+#include "Tile_SPU.h"
+#include "ChunkRebuildData.h"
+#include "GrassTile_SPU.h"
+#include "HalfSlabTile_SPU.h"
+#include "WoodSlabTile_SPU.h"
+#include "StoneSlabTile_SPU.h"
+#include "ChestTile_SPU.h"
+#include "ThinFenceTile_SPU.h"
+#include "FenceTile_SPU.h"
+#include "StairTile_SPU.h"
+#include "DirtTile_SPU.h"
+#include "DoorTile_SPU.h"
+#include "PressurePlateTile_SPU.h"
+#include "FarmTile_SPU.h"
+#include "Bush_SPU.h"
+#include "TallGrass_SPU.h"
+#include "SandStoneTile_SPU.h"
+#include "WoodTile_SPU.h"
+#include "TreeTile_SPU.h"
+#include "LeafTile_SPU.h"
+#include "CropTile_SPU.h"
+#include "ReedTile_SPU.h"
+#include "TorchTile_SPU.h"
+#include "Mushroom_SPU.h"
+#include "FurnaceTile_SPU.h"
+#include "WebTile_SPU.h"
+#include "LiquidTile_SPU.h"
+#include "FireTile_SPU.h"
+#include "Sapling_SPU.h"
+#include "GlassTile_SPU.h"
+#include "IceTile_SPU.h"
+#include "PortalTile_SPU.h"
+#include "DispenserTile_SPU.h"
+#include "RailTile_SPU.h"
+#include "DetectorRailTile_SPU.h"
+#include "TntTile_SPU.h"
+#include "BookshelfTile_SPU.h"
+#include "WorkbenchTile_SPU.h"
+#include "SignTile_SPU.h"
+#include "LadderTile_SPU.h"
+#include "ButtonTile_SPU.h"
+#include "TopSnowTile_SPU.h"
+#include "CactusTile_SPU.h"
+#include "RecordPlayerTile_SPU.h"
+#include "PumpkinTile_SPU.h"
+#include "CakeTile_SPU.h"
+#include "TrapDoorTile_SPU.h"
+#include "StoneMonsterTile_SPU.h"
+#include "SmoothStoneBrickTile_SPU.h"
+#include "HugeMushroomTile_SPU.h"
+#include "MelonTile_SPU.h"
+#include "StemTile_SPU.h"
+#include "VineTile_SPU.h"
+#include "MycelTile_SPU.h"
+#include "WaterlilyTile_SPU.h"
+#include "NetherStalkTile_SPU.h"
+#include "EnchantmentTableTile_SPU.h"
+#include "BrewingStandTile_SPU.h"
+#include "DiodeTile_SPU.h"
+#include "RedStoneDustTile_SPU.h"
+#include "FenceGateTile_SPU.h"
+#include "BedTile_SPU.h"
+#include "PistonBaseTile_SPU.h"
+#include "PistonExtensionTile_SPU.h"
+#include "PistonMovingPiece_SPU.h"
+#include "LeverTile_SPU.h"
+#include "CauldronTile_SPU.h"
+#include "TheEndPortal_SPU.h"
+#include "TheEndPortalFrameTile_SPU.h"
+#include "EggTile_SPU.h"
+#include "CocoaTile_SPU.h"
+#include "RedlightTile_SPU.h"
+#include "ClothTile_SPU.h"
+#include "SkullTile_SPU.h"
+#include "MobSpawnerTile_SPU.h"
+#include "EnderChestTile_SPU.h"
+#include "TripWireSourceTile_SPU.h"
+#include "TripWireTile_SPU.h"
+#include "WallTile_SPU.h"
+#include "FlowerPotTile_SPU.h"
+#include "CarrotTile_SPU.h"
+#include "PotatoTile_SPU.h"
+#include "QuartzBlockTile_SPU.h"
+#include "WoolCarpetTile_SPU.h"
+
+#ifdef SN_TARGET_PS3_SPU
+#include "..\Common\spu_assert.h"
+#endif
+
+#include <assert.h>
+#include <new>
+#include "AnvilTile_SPU.h"
+
+TileData_SPU* Tile_SPU::ms_pTileData = NULL;
+
+Tile_SPU Tile_SPU::m_tiles[256];
+
+
+
+int Tile_SPU::getRenderShape()
+{
+	return SHAPE_BLOCK;
+}
+
+
+void Tile_SPU::setShape(float x0, float y0, float z0, float x1, float y1, float z1)
+{
+	ms_pTileData->xx0[id] = x0;
+	ms_pTileData->yy0[id] = y0;
+	ms_pTileData->zz0[id] = z0;
+	ms_pTileData->xx1[id] = x1;
+	ms_pTileData->yy1[id] = y1;
+	ms_pTileData->zz1[id] = z1;
+}
+
+float Tile_SPU::getBrightness(ChunkRebuildData *level, int x, int y, int z)
+{
+	return level->getBrightness(x, y, z, ms_pTileData->lightEmission[id]);
+}
+// 
+// // 4J - brought forward from 1.8.2
+int Tile_SPU::getLightColor(ChunkRebuildData *level, int x, int y, int z)
+{
+	int tileID = level->getTile(x, y, z);
+	return level->getLightColor(x, y, z, ms_pTileData->lightEmission[tileID]);
+}
+// 
+// bool Tile_SPU::isFaceVisible(Level *level, int x, int y, int z, int f)
+// {
+// 	if (f == 0) y--;
+// 	if (f == 1) y++;
+// 	if (f == 2) z--;
+// 	if (f == 3) z++;
+// 	if (f == 4) x--;
+// 	if (f == 5) x++;
+// 	return !level->isSolidRenderTile(x, y, z);
+// }
+// 
+bool Tile_SPU::shouldRenderFace(ChunkRebuildData *level, int x, int y, int z, int face)
+{
+	if (face == 0 && getShapeY0() > 0) return true;
+	if (face == 1 && getShapeY1() < 1) return true;
+	if (face == 2 && getShapeZ0() > 0) return true;
+	if (face == 3 && getShapeZ1() < 1) return true;
+	if (face == 4 && getShapeX0() > 0) return true;
+	if (face == 5 && getShapeX1() < 1) return true;
+	return (!level->isSolidRenderTile(x, y, z));
+}
+// 
+bool Tile_SPU::isSolidFace(ChunkRebuildData *level, int x, int y, int z, int face)
+{
+	return (level->getMaterial(x, y, z)->isSolid());
+}
+
+Icon_SPU *Tile_SPU::getTexture(ChunkRebuildData *level, int x, int y, int z, int face)
+{
+	// 4J - addition here to make rendering big blocks of leaves more efficient. Normally leaves never consider themselves as solid, so
+	// blocks of leaves will have all sides of each block completely visible. Changing to consider as solid if this block is surrounded by
+	// other leaves. This is paired with another change in  Level::isSolidRenderTile/Region::isSolidRenderTile which makes things solid
+	// code-wise (ie for determining visible sides of neighbouring blocks). This change just makes the texture a solid one (tex + 1) which
+	// we already have in the texture map for doing non-fancy graphics. Note: this tile-specific code is here rather than making some new virtual
+	// method in the tiles, for the sake of efficiency - I don't imagine we'll be doing much more of this sort of thing
+
+	int tileId = level->getTile(x, y, z);
+	int tileData = level->getData(x, y, z);
+
+	if( tileId == Tile_SPU::leaves_Id )
+	{
+		bool opaque = true;
+		int axo[6] = { 1,-1, 0, 0, 0, 0};
+		int ayo[6] = { 0, 0, 1,-1, 0, 0};
+		int azo[6] = { 0, 0, 0, 0, 1,-1};
+		for( int i = 0; (i < 6) && opaque; i++ )
+		{
+			int t = level->getTile(x + axo[i], y + ayo[i] , z + azo[i]);
+			if( ( t != Tile_SPU::leaves_Id ) && ( ( Tile_SPU::m_tiles[t].id == -1) || !Tile_SPU::m_tiles[t].isSolidRender() ) )
+			{
+				opaque = false;
+			}
+		}
+
+
+		Icon_SPU *icon = NULL;
+		if(opaque)
+		{
+			LeafTile_SPU::setFancy(false);
+			icon = getTexture(face, tileData);
+			LeafTile_SPU::setFancy(true);
+		}
+		else
+		{
+			icon = getTexture(face, tileData);
+		}
+		return icon;
+	}
+	return getTexture(face, tileData);
+}
+// 
+Icon_SPU *Tile_SPU::getTexture(int face, int data)
+{
+	return &ms_pTileData->iconData[id];
+}
+// 
+Icon_SPU *Tile_SPU::getTexture(int face)
+{
+	return getTexture(face, 0);
+}
+// 
+// AABB *Tile_SPU::getTileAABB(Level *level, int x, int y, int z)
+// {
+// 	return AABB::newTemp(x + xx0, y + yy0, z + zz0, x + xx1, y + yy1, z + zz1);
+// }
+// 
+// void Tile_SPU::addAABBs(Level *level, int x, int y, int z, AABB *box, AABBList *boxes, Entity *source) 
+// {
+// 	AABB *aabb = getAABB(level, x, y, z);
+// 	if (aabb != NULL && box->intersects(aabb)) boxes->push_back(aabb);
+// }
+// 
+// void Tile_SPU::addAABBs(Level *level, int x, int y, int z, AABB *box, AABBList *boxes)
+// {
+// 	AABB *aabb = getAABB(level, x, y, z);
+// 	if (aabb != NULL && box->intersects(aabb)) boxes->push_back(aabb);
+// }
+// 
+// AABB *Tile_SPU::getAABB(Level *level, int x, int y, int z)
+// {
+// 	return AABB::newTemp(x + xx0, y + yy0, z + zz0, x + xx1, y + yy1, z + zz1);
+// }
+// 
+ bool Tile_SPU::isSolidRender(bool isServerLevel)
+ {
+ 	return true;
+ }
+
+
+// bool Tile_SPU::mayPick(int data, bool liquid)
+// {
+// 	return mayPick();
+// }
+// 
+// bool Tile_SPU::mayPick()
+// {
+// 	return true;
+// }
+// 
+// void Tile_SPU::tick(Level *level, int x, int y, int z, Random *random)
+// {
+// }
+// 
+// void Tile_SPU::animateTick(Level *level, int x, int y, int z, Random *random)
+// {
+// }
+// 
+// void Tile_SPU::destroy(Level *level, int x, int y, int z, int data)
+// {
+// }
+// 
+// void Tile_SPU::neighborChanged(Level *level, int x, int y, int z, int type)
+// {
+// }
+// 
+// void Tile_SPU::addLights(Level *level, int x, int y, int z)
+// {
+// }
+// 
+// int Tile_SPU::getTickDelay()
+// {
+// 	return 10;
+// }
+// 
+// void Tile_SPU::onPlace(Level *level, int x, int y, int z)
+// {
+// }
+// 
+// void Tile_SPU::onRemove(Level *level, int x, int y, int z)
+// {
+// }
+// 
+// int Tile_SPU::getResourceCount(Random *random)
+// {
+// 	return 1;
+// }
+// 
+// int Tile_SPU::getResource(int data, Random *random, int playerBonusLevel)
+// {
+// 	return id;
+// }
+// 
+// float Tile_SPU::getDestroyProgress(shared_ptr<Player> player)
+// {
+// 	if (destroySpeed < 0) return 0;
+// 	if (!player->canDestroy(this)) return 1 / destroySpeed / 100.0f;
+// 	return (player->getDestroySpeed(this) / destroySpeed) / 30;
+// }
+// 
+// void Tile_SPU::spawnResources(Level *level, int x, int y, int z, int data, int playerBonusLevel)
+// {
+// 	spawnResources(level, x, y, z, data, 1, playerBonusLevel);
+// }
+// 
+// void Tile_SPU::spawnResources(Level *level, int x, int y, int z, int data, float odds, int playerBonusLevel)
+// {
+// 	if (level->isClientSide) return;
+// 	int count = getResourceCountForLootBonus(playerBonusLevel, level->random);
+// 	for (int i = 0; i < count; i++)
+// 	{
+// 		if (level->random->nextFloat() > odds) continue;
+// 		int type = getResource(data, level->random, playerBonusLevel);
+// 		if (type <= 0) continue;
+// 
+// 		popResource(level, x, y, z, shared_ptr<ItemInstance>( new ItemInstance(type, 1, getSpawnResourcesAuxValue(data) ) ) );
+// 	}
+// }
+// 
+// void Tile_SPU::popResource(Level *level, int x, int y, int z, shared_ptr<ItemInstance> itemInstance)
+// {
+// 	if( level->isClientSide ) return;
+// 
+// 	float s = 0.7f;
+// 	double xo = level->random->nextFloat() * s + (1 - s) * 0.5;
+// 	double yo = level->random->nextFloat() * s + (1 - s) * 0.5;
+// 	double zo = level->random->nextFloat() * s + (1 - s) * 0.5;
+// 	shared_ptr<ItemEntity> item = shared_ptr<ItemEntity>( new ItemEntity(level, x + xo, y + yo, z + zo, itemInstance ) );
+// 	item->throwTime = 10;
+// 	level->addEntity(item);
+// }
+// 
+// // Brought forward for TU7
+// void Tile_SPU::popExperience(Level *level, int x, int y, int z, int amount)
+// {
+// 	if (!level->isClientSide)
+// 	{
+// 		while (amount > 0)
+// 		{
+// 			int newCount = ExperienceOrb::getExperienceValue(amount);
+// 			amount -= newCount;
+// 			level->addEntity(shared_ptr<ExperienceOrb>( new ExperienceOrb(level, x + .5, y + .5, z + .5, newCount)));
+// 		}
+// 	}
+// }
+// 
+// int Tile_SPU::getSpawnResourcesAuxValue(int data)
+// {
+// 	return 0;
+// }
+// 
+// float Tile_SPU::getExplosionResistance(shared_ptr<Entity> source)
+// {
+// 	return explosionResistance / 5.0f;
+// }
+// 
+// HitResult *Tile_SPU::clip(Level *level, int xt, int yt, int zt, Vec3 *a, Vec3 *b)
+// {
+// 	EnterCriticalSection(&m_csShape);
+// 	updateShape(level, xt, yt, zt);
+// 
+// 	a = a->add(-xt, -yt, -zt);
+// 	b = b->add(-xt, -yt, -zt);
+// 
+// 	Vec3 *xh0 = a->clipX(b, xx0);
+// 	Vec3 *xh1 = a->clipX(b, xx1);
+// 
+// 	Vec3 *yh0 = a->clipY(b, yy0);
+// 	Vec3 *yh1 = a->clipY(b, yy1);
+// 
+// 	Vec3 *zh0 = a->clipZ(b, zz0);
+// 	Vec3 *zh1 = a->clipZ(b, zz1);
+// 
+// 	Vec3 *closest = NULL;
+// 
+// 	if (containsX(xh0) && (closest == NULL || a->distanceTo(xh0) < a->distanceTo(closest))) closest = xh0;
+// 	if (containsX(xh1) && (closest == NULL || a->distanceTo(xh1) < a->distanceTo(closest))) closest = xh1;
+// 	if (containsY(yh0) && (closest == NULL || a->distanceTo(yh0) < a->distanceTo(closest))) closest = yh0;
+// 	if (containsY(yh1) && (closest == NULL || a->distanceTo(yh1) < a->distanceTo(closest))) closest = yh1;
+// 	if (containsZ(zh0) && (closest == NULL || a->distanceTo(zh0) < a->distanceTo(closest))) closest = zh0;
+// 	if (containsZ(zh1) && (closest == NULL || a->distanceTo(zh1) < a->distanceTo(closest))) closest = zh1;
+// 
+// 	LeaveCriticalSection(&m_csShape);
+// 
+// 	if (closest == NULL) return NULL;
+// 
+// 	int face = -1;
+// 
+// 	if (closest == xh0) face = 4;
+// 	if (closest == xh1) face = 5;
+// 	if (closest == yh0) face = 0;
+// 	if (closest == yh1) face = 1;
+// 	if (closest == zh0) face = 2;
+// 	if (closest == zh1) face = 3;
+// 
+// 	return new HitResult(xt, yt, zt, face, closest->add(xt, yt, zt));
+// }
+// 
+// bool Tile_SPU::containsX(Vec3 *v)
+// {
+// 	if( v == NULL) return false;
+// 	return v->y >= yy0 && v->y <= yy1 && v->z >= zz0 && v->z <= zz1;
+// }
+// 
+// bool Tile_SPU::containsY(Vec3 *v)
+// {
+// 	if( v == NULL) return false;
+// 	return v->x >= xx0 && v->x <= xx1 && v->z >= zz0 && v->z <= zz1;
+// }
+// 
+// bool Tile_SPU::containsZ(Vec3 *v)
+// {
+// 	if( v == NULL) return false;
+// 	return v->x >= xx0 && v->x <= xx1 && v->y >= yy0 && v->y <= yy1;
+// }
+// 
+// void Tile_SPU::wasExploded(Level *level, int x, int y, int z)
+// {
+// }
+// 
+int Tile_SPU::getRenderLayer()
+{
+	return 0;
+}
+// 
+// bool Tile_SPU::mayPlace(Level *level, int x, int y, int z, int face)
+// {
+// 	return mayPlace(level, x, y, z);
+// }
+// 
+// bool Tile_SPU::mayPlace(Level *level, int x, int y, int z)
+// {
+// 	int t = level->getTile(x, y, z);
+// 	return t == 0 || Tile_SPU::tiles[t]->material->isReplaceable();
+// }
+// 
+// // 4J-PB - Adding a TestUse for tooltip display
+// bool Tile_SPU::TestUse()
+// {
+// 	return false;
+// }
+// 
+// bool Tile_SPU::TestUse(Level *level, int x, int y, int z, shared_ptr<Player> player)
+// {
+// 	return false;
+// }
+// 
+// bool Tile_SPU::use(Level *level, int x, int y, int z, shared_ptr<Player> player, int clickedFace, float clickX, float clickY, float clickZ, bool soundOnly/*=false*/) // 4J added soundOnly param
+// {
+// 	return false;
+// }
+// 
+// void Tile_SPU::stepOn(Level *level, int x, int y, int z, shared_ptr<Entity> entity)
+// {
+// }
+// 
+// void Tile_SPU::setPlacedOnFace(Level *level, int x, int y, int z, int face)
+// {
+// }
+// 
+// void Tile_SPU::prepareRender(Level *level, int x, int y, int z)
+// {
+// }
+// 
+// void Tile_SPU::attack(Level *level, int x, int y, int z, shared_ptr<Player> player)
+// {
+// }
+// 
+// void Tile_SPU::handleEntityInside(Level *level, int x, int y, int z, shared_ptr<Entity> e, Vec3 *current)
+// {
+// }
+// 
+void Tile_SPU::updateShape(ChunkRebuildData *level, int x, int y, int z, int forceData, TileEntity* forceEntity) // 4J added forceData, forceEntity param
+{
+}
+// 
+
+int Tile_SPU::getColor(ChunkRebuildData *level, int x, int y, int z)
+{
+	return 0xffffff;
+}
+
+// 
+// int Tile_SPU::getColor(LevelSource *level, int x, int y, int z, int data)
+// {
+// 	return 0xffffff;
+// }
+// 
+// bool Tile_SPU::getSignal(LevelSource *level, int x, int y, int z)
+// {
+// 	return false;
+// }
+// 
+// bool Tile_SPU::getSignal(LevelSource *level, int x, int y, int z, int dir)
+// {
+// 	return false;
+// }
+// 
+// bool Tile_SPU::isSignalSource()
+// {
+// 	return false;
+// }
+// 
+// void Tile_SPU::entityInside(Level *level, int x, int y, int z, shared_ptr<Entity> entity)
+// {
+// }
+// 
+// bool Tile_SPU::getDirectSignal(Level *level, int x, int y, int z, int dir)
+// {
+// 	return false;
+// }
+// 
+void Tile_SPU::updateDefaultShape()
+{
+}
+// 
+// void Tile_SPU::playerDestroy(Level *level, shared_ptr<Player> player, int x, int y, int z, int data)
+// {
+// 	// 4J Stu - Special case - only record a crop destroy if is fully grown
+// 	if(id==Tile_SPU::crops_Id)
+// 	{
+// 		if( Tile_SPU::crops->getResource(data, NULL, 0) > 0 )
+// 			player->awardStat(Stats::blocksMined[id], 1);
+// 	}
+// 	else
+// 	{
+// 		player->awardStat(Stats::blocksMined[id], 1);
+// 	}
+// 	player->awardStat(Stats::totalBlocksMined, 1);	// 4J : WESTY : Added for other award.
+// 	player->causeFoodExhaustion(FoodConstants::EXHAUSTION_MINE);
+// 
+// 	if( id == Tile_SPU::treeTrunk_Id )
+// 		player->awardStat(Achievements::mineWood);
+// 
+// 
+//     if (isCubeShaped() && !isEntityTile[id] && EnchantmentHelper::hasSilkTouch(player->inventory))
+// 	{
+//         shared_ptr<ItemInstance> item = getSilkTouchItemInstance(data);
+//         if (item != NULL)
+// 		{
+//             popResource(level, x, y, z, item);
+//         }
+//     }
+// 	else
+// 	{
+//         int playerBonusLevel = EnchantmentHelper::getDiggingLootBonus(player->inventory);
+//         spawnResources(level, x, y, z, data, playerBonusLevel);
+//     }
+// }
+// 
+// shared_ptr<ItemInstance> Tile_SPU::getSilkTouchItemInstance(int data)
+// {
+//     int popData = 0;
+//     if (id >= 0 && id < Item::items.length && Item::items[id]->isStackedByData())
+// 	{
+//         popData = data;
+//     }
+//     return shared_ptr<ItemInstance>(new ItemInstance(id, 1, popData));
+// }
+// 
+// int Tile_SPU::getResourceCountForLootBonus(int bonusLevel, Random *random)
+// {
+// 	return getResourceCount(random);
+// }
+// 
+// bool Tile_SPU::canSurvive(Level *level, int x, int y, int z)
+// {
+// 	return true;
+// }
+// 
+// void Tile_SPU::setPlacedBy(Level *level, int x, int y, int z, shared_ptr<Mob> by)
+// {
+// }
+// 
+// Tile *Tile_SPU::setDescriptionId(unsigned int id)
+// {
+// 	this->descriptionId = id;
+// 	return this;
+// }
+// 
+// wstring Tile_SPU::getName()
+// {
+// 	return I18n::get(getDescriptionId() + L".name");
+// }
+// 
+// unsigned int Tile_SPU::getDescriptionId(int iData /*= -1*/)
+// {
+// 	return descriptionId;
+// }
+// 
+// Tile *Tile_SPU::setUseDescriptionId(unsigned int id)
+// {
+// 	this->useDescriptionId = id;
+// 	return this;
+// }
+// 
+// unsigned int Tile_SPU::getUseDescriptionId()
+// {
+// 	return useDescriptionId;
+// }
+// 
+// void Tile_SPU::triggerEvent(Level *level, int x, int y, int z, int b0, int b1)
+// {
+// }
+// 
+// bool Tile_SPU::isCollectStatistics()
+// {
+// 	return collectStatistics;
+// }
+// 
+// Tile *Tile_SPU::setNotCollectStatistics()
+// {
+// 	collectStatistics = false;
+// 	return this;
+// }
+// 
+// int Tile_SPU::getPistonPushReaction()
+// {
+// 	return material->getPushReaction();
+// }
+// 
+// // 4J - brought forward from 1.8.2
+float Tile_SPU::getShadeBrightness(ChunkRebuildData *level, int x, int y, int z)
+{
+	return level->isSolidBlockingTile(x, y, z) ? 0.2f : 1.0f;
+}
+
+Tile_SPU* Tile_SPU::createFromID( int tileID )
+{
+	if(tileID == 0)
+		return NULL;
+
+	if(m_tiles[tileID].id != -1)
+		return &m_tiles[tileID];
+	
+#ifndef SN_TARGET_PS3_SPU
+	app.DebugPrintf("missing tile ID %d\n", tileID);
+#else
+	spu_print("missing tile ID %d\n", tileID);
+#endif	
+	return &m_tiles[1];
+
+}
+
+Material_SPU* Tile_SPU::getMaterial()
+{
+	int matID = ms_pTileData->materialIDs[id]; 
+	return &ms_pTileData->materials[matID];
+}
+
+// 
+// void Tile_SPU::fallOn(Level *level, int x, int y, int z, shared_ptr<Entity> entity, float fallDistance)
+// {
+// }
+// 
+// void Tile_SPU::registerIcons(IconRegister *iconRegister)
+// {
+// 	icon = iconRegister->registerIcon(m_textureName);
+// }
+// 
+// wstring Tile_SPU::getTileItemIconName()
+// {
+// 	return L"";
+// }
+// 
+// Tile *Tile_SPU::setTextureName(const wstring &name)
+// {
+// 	m_textureName = name;
+// 	return this;
+// }
+
+
+
+void Tile_SPU::initTilePointers()
+{
+
+#define  CREATE_TILE_TYPE(index, className) new (&m_tiles[index]) className(index);
+
+
+	CREATE_TILE_TYPE(grass_Id, GrassTile_SPU);
+	CREATE_TILE_TYPE(stoneSlab_Id, StoneSlabTile_SPU);
+	CREATE_TILE_TYPE(stoneSlabHalf_Id, StoneSlabTile_SPU);
+	CREATE_TILE_TYPE(woodSlab_Id, WoodSlabTile_SPU);
+	CREATE_TILE_TYPE(woodSlabHalf_Id, WoodSlabTile_SPU);
+
+	CREATE_TILE_TYPE(chest_Id, ChestTile_SPU);
+
+	CREATE_TILE_TYPE(ironFence_Id, ThinFenceTile_SPU);
+	CREATE_TILE_TYPE(thinGlass_Id, ThinFenceTile_SPU);
+
+	CREATE_TILE_TYPE(fence_Id, FenceTile_SPU);
+	CREATE_TILE_TYPE(netherFence_Id, FenceTile_SPU);
+
+	CREATE_TILE_TYPE(stairs_wood_Id, StairTile_SPU);
+	CREATE_TILE_TYPE(stairs_stone_Id, StairTile_SPU);
+	CREATE_TILE_TYPE(stairs_bricks_Id, StairTile_SPU);	
+	CREATE_TILE_TYPE(stairs_stoneBrickSmooth_Id, StairTile_SPU);
+	CREATE_TILE_TYPE(stairs_netherBricks_Id, StairTile_SPU);
+	CREATE_TILE_TYPE(stairs_sandstone_Id, StairTile_SPU);
+	CREATE_TILE_TYPE(stairs_sprucewood_Id, StairTile_SPU);
+	CREATE_TILE_TYPE(stairs_birchwood_Id, StairTile_SPU);
+	CREATE_TILE_TYPE(stairs_junglewood_Id, StairTile_SPU);
+
+	CREATE_TILE_TYPE(dirt_Id, DirtTile_SPU);
+
+	CREATE_TILE_TYPE(door_iron_Id, DoorTile_SPU);
+	CREATE_TILE_TYPE(door_wood_Id, DoorTile_SPU);
+
+	CREATE_TILE_TYPE(pressurePlate_stone_Id, PressurePlateTile_SPU);
+	CREATE_TILE_TYPE(pressurePlate_wood_Id, PressurePlateTile_SPU);
+
+	CREATE_TILE_TYPE(farmland_Id, FarmTile_SPU);
+
+	CREATE_TILE_TYPE(flower_Id, Bush_SPU);
+	CREATE_TILE_TYPE(rose_Id, Bush_SPU);
+	CREATE_TILE_TYPE(deadBush_Id, Bush_SPU); // DeadBushTile
+
+	CREATE_TILE_TYPE(tallgrass_Id, TallGrass_SPU);
+
+	CREATE_TILE_TYPE(sandStone_Id, SandStoneTile_SPU);
+
+	CREATE_TILE_TYPE(wood_Id, WoodTile_SPU);
+
+	CREATE_TILE_TYPE(treeTrunk_Id, TreeTile_SPU);
+
+	CREATE_TILE_TYPE(leaves_Id, LeafTile_SPU);
+
+	CREATE_TILE_TYPE(crops_Id, CropTile_SPU);
+
+	CREATE_TILE_TYPE(reeds_Id, ReedTile_SPU);
+
+	CREATE_TILE_TYPE(torch_Id, TorchTile_SPU);
+	CREATE_TILE_TYPE(notGate_off_Id, TorchTile_SPU); // TorchTile->NotGateTile
+	CREATE_TILE_TYPE(notGate_on_Id, TorchTile_SPU);	// TorchTile->NotGateTile
+
+	CREATE_TILE_TYPE(mushroom1_Id, Mushroom_SPU);
+	CREATE_TILE_TYPE(mushroom2_Id, Mushroom_SPU);
+
+	CREATE_TILE_TYPE(mobSpawner_Id, MobSpawnerTile_SPU);
+	CREATE_TILE_TYPE(musicBlock_Id, EntityTile_SPU);	// MusicTile->EntityTile
+
+	CREATE_TILE_TYPE(furnace_Id, FurnaceTile_SPU);
+	CREATE_TILE_TYPE(furnace_lit_Id, FurnaceTile_SPU);
+
+	CREATE_TILE_TYPE(web_Id, WebTile_SPU);
+
+	CREATE_TILE_TYPE(water_Id, LiquidTile_SPU);
+	CREATE_TILE_TYPE(lava_Id, LiquidTile_SPU);
+	CREATE_TILE_TYPE(calmLava_Id, LiquidTile_SPU);		// LiquidTileStatic
+	CREATE_TILE_TYPE(calmWater_Id, LiquidTile_SPU);		// LiquidTileStatic
+
+	CREATE_TILE_TYPE(fire_Id, FireTile_SPU);
+
+	CREATE_TILE_TYPE(sapling_Id, Sapling_SPU);
+
+	CREATE_TILE_TYPE(glass_Id, GlassTile_SPU);
+
+	CREATE_TILE_TYPE(ice_Id, IceTile_SPU);
+
+	CREATE_TILE_TYPE(portalTile_Id, PortalTile_SPU);
+
+	CREATE_TILE_TYPE(dispenser_Id, DispenserTile_SPU);
+
+	CREATE_TILE_TYPE(rail_Id, RailTile_SPU);
+	CREATE_TILE_TYPE(goldenRail_Id, RailTile_SPU);
+
+	CREATE_TILE_TYPE(detectorRail_Id, DetectorRailTile_SPU);
+
+	CREATE_TILE_TYPE(tnt_Id, TntTile_SPU);
+
+	CREATE_TILE_TYPE(bookshelf_Id, BookshelfTile_SPU);
+
+	CREATE_TILE_TYPE(workBench_Id, WorkbenchTile_SPU);
+
+	CREATE_TILE_TYPE(sign_Id, SignTile_SPU);
+	CREATE_TILE_TYPE(wallSign_Id, SignTile_SPU);
+
+	CREATE_TILE_TYPE(ladder_Id, LadderTile_SPU);
+
+	CREATE_TILE_TYPE(button_stone_Id, ButtonTile_SPU);
+	CREATE_TILE_TYPE(button_wood_Id, ButtonTile_SPU);
+
+	CREATE_TILE_TYPE(topSnow_Id, TopSnowTile_SPU);
+
+	CREATE_TILE_TYPE(cactus_Id, CactusTile_SPU);
+
+	CREATE_TILE_TYPE(recordPlayer_Id, RecordPlayerTile_SPU);
+
+	CREATE_TILE_TYPE(pumpkin_Id, PumpkinTile_SPU);
+	CREATE_TILE_TYPE(litPumpkin_Id, PumpkinTile_SPU);
+
+	CREATE_TILE_TYPE(cake_Id, CakeTile_SPU);
+
+	CREATE_TILE_TYPE(trapdoor_Id, TrapDoorTile_SPU);
+
+	CREATE_TILE_TYPE(monsterStoneEgg_Id, StoneMonsterTile_SPU);
+
+	CREATE_TILE_TYPE(stoneBrickSmooth_Id, SmoothStoneBrickTile_SPU);
+
+	CREATE_TILE_TYPE(hugeMushroom1_Id, HugeMushroomTile_SPU);
+	CREATE_TILE_TYPE(hugeMushroom2_Id, HugeMushroomTile_SPU);
+
+	CREATE_TILE_TYPE(melon_Id, MelonTile_SPU);
+
+	CREATE_TILE_TYPE(melonStem_Id, StemTile_SPU);
+	CREATE_TILE_TYPE(pumpkinStem_Id, StemTile_SPU);
+
+	CREATE_TILE_TYPE(vine_Id, VineTile_SPU);
+
+	CREATE_TILE_TYPE(mycel_Id, MycelTile_SPU);
+
+	CREATE_TILE_TYPE(waterLily_Id, WaterlilyTile_SPU);
+
+	CREATE_TILE_TYPE(netherStalk_Id, NetherStalkTile_SPU);
+
+	CREATE_TILE_TYPE(enchantTable_Id, EnchantmentTableTile_SPU);
+
+	CREATE_TILE_TYPE(brewingStand_Id, BrewingStandTile_SPU);
+
+	CREATE_TILE_TYPE(diode_on_Id, DiodeTile_SPU);
+	CREATE_TILE_TYPE(diode_off_Id, DiodeTile_SPU);
+
+	CREATE_TILE_TYPE(redStoneDust_Id, RedStoneDustTile_SPU);
+
+	CREATE_TILE_TYPE(fenceGate_Id, FenceGateTile_SPU);
+
+	CREATE_TILE_TYPE(bed_Id, BedTile_SPU);
+
+	CREATE_TILE_TYPE(pistonBase_Id, PistonBaseTile_SPU);
+	CREATE_TILE_TYPE(pistonStickyBase_Id, PistonBaseTile_SPU);
+
+	CREATE_TILE_TYPE(pistonExtensionPiece_Id, PistonExtensionTile_SPU);
+
+	CREATE_TILE_TYPE(pistonMovingPiece_Id, PistonMovingPiece_SPU);
+
+	CREATE_TILE_TYPE(lever_Id, LeverTile_SPU);
+
+	CREATE_TILE_TYPE(cauldron_Id, CauldronTile_SPU);
+
+	CREATE_TILE_TYPE(endPortalTile_Id, TheEndPortal_SPU);
+
+	CREATE_TILE_TYPE(endPortalFrameTile_Id, TheEndPortalFrameTile_SPU);
+
+	CREATE_TILE_TYPE(dragonEgg_Id, EggTile_SPU);
+
+	CREATE_TILE_TYPE(cocoa_Id, CocoaTile_SPU);
+
+	CREATE_TILE_TYPE(redstoneLight_Id, RedlightTile_SPU);
+	CREATE_TILE_TYPE(redstoneLight_lit_Id, RedlightTile_SPU);
+
+	CREATE_TILE_TYPE(skull_Id, SkullTile_SPU);
+
+		// these tile types don't have any additional code that we need.
+	CREATE_TILE_TYPE(stoneBrick_Id, Tile_SPU);		// Tile
+	CREATE_TILE_TYPE(lapisBlock_Id, Tile_SPU);
+	CREATE_TILE_TYPE(redBrick_Id, Tile_SPU);
+	CREATE_TILE_TYPE(mossStone_Id, Tile_SPU);
+	CREATE_TILE_TYPE(netherBrick_Id, Tile_SPU);
+	CREATE_TILE_TYPE(whiteStone_Id, Tile_SPU);
+	CREATE_TILE_TYPE(unbreakable_Id, Tile_SPU);
+	CREATE_TILE_TYPE(sponge_Id, Tile_SPU);
+	CREATE_TILE_TYPE(rock_Id, Tile_SPU);			// StoneTile
+	CREATE_TILE_TYPE(obsidian_Id, Tile_SPU);		// StoneTile->ObsidianTile
+	CREATE_TILE_TYPE(sand_Id, Tile_SPU);			// HeavyTile
+	CREATE_TILE_TYPE(gravel_Id, Tile_SPU);			// GravelTile
+	CREATE_TILE_TYPE(goldOre_Id, Tile_SPU);		// OreTile
+	CREATE_TILE_TYPE(ironOre_Id, Tile_SPU); 		// OreTile
+	CREATE_TILE_TYPE(coalOre_Id, Tile_SPU); 		// OreTile
+	CREATE_TILE_TYPE(lapisOre_Id, Tile_SPU); 		// OreTile	
+	CREATE_TILE_TYPE(diamondOre_Id, Tile_SPU); 	// OreTile
+	CREATE_TILE_TYPE(clay_Id, Tile_SPU);			// ClayTile
+	CREATE_TILE_TYPE(redStoneOre_Id, Tile_SPU);	// RedStoneOreTile
+	CREATE_TILE_TYPE(redStoneOre_lit_Id, Tile_SPU);	// RedStoneOreTile
+	CREATE_TILE_TYPE(goldBlock_Id, Tile_SPU);		// MetalTile
+	CREATE_TILE_TYPE(ironBlock_Id, Tile_SPU);		// MetalTile
+	CREATE_TILE_TYPE(diamondBlock_Id, Tile_SPU);	// MetalTile
+	CREATE_TILE_TYPE(snow_Id, Tile_SPU);			// SnowTile
+	CREATE_TILE_TYPE(hellRock_Id, Tile_SPU);		// HellStoneTile
+	CREATE_TILE_TYPE(hellSand_Id, Tile_SPU);		// HellSandTile
+	CREATE_TILE_TYPE(lightGem_Id, Tile_SPU);		// LightGemTile
+	CREATE_TILE_TYPE(aprilFoolsJoke_Id, Tile_SPU); // LockedChestTile
+
+	CREATE_TILE_TYPE(cloth_Id, ClothTile_SPU); // wool
+
+
+	CREATE_TILE_TYPE(emeraldOre_Id, Tile_SPU);		// OreTile
+	CREATE_TILE_TYPE(enderChest_Id, EnderChestTile_SPU);
+	CREATE_TILE_TYPE(tripWireSource_Id, TripWireSourceTile_SPU);
+	CREATE_TILE_TYPE(tripWire_Id, TripWireTile_SPU);
+// 
+	CREATE_TILE_TYPE(emeraldBlock_Id, Tile_SPU);	// MetalTile
+	CREATE_TILE_TYPE(cobbleWall_Id, WallTile_SPU);
+	CREATE_TILE_TYPE(flowerPot_Id, FlowerPotTile_SPU);
+	CREATE_TILE_TYPE(carrots_Id, CarrotTile_SPU);
+	CREATE_TILE_TYPE(potatoes_Id, PotatoTile_SPU);
+ 	CREATE_TILE_TYPE(anvil_Id, AnvilTile_SPU);
+ 	CREATE_TILE_TYPE(netherQuartz_Id, Tile_SPU);		// OreTile
+ 	CREATE_TILE_TYPE(quartzBlock_Id, QuartzBlockTile_SPU);
+	CREATE_TILE_TYPE(stairs_quartz_Id, StairTile_SPU);
+ 	CREATE_TILE_TYPE(woolCarpet_Id, WoolCarpetTile_SPU);
+
+};
\ No newline at end of file