path: root/Minecraft.Client/PS3/SPU_Tasks/ChunkUpdate/ChunkRebuildData.cpp

#include "stdafx.h"
#ifdef __PS3__
#ifndef SN_TARGET_PS3_SPU
// 	#include "..\..\..\stdafx.h"
#endif
#endif 

#include "ChunkRebuildData.h"
#include "Tesselator_SPU.h"


#ifndef SN_TARGET_PS3_SPU
#include "..\..\..\..\Minecraft.World\Tile.h"
#include "..\..\..\..\Minecraft.World\Level.h"
#include "..\..\..\..\Minecraft.World\Dimension.h"
// 
// #include "..\..\..\Chunk.h"
// #include "..\..\..\TileRenderer.h"
// #include "..\..\..\TileEntityRenderDispatcher.h"
// #include "..\..\..\LevelRenderer.h"
#include "..\..\..\..\Minecraft.World\net.minecraft.world.level.h"
#include "..\..\..\..\Minecraft.World\net.minecraft.world.level.chunk.h"
#include "..\..\..\..\Minecraft.World\net.minecraft.world.level.tile.h"
#include "..\..\..\..\Minecraft.World\net.minecraft.world.level.tile.entity.h"
#include "..\..\..\..\Minecraft.World\Icon.h"
#include "..\..\..\..\Minecraft.World\BiomeSource.h"

#else
 
#include "..\Common\spu_assert.h"

#endif //SN_TARGET_PS3_SPU

static const int Level_maxBuildHeight = 256;
static const int Level_MAX_LEVEL_SIZE = 30000000; 
static const int Level_MAX_BRIGHTNESS = 15;


#include "TileRenderer_SPU.h"
#include "Tile_SPU.h"
#include "ChunkRebuildData.h"
TileData_SPU g_tileSPUData;

static const int MAX_LEVEL_SIZE = 30000000;
static const int MAX_BRIGHTNESS = 15;

#if 0 //def SN_TARGET_PS3_SPU
int ChunkRebuildData::getTile( int x, int y, int z )			{	return m_tileIds[getTileIdx(x,y,z)]; }
int ChunkRebuildData::getBrightnessSky(int x, int y, int z)		{	return m_brightness[getTileIdx(x,y,z)] & 0x0f; }
int ChunkRebuildData::getBrightnessBlock(int x, int y, int z)	{	return m_brightness[getTileIdx(x,y,z)] >> 4; }
int ChunkRebuildData::getData(int x, int y, int z)				{	return m_data_flags[getTileIdx(x,y,z)] & 0x0f; }
int ChunkRebuildData::getGrassColor( int x, int z )				{	return m_grassColor[getTileIdx(x,z)]; }
int ChunkRebuildData::getFoliageColor( int x, int z )			{	return m_foliageColor[getTileIdx(x,z)]; }
int ChunkRebuildData::getFlags(int x, int y, int z)				{	return m_data_flags[getTileIdx(x,y,z)] >> 4; }
void ChunkRebuildData::setFlag(int x, int y, int z, int flag)	{	m_data_flags[getTileIdx(x,y,z)] |= (flag<<4);}
#endif 



void ChunkRebuildData::disableUnseenTiles()
{
	// We now go through the vertical section of this level chunk that we are interested in and try and establish
	// (1) if it is completely empty
	// (2) if any of the tiles can be quickly determined to not need rendering because they are in the middle of other tiles and
	//     so can't be seen. A large amount (> 60% in tests) of tiles that call tesselateInWorld in the unoptimised version
	//     of this function fall into this category. By far the largest category of these are tiles in solid regions of rock.
	int startX = m_x0+2;	// beginning of the chunk
	int startY = m_y0+2;	// beginning of the chunk
	int startZ = m_z0+2;	// beginning of the chunk

	for(int iX=startX; iX<(startX+16); iX++)
	{
		for(int iY=startY; iY<(startY+16); iY++)
		{
			for(int iZ=startZ; iZ<(startZ+16); iZ++)
			{
				int tileID = getTile(iX,iY,iZ);
				if( tileID == 0 )  continue;
				m_flags &= ~e_flag_EmptyChunk;
				

				// Don't bother trying to work out neighbours for this tile if we are at the edge of the chunk - apart from the very
				// bottom of the world where we shouldn't ever be able to see
				if( iY == 127 ) continue;
				if(( iX-startX == 0 ) || ( iX-startX == 15 )) continue;
				if(( iZ-startZ == 0 ) || ( iZ-startZ == 15 )) continue;

				int flags = getFlags(iX, iY, iZ);

				// Establish whether this tile and its neighbours are all made of rock, dirt, unbreakable tiles, or have already
				// been determined to meet this criteria themselves and have a tile of 255 set.
				if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
				tileID = getTile(iX-1, iY, iZ);
				flags = getFlags(iX-1, iY, iZ);
				if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
				tileID = getTile(iX+1, iY, iZ);
				flags = getFlags(iX+1, iY, iZ);
				if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
				tileID = getTile(iX, iY, iZ-1);
				flags = getFlags(iX, iY, iZ-1);
				if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
				tileID = getTile(iX, iY, iZ+1);
				flags = getFlags(iX, iY, iZ+1);
				if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
				// Treat the bottom of the world differently - we shouldn't ever be able to look up at this, so consider tiles as invisible
				// if they are surrounded on sides other than the bottom
				if( iY > 0 )
				{
					tileID = getTile(iX, iY-1, iZ);
					flags = getFlags(iX, iY-1, iZ);
					if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
				}
				tileID = getTile(iX, iY+1, iZ);
				flags = getFlags(iX, iY+1, iZ);
				if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;

				// This tile is surrounded. Flag it as not requiring to be rendered by setting its id to 255.
				setFlag(iX, iY, iZ, e_flag_NoRender);
			}
		}
	}
}
 
