Something went wrong. Try again.
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
Something went wrong. Try again.
36 kB · 894 lines
C++
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895#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_SPUint 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] = (float)Tile::tiles[i]->getShapeX0(); m_tileData.yy0[i] = (float)Tile::tiles[i]->getShapeY0(); m_tileData.zz0[i] = (float)Tile::tiles[i]->getShapeZ0(); m_tileData.xx1[i] = (float)Tile::tiles[i]->getShapeX1(); m_tileData.yy1[i] = (float)Tile::tiles[i]->getShapeY1(); m_tileData.zz1[i] = (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, ((ThinFenceTile*)Tile::ironFence)->getEdgeTexture()); setIconSPUFromIcon(&m_tileData.thinGlass_EdgeTexture, ((ThinFenceTile*)Tile::thinGlass)->getEdgeTexture());
//FarmTile setIconSPUFromIcon(&m_tileData.farmTile_Dry, ((FarmTile*)Tile::farmland)->iconDry); setIconSPUFromIcon(&m_tileData.farmTile_Wet, ((FarmTile*)Tile::farmland)->iconWet);
// DoorTile for(int i=0;i<8; i++) { setIconSPUFromIcon(&m_tileData.doorTile_Icons[i], ((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], ((SandStoneTile*)Tile::sandStone)->icons[i]); setIconSPUFromIcon(&m_tileData.sandStone_iconTop, ((SandStoneTile*)Tile::sandStone)->iconTop); setIconSPUFromIcon(&m_tileData.sandStone_iconBottom, ((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], ((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], ((TreeTile*)Tile::treeTrunk)->icons[i]); setIconSPUFromIcon(&m_tileData.treeTile_iconTop, ((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], ((CropTile*)Tile::crops)->icons[i]);
// FurnaceTile setIconSPUFromIcon(&m_tileData.furnaceTile_iconTop, ((FurnaceTile*)Tile::furnace)->iconTop); setIconSPUFromIcon(&m_tileData.furnaceTile_iconFront, ((FurnaceTile*)Tile::furnace)->iconFront); setIconSPUFromIcon(&m_tileData.furnaceTile_iconFront_lit, ((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], ((Sapling*)Tile::sapling)->icons[i]);
m_tileData.glassTile_allowSame = ((GlassTile*)Tile::glass)->allowSame; m_tileData.iceTile_allowSame = ((IceTile*)Tile::ice)->allowSame;
// DispenserTile setIconSPUFromIcon(&m_tileData.dispenserTile_iconTop, ((DispenserTile*)Tile::dispenser)->iconTop); setIconSPUFromIcon(&m_tileData.dispenserTile_iconFront, ((DispenserTile*)Tile::dispenser)->iconFront); setIconSPUFromIcon(&m_tileData.dispenserTile_iconFrontVertical, ((DispenserTile*)Tile::dispenser)->iconFrontVertical);
// RailTile setIconSPUFromIcon(&m_tileData.railTile_iconTurn, ((RailTile*)Tile::rail)->iconTurn); setIconSPUFromIcon(&m_tileData.railTile_iconTurnGolden, ((RailTile*)Tile::goldenRail)->iconTurn);
for(int i=0;i<2;i++) setIconSPUFromIcon(&m_tileData.detectorRailTile_icons[i], ((DetectorRailTile*)Tile::detectorRail)->icons[i]);
// tntTile setIconSPUFromIcon(&m_tileData.tntTile_iconBottom, ((TntTile*)Tile::tnt)->iconBottom); setIconSPUFromIcon(&m_tileData.tntTile_iconTop, ((TntTile*)Tile::tnt)->iconTop);
// workbenchTile setIconSPUFromIcon(&m_tileData.workBench_iconFront, ((WorkbenchTile*)Tile::workBench)->iconFront); setIconSPUFromIcon(&m_tileData.workBench_iconTop, ((WorkbenchTile*)Tile::workBench)->iconTop);
// cactusTile setIconSPUFromIcon(&m_tileData.cactusTile_iconTop, ((CactusTile*)Tile::cactus)->iconTop); setIconSPUFromIcon(&m_tileData.cactusTile_iconBottom, ((CactusTile*)Tile::cactus)->iconBottom);
// recordPlayer setIconSPUFromIcon(&m_tileData.recordPlayer_iconTop, ((RecordPlayerTile*)Tile::recordPlayer)->iconTop);
// pumpkin setIconSPUFromIcon(&m_tileData.pumpkinTile_iconTop, ((PumpkinTile*)Tile::pumpkin)->iconTop); setIconSPUFromIcon(&m_tileData.pumpkinTile_iconFace, ((PumpkinTile*)Tile::pumpkin)->iconFace); setIconSPUFromIcon(&m_tileData.pumpkinTile_iconFaceLit, ((PumpkinTile*)Tile::litPumpkin)->iconFace);
// cakeTile setIconSPUFromIcon(&m_tileData.cakeTile_iconTop, ((CakeTile*)Tile::cake)->iconTop); setIconSPUFromIcon(&m_tileData.cakeTile_iconBottom, ((CakeTile*)Tile::cake)->iconBottom); setIconSPUFromIcon(&m_tileData.cakeTile_iconInner, ((CakeTile*)Tile::cake)->iconInner);
// SmoothStoneBrickTile for(int i=0;i<4;i++) setIconSPUFromIcon(&m_tileData.smoothStoneBrick_icons[i], ((SmoothStoneBrickTile*)Tile::stoneBrickSmooth)->icons[i]);
// HugeMushroomTile for(int i=0;i<2;i++) setIconSPUFromIcon(&m_tileData.hugeMushroom_icons[i], ((HugeMushroomTile*)Tile::hugeMushroom1)->icons[i]); setIconSPUFromIcon(&m_tileData.hugeMushroom_iconStem, ((HugeMushroomTile*)Tile::hugeMushroom1)->iconStem); setIconSPUFromIcon(&m_tileData.hugeMushroom_iconInside, ((HugeMushroomTile*)Tile::hugeMushroom1)->iconInside);
// MelonTile setIconSPUFromIcon(&m_tileData.melonTile_iconTop, ((MelonTile*)Tile::melon)->iconTop);
// StemTile setIconSPUFromIcon(&m_tileData.stemTile_iconAngled, ((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], ((NetherStalkTile*)Tile::netherStalk)->icons[i]);
// EnchantmentTableTile setIconSPUFromIcon(&m_tileData.enchantmentTable_iconTop, ((EnchantmentTableTile*)Tile::enchantTable)->iconTop); setIconSPUFromIcon(&m_tileData.enchantmentTable_iconBottom, ((EnchantmentTableTile*)Tile::enchantTable)->iconBottom);
//BrewingStandTile setIconSPUFromIcon(&m_tileData.brewingStand_iconBase, ((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, ((StoneSlabTile*)(Tile::stoneSlab))->iconSide);
for(int i=0;i<16;i++) setIconSPUFromIcon(&m_tileData.clothTile_icons[i], ((ClothTile*)Tile::cloth)->icons[i]);
// CarrotTile for(int i=0;i<4;i++) setIconSPUFromIcon(&m_tileData.carrot_icons[i], ((CarrotTile*)Tile::carrots)->icons[i]);
// PotatoTile for(int i=0;i<4;i++) setIconSPUFromIcon(&m_tileData.potato_icons[i], ((PotatoTile*)Tile::potatoes)->icons[i]);
// AnvilTile for(int i=0;i<3;i++) setIconSPUFromIcon(&m_tileData.anvil_icons[i], ((AnvilTile*)Tile::anvil)->icons[i]);
// QuartzBlockTile for(int i=0;i<5;i++) setIconSPUFromIcon(&m_tileData.quartzBlock_icons[i], ((QuartzBlockTile*)Tile::quartzBlock)->icons[i]);
setIconSPUFromIcon(&m_tileData.quartzBlock_iconChiseledTop, ((QuartzBlockTile*)Tile::quartzBlock)->iconChiseledTop); setIconSPUFromIcon(&m_tileData.quartzBlock_iconLinesTop, ((QuartzBlockTile*)Tile::quartzBlock)->iconLinesTop); setIconSPUFromIcon(&m_tileData.quartzBlock_iconTop, ((QuartzBlockTile*)Tile::quartzBlock)->iconTop); setIconSPUFromIcon(&m_tileData.quartzBlock_iconBottom, ((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() == NULL) 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() == NULL) 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.2int 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.2int 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];}