#ifndef SN_TARGET_PS3_SPU

void setIconSPUFromIcon(Icon_SPU* iconSpu, Icon* icon)
{
	iconSpu->set(icon->getX(), icon->getY(), icon->getWidth(), icon->getHeight(), icon->getSourceWidth(), icon->getSourceHeight());
}

void ChunkRebuildData::buildMaterial(int matSPUIndex, Material* mat)
{
	Material_SPU* matSPU = &m_tileData.materials[matSPUIndex];
	matSPU->id = matSPUIndex;
	matSPU->color = mat->color->col;
	matSPU->flags =0;
	matSPU->flags |= mat->isFlammable() ? Material_SPU::e_flammable : 0;
	matSPU->flags |= mat->isReplaceable() ? Material_SPU::e_replaceable : 0;
	matSPU->flags |= mat->_neverBuildable ? Material_SPU::e_neverBuildable : 0;
	matSPU->flags |= mat->isSolid() ? Material_SPU::e_isSolid : 0;
	matSPU->flags |= mat->isLiquid() ? Material_SPU::e_isLiquid : 0;
	matSPU->flags |= mat->blocksLight() ? Material_SPU::e_blocksLight : 0;
	matSPU->flags |= mat->blocksMotion() ? Material_SPU::e_blocksMotion : 0;
}

void ChunkRebuildData::buildMaterials()
{
	buildMaterial(Material_SPU::air_Id,					Material::air);					
	buildMaterial(Material_SPU::grass_Id,				Material::grass);				
	buildMaterial(Material_SPU::dirt_Id,				Material::dirt);				
	buildMaterial(Material_SPU::wood_Id,				Material::wood);				
	buildMaterial(Material_SPU::stone_Id,				Material::stone);				
	buildMaterial(Material_SPU::metal_Id,				Material::metal);				
	buildMaterial(Material_SPU::water_Id,				Material::water);				
	buildMaterial(Material_SPU::lava_Id,				Material::lava);				
	buildMaterial(Material_SPU::leaves_Id,				Material::leaves);				
	buildMaterial(Material_SPU::plant_Id,				Material::plant);				
	buildMaterial(Material_SPU::replaceable_plant_Id,	Material::replaceable_plant);	
	buildMaterial(Material_SPU::sponge_Id,				Material::sponge);				
	buildMaterial(Material_SPU::cloth_Id,				Material::cloth);				
	buildMaterial(Material_SPU::fire_Id,				Material::fire);				
	buildMaterial(Material_SPU::sand_Id,				Material::sand);				
	buildMaterial(Material_SPU::decoration_Id,			Material::decoration);		
	buildMaterial(Material_SPU::clothDecoration_Id,		Material::clothDecoration);		
	buildMaterial(Material_SPU::glass_Id,				Material::glass);				
	buildMaterial(Material_SPU::explosive_Id,			Material::explosive);			
	buildMaterial(Material_SPU::coral_Id,				Material::coral);				
	buildMaterial(Material_SPU::ice_Id,					Material::ice);					
	buildMaterial(Material_SPU::topSnow_Id,				Material::topSnow);				
	buildMaterial(Material_SPU::snow_Id,				Material::snow);				
	buildMaterial(Material_SPU::cactus_Id,				Material::cactus);				
	buildMaterial(Material_SPU::clay_Id,				Material::clay);				
	buildMaterial(Material_SPU::vegetable_Id,			Material::vegetable);			
	buildMaterial(Material_SPU::egg_Id,					Material::egg);					
	buildMaterial(Material_SPU::portal_Id,				Material::portal);				
	buildMaterial(Material_SPU::cake_Id,				Material::cake);				
	buildMaterial(Material_SPU::web_Id,					Material::web);					
	buildMaterial(Material_SPU::piston_Id,				Material::piston);				
	buildMaterial(Material_SPU::buildable_glass_Id,		Material::buildable_glass);				
	buildMaterial(Material_SPU::heavyMetal_Id,			Material::heavyMetal);				
}

int ChunkRebuildData::getMaterialID(Tile* pTile)
{
	Material* m = pTile->material;
	if(m == Material::air)  			return Material_SPU::air_Id;					
	if(m == Material::grass)  			return Material_SPU::grass_Id;					
	if(m == Material::dirt)  			return Material_SPU::dirt_Id;				
	if(m == Material::wood)  			return Material_SPU::wood_Id;				
	if(m == Material::stone)  			return Material_SPU::stone_Id;					
	if(m == Material::metal)  			return Material_SPU::metal_Id;					
	if(m == Material::water)  			return Material_SPU::water_Id;					
	if(m == Material::lava)  			return Material_SPU::lava_Id;				
	if(m == Material::leaves)  			return Material_SPU::leaves_Id;					
	if(m == Material::plant)  			return Material_SPU::plant_Id;					
	if(m == Material::replaceable_plant)return Material_SPU::replaceable_plant_Id;		
	if(m == Material::sponge)  			return Material_SPU::sponge_Id;					
	if(m == Material::cloth)  			return Material_SPU::cloth_Id;					
	if(m == Material::fire)  			return Material_SPU::fire_Id;				
	if(m == Material::sand)  			return Material_SPU::sand_Id;				
	if(m == Material::decoration)  		return Material_SPU::decoration_Id;			
	if(m == Material::clothDecoration)  return Material_SPU::clothDecoration_Id;			
	if(m == Material::glass)  			return Material_SPU::glass_Id;
	if(m == Material::explosive)  		return Material_SPU::explosive_Id;				
	if(m == Material::coral)  			return Material_SPU::coral_Id;					
	if(m == Material::ice)  			return Material_SPU::ice_Id;					
	if(m == Material::topSnow)  		return Material_SPU::topSnow_Id;				
	if(m == Material::snow)  			return Material_SPU::snow_Id;				
	if(m == Material::cactus)  			return Material_SPU::cactus_Id;					
	if(m == Material::clay)  			return Material_SPU::clay_Id;				
	if(m == Material::vegetable)  		return Material_SPU::vegetable_Id;				
	if(m == Material::egg)  			return Material_SPU::egg_Id;					
	if(m == Material::portal)  			return Material_SPU::portal_Id;					
	if(m == Material::cake)  			return Material_SPU::cake_Id;				
	if(m == Material::web)  			return Material_SPU::web_Id;					
	if(m == Material::piston)  			return Material_SPU::piston_Id;					
	if(m == Material::buildable_glass)	return Material_SPU::buildable_glass_Id;
	if(m == Material::heavyMetal)		return Material_SPU::heavyMetal_Id;
	assert(0);	
	return Material_SPU::air_Id;
}


void ChunkRebuildData::createTileData()
{
	// build the material data
	buildMaterials();

	// build the tile data
	for(int i=0;i<256;i++)
	{
		m_tileData.mipmapEnable.set(i, Tile::mipmapEnable[i]);
		m_tileData.solid.set(i, Tile::solid[i]);
		m_tileData.transculent.set(i, Tile::transculent[i]);
//		m_tileData._sendTileData.set(i, Tile::_sendTileData[i]);
		m_tileData.propagate.set(i, Tile::propagate[i]);
		m_tileData.lightBlock[i] = Tile::lightBlock[i];
		m_tileData.lightEmission[i] = Tile::lightEmission[i];
		if(Tile::tiles[i])
		{
			m_tileData.signalSource.set(i, Tile::tiles[i]->isSignalSource());
			m_tileData.cubeShaped.set(i, Tile::tiles[i]->isCubeShaped());

			m_tileData.xx0[i] = static_cast<float>(Tile::tiles[i]->getShapeX0());
			m_tileData.yy0[i] = static_cast<float>(Tile::tiles[i]->getShapeY0());
			m_tileData.zz0[i] = static_cast<float>(Tile::tiles[i]->getShapeZ0());
			m_tileData.xx1[i] = static_cast<float>(Tile::tiles[i]->getShapeX1());
			m_tileData.yy1[i] = static_cast<float>(Tile::tiles[i]->getShapeY1());
			m_tileData.zz1[i] = static_cast<float>(Tile::tiles[i]->getShapeZ1());
			Icon* pTex = Tile::tiles[i]->icon;
			if(pTex)
			{
				setIconSPUFromIcon(&m_tileData.iconData[i], pTex);
			}
			m_tileData.materialIDs[i] = getMaterialID(Tile::tiles[i]);
		}
	}
	m_tileData.leafTile_allowSame = Tile::leaves->allowSame;
	m_tileData.leafTile_fancyTextureSet = Tile::leaves->fancyTextureSet;


	// Custom tile textures
	// get the width and height of any texture, since everything uses the same texture
	m_tileData.iconTexWidth = Tile::grass->iconTop->getSourceWidth();
	m_tileData.iconTexHeight = Tile::grass->iconTop->getSourceHeight();
	// Grass tile
	setIconSPUFromIcon(&m_tileData.grass_iconTop, Tile::grass->iconTop);
	setIconSPUFromIcon(&m_tileData.grass_iconSnowSide, Tile::grass->iconSnowSide);
	setIconSPUFromIcon(&m_tileData.grass_iconSideOverlay, Tile::grass->iconSideOverlay);

	// ThinFence
	setIconSPUFromIcon(&m_tileData.ironFence_EdgeTexture, static_cast<ThinFenceTile *>(Tile::ironFence)->getEdgeTexture());
	setIconSPUFromIcon(&m_tileData.thinGlass_EdgeTexture, static_cast<ThinFenceTile *>(Tile::thinGlass)->getEdgeTexture());

	//FarmTile
	setIconSPUFromIcon(&m_tileData.farmTile_Dry, static_cast<FarmTile *>(Tile::farmland)->iconDry);
	setIconSPUFromIcon(&m_tileData.farmTile_Wet, static_cast<FarmTile *>(Tile::farmland)->iconWet);

	// DoorTile
	for(int i=0;i<8; i++)
	{
		setIconSPUFromIcon(&m_tileData.doorTile_Icons[i], static_cast<DoorTile *>(Tile::door_wood)->icons[i]);
		// we're not supporting flipped icons, so manually flip here
		if(i>=4)
			m_tileData.doorTile_Icons[i].flipHorizontal();
	}

	// TallGrass
	for(int i=0;i<3; i++)
		setIconSPUFromIcon(&m_tileData.tallGrass_Icons[i], Tile::tallgrass->icons[i]);

	// SandStoneTile
	for(int i=0;i<3; i++)
		setIconSPUFromIcon(&m_tileData.sandStone_icons[i], static_cast<SandStoneTile *>(Tile::sandStone)->icons[i]);
	setIconSPUFromIcon(&m_tileData.sandStone_iconTop, static_cast<SandStoneTile *>(Tile::sandStone)->iconTop);
	setIconSPUFromIcon(&m_tileData.sandStone_iconBottom, static_cast<SandStoneTile *>(Tile::sandStone)->iconBottom);

	// WoodTile
// 	assert(WoodTile_SPU::WOOD_NAMES_LENGTH == 4);
	for(int i=0;i<4; i++)
		setIconSPUFromIcon(&m_tileData.woodTile_icons[i], static_cast<WoodTile *>(Tile::wood)->icons[i]);

	// TreeTile
// 	assert(TreeTile_SPU::TREE_NAMES_LENGTH == 4);
	for(int i=0;i<4; i++)
		setIconSPUFromIcon(&m_tileData.treeTile_icons[i], static_cast<TreeTile *>(Tile::treeTrunk)->icons[i]);
	setIconSPUFromIcon(&m_tileData.treeTile_iconTop, static_cast<TreeTile *>(Tile::treeTrunk)->iconTop);

	// LeafTile
	for(int i=0;i<2; i++)
		for(int j=0;j<4;j++)
			setIconSPUFromIcon(&m_tileData.leafTile_icons[i][j], ((LeafTile*)Tile::leaves)->icons[i][j]);

	// CropTile
	for(int i=0;i<8; i++)
		setIconSPUFromIcon(&m_tileData.cropTile_icons[i], static_cast<CropTile *>(Tile::crops)->icons[i]);

	// FurnaceTile
	setIconSPUFromIcon(&m_tileData.furnaceTile_iconTop, static_cast<FurnaceTile *>(Tile::furnace)->iconTop);
	setIconSPUFromIcon(&m_tileData.furnaceTile_iconFront, static_cast<FurnaceTile *>(Tile::furnace)->iconFront);
	setIconSPUFromIcon(&m_tileData.furnaceTile_iconFront_lit, static_cast<FurnaceTile *>(Tile::furnace_lit)->iconFront);

	//LiquidTile
	setIconSPUFromIcon(&m_tileData.liquidTile_iconWaterStill, (Tile::water)->icons[0]);
	setIconSPUFromIcon(&m_tileData.liquidTile_iconWaterFlow, (Tile::water)->icons[1]);
	setIconSPUFromIcon(&m_tileData.liquidTile_iconLavaStill, (Tile::lava)->icons[0]);
	setIconSPUFromIcon(&m_tileData.liquidTile_iconLavaFlow, (Tile::lava)->icons[1]);

	//FireTile
	for(int i=0;i<2;i++)
		setIconSPUFromIcon(&m_tileData.fireTile_icons[i], (Tile::fire)->icons[i]);

	// Sapling
	for(int i=0;i<4;i++)
		setIconSPUFromIcon(&m_tileData.sapling_icons[i], static_cast<Sapling *>(Tile::sapling)->icons[i]);

	m_tileData.glassTile_allowSame = static_cast<GlassTile *>(Tile::glass)->allowSame;
	m_tileData.iceTile_allowSame = static_cast<IceTile *>(Tile::ice)->allowSame;

	// DispenserTile
	setIconSPUFromIcon(&m_tileData.dispenserTile_iconTop, static_cast<DispenserTile *>(Tile::dispenser)->iconTop);
	setIconSPUFromIcon(&m_tileData.dispenserTile_iconFront, static_cast<DispenserTile *>(Tile::dispenser)->iconFront);
	setIconSPUFromIcon(&m_tileData.dispenserTile_iconFrontVertical, static_cast<DispenserTile *>(Tile::dispenser)->iconFrontVertical);

	// RailTile
	setIconSPUFromIcon(&m_tileData.railTile_iconTurn, static_cast<RailTile *>(Tile::rail)->iconTurn);
	setIconSPUFromIcon(&m_tileData.railTile_iconTurnGolden, static_cast<RailTile *>(Tile::goldenRail)->iconTurn);

	for(int i=0;i<2;i++)
		setIconSPUFromIcon(&m_tileData.detectorRailTile_icons[i], static_cast<DetectorRailTile *>(Tile::detectorRail)->icons[i]);

	// tntTile
	setIconSPUFromIcon(&m_tileData.tntTile_iconBottom, static_cast<TntTile *>(Tile::tnt)->iconBottom);
	setIconSPUFromIcon(&m_tileData.tntTile_iconTop, static_cast<TntTile *>(Tile::tnt)->iconTop);

	// workbenchTile
	setIconSPUFromIcon(&m_tileData.workBench_iconFront, static_cast<WorkbenchTile *>(Tile::workBench)->iconFront);
	setIconSPUFromIcon(&m_tileData.workBench_iconTop, static_cast<WorkbenchTile *>(Tile::workBench)->iconTop);

	// cactusTile
	setIconSPUFromIcon(&m_tileData.cactusTile_iconTop, static_cast<CactusTile *>(Tile::cactus)->iconTop);
	setIconSPUFromIcon(&m_tileData.cactusTile_iconBottom, static_cast<CactusTile *>(Tile::cactus)->iconBottom);

	// recordPlayer
	setIconSPUFromIcon(&m_tileData.recordPlayer_iconTop, static_cast<RecordPlayerTile *>(Tile::recordPlayer)->iconTop);

	// pumpkin 
	setIconSPUFromIcon(&m_tileData.pumpkinTile_iconTop, static_cast<PumpkinTile *>(Tile::pumpkin)->iconTop);
	setIconSPUFromIcon(&m_tileData.pumpkinTile_iconFace, static_cast<PumpkinTile *>(Tile::pumpkin)->iconFace);
	setIconSPUFromIcon(&m_tileData.pumpkinTile_iconFaceLit, static_cast<PumpkinTile *>(Tile::litPumpkin)->iconFace);

	// cakeTile 
	setIconSPUFromIcon(&m_tileData.cakeTile_iconTop, static_cast<CakeTile *>(Tile::cake)->iconTop);
	setIconSPUFromIcon(&m_tileData.cakeTile_iconBottom, static_cast<CakeTile *>(Tile::cake)->iconBottom);
	setIconSPUFromIcon(&m_tileData.cakeTile_iconInner, static_cast<CakeTile *>(Tile::cake)->iconInner);

	// SmoothStoneBrickTile
	for(int i=0;i<4;i++)
		setIconSPUFromIcon(&m_tileData.smoothStoneBrick_icons[i], static_cast<SmoothStoneBrickTile *>(Tile::stoneBrickSmooth)->icons[i]);

	// HugeMushroomTile
	for(int i=0;i<2;i++)
		setIconSPUFromIcon(&m_tileData.hugeMushroom_icons[i], static_cast<HugeMushroomTile *>(Tile::hugeMushroom1)->icons[i]);
	setIconSPUFromIcon(&m_tileData.hugeMushroom_iconStem, static_cast<HugeMushroomTile *>(Tile::hugeMushroom1)->iconStem);
	setIconSPUFromIcon(&m_tileData.hugeMushroom_iconInside, static_cast<HugeMushroomTile *>(Tile::hugeMushroom1)->iconInside);


	// MelonTile
	setIconSPUFromIcon(&m_tileData.melonTile_iconTop, static_cast<MelonTile *>(Tile::melon)->iconTop);

	// StemTile
	setIconSPUFromIcon(&m_tileData.stemTile_iconAngled, static_cast<StemTile *>(Tile::melonStem)->iconAngled);

	// MycelTile
	setIconSPUFromIcon(&m_tileData.mycelTile_iconTop, (Tile::mycel)->iconTop);
	setIconSPUFromIcon(&m_tileData.mycelTile_iconSnowSide, (Tile::mycel)->iconSnowSide);

	// NetherStalkTile
	for(int i=0;i<3;i++)
		setIconSPUFromIcon(&m_tileData.netherStalk_icons[i], static_cast<NetherStalkTile *>(Tile::netherStalk)->icons[i]);

	// EnchantmentTableTile
	setIconSPUFromIcon(&m_tileData.enchantmentTable_iconTop, static_cast<EnchantmentTableTile *>(Tile::enchantTable)->iconTop);
	setIconSPUFromIcon(&m_tileData.enchantmentTable_iconBottom, static_cast<EnchantmentTableTile *>(Tile::enchantTable)->iconBottom);

	//BrewingStandTile
	setIconSPUFromIcon(&m_tileData.brewingStand_iconBase, static_cast<BrewingStandTile *>(Tile::brewingStand)->iconBase);

	//RedStoneDust
	setIconSPUFromIcon(&m_tileData.redStoneDust_iconCross, (Tile::redStoneDust)->iconCross);
	setIconSPUFromIcon(&m_tileData.redStoneDust_iconCross, (Tile::redStoneDust)->iconLine);
	setIconSPUFromIcon(&m_tileData.redStoneDust_iconCrossOver, (Tile::redStoneDust)->iconCrossOver);
	setIconSPUFromIcon(&m_tileData.redStoneDust_iconLineOver, (Tile::redStoneDust)->iconLineOver);

	setIconSPUFromIcon(&m_tileData.stoneSlab_iconSide, static_cast<StoneSlabTile *>(Tile::stoneSlab)->iconSide);

	for(int i=0;i<16;i++)
		setIconSPUFromIcon(&m_tileData.clothTile_icons[i], static_cast<ClothTile *>(Tile::cloth)->icons[i]);

	// CarrotTile
	for(int i=0;i<4;i++)
		setIconSPUFromIcon(&m_tileData.carrot_icons[i], static_cast<CarrotTile *>(Tile::carrots)->icons[i]);

	// PotatoTile
	for(int i=0;i<4;i++)
		setIconSPUFromIcon(&m_tileData.potato_icons[i], static_cast<PotatoTile *>(Tile::potatoes)->icons[i]);

	// AnvilTile
	for(int i=0;i<3;i++)
		setIconSPUFromIcon(&m_tileData.anvil_icons[i], static_cast<AnvilTile *>(Tile::anvil)->icons[i]);


	// QuartzBlockTile
	for(int i=0;i<5;i++)
		setIconSPUFromIcon(&m_tileData.quartzBlock_icons[i], static_cast<QuartzBlockTile *>(Tile::quartzBlock)->icons[i]);

	setIconSPUFromIcon(&m_tileData.quartzBlock_iconChiseledTop, static_cast<QuartzBlockTile *>(Tile::quartzBlock)->iconChiseledTop);
	setIconSPUFromIcon(&m_tileData.quartzBlock_iconLinesTop, static_cast<QuartzBlockTile *>(Tile::quartzBlock)->iconLinesTop);
	setIconSPUFromIcon(&m_tileData.quartzBlock_iconTop, static_cast<QuartzBlockTile *>(Tile::quartzBlock)->iconTop);
	setIconSPUFromIcon(&m_tileData.quartzBlock_iconBottom, static_cast<QuartzBlockTile *>(Tile::quartzBlock)->iconBottom);
}

// extern int g_lastHitBlockX;
// extern int g_lastHitBlockY;
// extern int g_lastHitBlockZ;

void ChunkRebuildData::buildForChunk( Region* region, Level* level, int x0, int y0, int z0 )
{
	static  bool bCreatedTileData = false;
	if(!bCreatedTileData)
	{
		createTileData();
		bCreatedTileData = true;
	}

	m_tileData.stemTile_minColour = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Tile_StemMin );
	m_tileData.stemTile_maxColour = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Tile_StemMax );
	m_tileData.waterLily_colour = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Tile_WaterLily );

	m_tileData.foliageColor_evergreenColor =  FoliageColor::getEvergreenColor();
	m_tileData.foliageColor_birchColor = FoliageColor::getBirchColor();


// 	m_lastHitBlockX = g_lastHitBlockX;
// 	m_lastHitBlockY = g_lastHitBlockY;
// 	m_lastHitBlockZ = g_lastHitBlockZ;

	m_x0 = x0-2;
	m_y0 = y0-2;
	m_z0 = z0-2;
	m_pRegion = region;
	m_flags = 0;//e_flag_EmptyChunk;

// 	for(int iX=m_x0; iX<(m_x0+sc_size); iX++)
// 	{
// 		for(int iY=m_y0; iY<(m_y0+sc_size); iY++)
// 		{
// 			for(int iZ=m_z0; iZ<(m_z0+sc_size); iZ++)
// 			{
// 				buildTile(iX, iY, iZ);
// 			}
// 		}
// 	}

	BiomeCache::Block* cacheBlocks[9];
	cacheBlocks[0] = region->getBiomeSource()->getBlockAt(m_x0, m_z0);
	cacheBlocks[1] = region->getBiomeSource()->getBlockAt(m_x0+2, m_z0);
	cacheBlocks[2] = region->getBiomeSource()->getBlockAt(m_x0+18, m_z0);

	cacheBlocks[3] = region->getBiomeSource()->getBlockAt(m_x0, m_z0+2);
	cacheBlocks[4] = region->getBiomeSource()->getBlockAt(m_x0+2, m_z0+2);
	cacheBlocks[5] = region->getBiomeSource()->getBlockAt(m_x0+18, m_z0+2);

	cacheBlocks[6] = region->getBiomeSource()->getBlockAt(m_x0, m_z0+18);
	cacheBlocks[7] = region->getBiomeSource()->getBlockAt(m_x0+2, m_z0+18);
	cacheBlocks[8] = region->getBiomeSource()->getBlockAt(m_x0+18, m_z0+18);

	int cacheMap[20] = { 0,0,  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  2,2};

	ColourTable* pColourTable = Minecraft::GetInstance()->getColourTable();

	for(int iX=m_x0; iX<(m_x0+sc_size); iX++)
	{
		for(int iZ=m_z0; iZ<(m_z0+sc_size); iZ++)
		{
			int newX = ( iX - m_x0 );
			int newZ = ( iZ - m_z0 );
			int index = (newX*sc_size) + newZ;
//			assert(index < 400);
			int cacheBlockIndex = (cacheMap[iZ-m_z0]*3) + cacheMap[iX-m_x0];
			BiomeCache::Block* pCacheBlock = cacheBlocks[cacheBlockIndex];
//			assert(region->getBiomeSource()->getBlockAt(iX, iZ) == pCacheBlock);		
			Biome* pBiome = pCacheBlock->getBiome(iX, iZ);
			m_grassColor[index] = pColourTable->getColor(pBiome->m_grassColor);
			m_foliageColor[index] =  pColourTable->getColor(pBiome->m_foliageColor);
			m_waterColor[index] =  pColourTable->getColor(pBiome->m_waterColor);
		}
	}

	if(isEmptyChunk())
		return;


	if(level->dimension->hasCeiling)
		m_flags |= e_flag_HasCeiling;
	for(int i=0;i<16;i++)
		m_brightnessRamp[i] = level->dimension->brightnessRamp[i];
	m_levelSkyDarken = level->skyDarken;
}

void ChunkRebuildData::copyFromTesselator()
{
	Tesselator* t = Tesselator::getInstance(); // 4J - added - static initialiser being set at the wrong time

	m_tesselator.m_PPUArray = t->_array->data;
	assert(t->p == 0);
	m_tesselator.m_PPUOffset = 0;

	// copy tesselator vars over
	m_tesselator.vertices = t->vertices;																																																																																																																					
	m_tesselator.u = t->u;
	m_tesselator.v = t->v;
	m_tesselator._tex2 = t->_tex2;
	m_tesselator.col = t->col;
	m_tesselator.hasColor = t->hasColor;
	m_tesselator.hasTexture = t->hasTexture;
	m_tesselator.hasTexture2 = t->hasTexture2;
	m_tesselator.hasNormal = t->hasNormal;
	m_tesselator.p = t->p;
	m_tesselator.useCompactFormat360 = t->useCompactFormat360;
	m_tesselator.useProjectedTexturePixelShader = t->useProjectedTexturePixelShader;
	m_tesselator.count = t->count;
	m_tesselator._noColor = t->_noColor;
	m_tesselator.mode = t->mode;
	m_tesselator.xo = t->xo;
	m_tesselator.yo = t->yo;
	m_tesselator.zo = t->zo;
	m_tesselator.count = t->count	;
	m_tesselator._normal = t->_normal;
	m_tesselator.tesselating = t->tesselating;
	m_tesselator.mipmapEnable = t->mipmapEnable;	// 4J added
	m_tesselator.vboId = t->vboId;
	m_tesselator.vboCounts = t->vboCounts;
	m_tesselator.size = t->size;
	for(int i=0;i<6;i++)
		m_tesselator.bounds.boundingBox[i] = t->bounds.boundingBox[i];

}


void ChunkRebuildData::buildTile(int x, int y, int z)
{
	int newX = ( x - m_x0 );
	int newY = ( y - m_y0 );
	int newZ = ( z - m_z0 );

	int index = (newX*sc_size*sc_size) + (newY*sc_size) + newZ;

 	m_tileIds[index] = m_pRegion->getTile(x, y, z);
	m_brightness[index] = m_pRegion->getBrightness(LightLayer::Sky, x, y, z);
	m_brightness[index] |= (m_pRegion->getBrightness(LightLayer::Block, x, y, z)) << 4;
	m_data_flags[index] = m_pRegion->getData(x,y,z);
}


void ChunkRebuildData::storeInTesselator()
{
	Tesselator* t = Tesselator::getInstance(); // 4J - added - static initialiser being set at the wrong time

	// copy tesselator vars over
	t->vertices = m_tesselator.vertices;																																																																																																																					
	t->u = m_tesselator.u;
	t->v = m_tesselator.v;
	t->_tex2 = m_tesselator._tex2;
	t->col = m_tesselator.col;
	t->hasColor = m_tesselator.hasColor;
	t->hasTexture = m_tesselator.hasTexture;
	t->hasTexture2 = m_tesselator.hasTexture2;
	t->hasNormal = m_tesselator.hasNormal;
	t->p = m_tesselator.m_PPUOffset/4;
	t->useCompactFormat360 = m_tesselator.useCompactFormat360;
	t->useProjectedTexturePixelShader = m_tesselator.useProjectedTexturePixelShader;
	t->count = m_tesselator.count;
	t->_noColor = m_tesselator._noColor;
	t->mode = m_tesselator.mode;
	t->xo = m_tesselator.xo;
	t->yo = m_tesselator.yo;
	t->zo = m_tesselator.zo;
	t->count = m_tesselator.count;
	t->_normal = m_tesselator._normal;
	t->tesselating = m_tesselator.tesselating;
	t->mipmapEnable = m_tesselator.mipmapEnable;	// 4J added
	t->vboId = m_tesselator.vboId;
	t->vboCounts = m_tesselator.vboCounts;
	t->size = m_tesselator.size;
	for(int i=0;i<6;i++)
		t->bounds.boundingBox[i] = m_tesselator.bounds.boundingBox[i];
}
#endif // SN_TARGET_PS3_SPU



void ChunkRebuildData::tesselateAllTiles(TileRenderer_SPU* pTileRenderer)
{
	Tile_SPU::ms_pTileData = &m_tileData;
	// 4J - changed loop order here to leave y as the innermost loop for better cache performance
	bool renderNextLayer = false;
	bool rendered = false;
	int numRenderedLayer0 = 0;
	int startX = m_x0+2;	// beginning of the chunk
	int startY = m_y0+2;	// beginning of the chunk
	int startZ = m_z0+2;	// beginning of the chunk

	m_tesselator.beginData();
	for (int z = startZ; z < (startZ+16); z++)
	{
		for (int x = startX; x < (startX+16); x++)
		{
			for (int y = startY; y < (startY+16); y++)
			{
				// 4J - get tile from those copied into our local array in earlier optimisation
				int flags = getFlags(x,y,z);
				if(flags & ChunkRebuildData::e_flag_NoRender)
					continue;
				unsigned char tileId = getTile(x,y,z);
				if (tileId > 0)
				{
// 					if (m_currentLayer == 0 && m_tileData.isEntityTile[tileId])
// 					{
// 						shared_ptr<TileEntity> et = region->getTileEntity(x, y, z);
// 						if (TileEntityRenderDispatcher::instance->hasRenderer(et))
// 						{
// 							renderableTileEntities.push_back(et);
// 						}
// 					}
					TileRef_SPU tile(tileId);
					int renderLayer = tile->getRenderLayer();

					if (renderLayer != m_currentLayer)
					{
						renderNextLayer = true;
					}
					else //if (renderLayer == m_currentLayer)
					{
						if(pTileRenderer->hasRenderer(tile.getPtr()))
						{
							numRenderedLayer0++;
							rendered |= pTileRenderer->tesselateInWorld(tile.getPtr(), x, y, z);
						}
						else
						{
							setFlag(x, y, z, e_flag_SPURenderCodeMissing);
// #ifdef SN_TARGET_PS3_SPU
// 							spu_print("Render code missing for tile ID %d : render shape %d\n", tile->id, tile->getRenderShape());
// #endif

						}
					}
				}
			}
		}
	}
	if(rendered)
		m_flags |= e_flag_Rendered;

// 	spu_print("(%d,%d,%d) SPU num rendered : %d\n", m_x0+2, m_y0+2, m_z0+2,  numRenderedLayer0);

	m_tesselator.endData();
}

bool ChunkRebuildData::isEmptyTile(int x, int y, int z)
{
	return getTile(x, y, z) == 0;
}

bool ChunkRebuildData::isSolidRenderTile(int x, int y, int z)
{
	TileRef_SPU tile(getTile(x,y,z));
	if (tile.getPtr() == nullptr) return false;


	// 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 Tile::getTexture which makes such solid tiles actually visibly solid (these
	// textures exist already for 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
	if( tile->id == Tile_SPU::leaves_Id )
	{
		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; i++ )
		{
			int t = 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() ) )
			{
				return false;
			}
		}
		return true;
	}

	return tile->isSolidRender();
}


bool ChunkRebuildData::isSolidBlockingTile(int x, int y, int z)
{
	TileRef_SPU tile(getTile(x, y, z));
	if (tile.getPtr() == nullptr) return false;
	bool ret =  tile->getMaterial()->blocksMotion() && tile->isCubeShaped();
	return ret;
}

float ChunkRebuildData::getBrightness(int x, int y, int z, int emitt)
{
	int n = getRawBrightness(x, y, z);
	if (n < emitt) n = emitt;
	return m_brightnessRamp[n];
}

float ChunkRebuildData::getBrightness(int x, int y, int z)
{
	return m_brightnessRamp[getRawBrightness(x, y, z)];
}

// 4J - brought forward from 1.8.2
int ChunkRebuildData::getBrightness(LightLayer::variety layer, int x, int y, int z)
{
#ifndef SN_TARGET_PS3_SPU
	assert(Level_MAX_LEVEL_SIZE == Level::MAX_LEVEL_SIZE);
	assert(Level_maxBuildHeight == Level::maxBuildHeight);
	assert(Level_MAX_BRIGHTNESS == Level::MAX_BRIGHTNESS);
#endif

	if (y < 0) y = 0;
	if (y >= Level_maxBuildHeight) y = Level_maxBuildHeight - 1;
	if (y < 0 || y >= Level_maxBuildHeight || x < -Level_MAX_LEVEL_SIZE || z < -Level_MAX_LEVEL_SIZE || x >= Level_MAX_LEVEL_SIZE || z > Level_MAX_LEVEL_SIZE)
	{
		// 4J Stu - The java LightLayer was an enum class type with a member "surrounding" which is what we
		// were returning here. Surrounding has the same value as the enum value in our C++ code, so just cast
		// it to an int
		return (int)layer;
	}

	if(layer == LightLayer::Sky)
		return getBrightnessSky(x, y, z);
	return getBrightnessBlock(x, y, z);
}

// 4J - brought forward from 1.8.2
int ChunkRebuildData::getBrightnessPropagate(LightLayer::variety layer, int x, int y, int z)
{
	if (y < 0) y = 0;
	if (y >= Level_maxBuildHeight) y = Level_maxBuildHeight - 1;
	if (y < 0 || y >= Level_maxBuildHeight || x < -Level_MAX_LEVEL_SIZE || z < -Level_MAX_LEVEL_SIZE || x >= Level_MAX_LEVEL_SIZE || z > Level_MAX_LEVEL_SIZE)
	{
		// 4J Stu - The java LightLayer was an enum class type with a member "surrounding" which is what we
		// were returning here. Surrounding has the same value as the enum value in our C++ code, so just cast
		// it to an int
		return (int)layer;
	}

	{
		int id = getTile(x, y, z);
		if (m_tileData.propagate[getTile(x, y, z)])
		{
			int br = getBrightness(layer, x, y + 1, z);
			int br1 = getBrightness(layer, x + 1, y, z);
			int br2 = getBrightness(layer, x - 1, y, z);
			int br3 = getBrightness(layer, x, y, z + 1);
			int br4 = getBrightness(layer, x, y, z - 1);
			if (br1 > br) br = br1;
			if (br2 > br) br = br2;
			if (br3 > br) br = br3;
			if (br4 > br) br = br4;
			return br;
		}
	}

	if(layer == LightLayer::Sky)
		return getBrightnessSky(x, y, z);
	return getBrightnessBlock(x, y, z);
	
}
int ChunkRebuildData::getLightColor(int x, int y, int z, int emitt)	// 4J - change brought forward from 1.8.2
{
	int s = getBrightnessPropagate(LightLayer::Sky, x, y, z);
	int b = getBrightnessPropagate(LightLayer::Block, x, y, z);
	if (b < emitt) b = emitt;
	return s << 20 | b << 4;
}


int ChunkRebuildData::getRawBrightness(int x, int y, int z)
{
	return getRawBrightness(x, y, z, true);
}


int ChunkRebuildData::getRawBrightness(int x, int y, int z, bool propagate)
{
	if (x < -Level_MAX_LEVEL_SIZE || z < -Level_MAX_LEVEL_SIZE || x >= Level_MAX_LEVEL_SIZE || z > Level_MAX_LEVEL_SIZE)
	{
		return Level_MAX_BRIGHTNESS;
	}

	if (propagate)
	{
		int id = getTile(x, y, z);
		switch(id)
		{
		case Tile_SPU::stoneSlabHalf_Id:
		case Tile_SPU::woodSlabHalf_Id:
		case Tile_SPU::farmland_Id:
		case Tile_SPU::stairs_stone_Id:
		case Tile_SPU::stairs_wood_Id:
			{
				int br = getRawBrightness(x, y + 1, z, false);
				int br1 = getRawBrightness(x + 1, y, z, false);
				int br2 = getRawBrightness(x - 1, y, z, false);
				int br3 = getRawBrightness(x, y, z + 1, false);
				int br4 = getRawBrightness(x, y, z - 1, false);
				if (br1 > br) br = br1;
				if (br2 > br) br = br2;
				if (br3 > br) br = br3;
				if (br4 > br) br = br4;
				return br;
			}
			break;
		}
	}

	if (y < 0) return 0;
	if (y >= Level_maxBuildHeight)
	{
		int br = Level_MAX_BRIGHTNESS - m_levelSkyDarken;
		if (br < 0) br = 0;
		return br;
	}

	return LevelChunk_getRawBrightness(x, y, z, m_levelSkyDarken);
}

int ChunkRebuildData::LevelChunk_getRawBrightness(int x, int y, int z, int skyDampen)
{
	   int light = (m_flags & e_flag_HasCeiling) ? 0 : getBrightnessSky(x, y, z);
    if (light > 0) 
		m_flags |= e_flag_TouchedSky;
    light -= skyDampen;
    int block = getBrightnessBlock(x, y, z);
    if (block > light) light = block;

    /*
        * int xd = (absFloor(level.player.x-(this->x*16+x))); int yd =
        * (absFloor(level.player.y-(y))); int zd =
        * (absFloor(level.player.z-(this->z*16+z))); int dd = xd+yd+zd; if
        * (dd<15){ int carried = 15-dd; if (carried<0) carried = 0; if
        * (carried>15) carried = 15; if (carried > light) light = carried; }
        */

    return light;

}


Material_SPU *ChunkRebuildData::getMaterial(int x, int y, int z)
{
	int t = getTile(x, y, z);
	int matID = Material_SPU::air_Id;
	if (t != 0)
		matID = m_tileData.materialIDs[t];
	return &m_tileData.materials[matID];
}