ocrm.bsky.social
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
1#include "stdafx.h"
2#ifdef __PS3__
3#ifndef SN_TARGET_PS3_SPU
4// #include "..\..\..\stdafx.h"
5#endif
6#endif
7
8#include "ChunkRebuildData.h"
9#include "Tesselator_SPU.h"
10
11
12#ifndef SN_TARGET_PS3_SPU
13#include "..\..\..\..\Minecraft.World\Tile.h"
14#include "..\..\..\..\Minecraft.World\Level.h"
15#include "..\..\..\..\Minecraft.World\Dimension.h"
16//
17// #include "..\..\..\Chunk.h"
18// #include "..\..\..\TileRenderer.h"
19// #include "..\..\..\TileEntityRenderDispatcher.h"
20// #include "..\..\..\LevelRenderer.h"
21#include "..\..\..\..\Minecraft.World\net.minecraft.world.level.h"
22#include "..\..\..\..\Minecraft.World\net.minecraft.world.level.chunk.h"
23#include "..\..\..\..\Minecraft.World\net.minecraft.world.level.tile.h"
24#include "..\..\..\..\Minecraft.World\net.minecraft.world.level.tile.entity.h"
25#include "..\..\..\..\Minecraft.World\Icon.h"
26#include "..\..\..\..\Minecraft.World\BiomeSource.h"
27
28#else
29
30#include "..\Common\spu_assert.h"
31
32#endif //SN_TARGET_PS3_SPU
33
34static const int Level_maxBuildHeight = 256;
35static const int Level_MAX_LEVEL_SIZE = 30000000;
36static const int Level_MAX_BRIGHTNESS = 15;
37
38
39#include "TileRenderer_SPU.h"
40#include "Tile_SPU.h"
41#include "ChunkRebuildData.h"
42TileData_SPU g_tileSPUData;
43
44static const int MAX_LEVEL_SIZE = 30000000;
45static const int MAX_BRIGHTNESS = 15;
46
47#if 0 //def SN_TARGET_PS3_SPU
48int ChunkRebuildData::getTile( int x, int y, int z ) { return m_tileIds[getTileIdx(x,y,z)]; }
49int ChunkRebuildData::getBrightnessSky(int x, int y, int z) { return m_brightness[getTileIdx(x,y,z)] & 0x0f; }
50int ChunkRebuildData::getBrightnessBlock(int x, int y, int z) { return m_brightness[getTileIdx(x,y,z)] >> 4; }
51int ChunkRebuildData::getData(int x, int y, int z) { return m_data_flags[getTileIdx(x,y,z)] & 0x0f; }
52int ChunkRebuildData::getGrassColor( int x, int z ) { return m_grassColor[getTileIdx(x,z)]; }
53int ChunkRebuildData::getFoliageColor( int x, int z ) { return m_foliageColor[getTileIdx(x,z)]; }
54int ChunkRebuildData::getFlags(int x, int y, int z) { return m_data_flags[getTileIdx(x,y,z)] >> 4; }
55void ChunkRebuildData::setFlag(int x, int y, int z, int flag) { m_data_flags[getTileIdx(x,y,z)] |= (flag<<4);}
56#endif
57
58
59
60void ChunkRebuildData::disableUnseenTiles()
61{
62 // We now go through the vertical section of this level chunk that we are interested in and try and establish
63 // (1) if it is completely empty
64 // (2) if any of the tiles can be quickly determined to not need rendering because they are in the middle of other tiles and
65 // so can't be seen. A large amount (> 60% in tests) of tiles that call tesselateInWorld in the unoptimised version
66 // of this function fall into this category. By far the largest category of these are tiles in solid regions of rock.
67 int startX = m_x0+2; // beginning of the chunk
68 int startY = m_y0+2; // beginning of the chunk
69 int startZ = m_z0+2; // beginning of the chunk
70
71 for(int iX=startX; iX<(startX+16); iX++)
72 {
73 for(int iY=startY; iY<(startY+16); iY++)
74 {
75 for(int iZ=startZ; iZ<(startZ+16); iZ++)
76 {
77 int tileID = getTile(iX,iY,iZ);
78 if( tileID == 0 ) continue;
79 m_flags &= ~e_flag_EmptyChunk;
80
81
82 // Don't bother trying to work out neighbours for this tile if we are at the edge of the chunk - apart from the very
83 // bottom of the world where we shouldn't ever be able to see
84 if( iY == 127 ) continue;
85 if(( iX-startX == 0 ) || ( iX-startX == 15 )) continue;
86 if(( iZ-startZ == 0 ) || ( iZ-startZ == 15 )) continue;
87
88 int flags = getFlags(iX, iY, iZ);
89
90 // Establish whether this tile and its neighbours are all made of rock, dirt, unbreakable tiles, or have already
91 // been determined to meet this criteria themselves and have a tile of 255 set.
92 if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
93 tileID = getTile(iX-1, iY, iZ);
94 flags = getFlags(iX-1, iY, iZ);
95 if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
96 tileID = getTile(iX+1, iY, iZ);
97 flags = getFlags(iX+1, iY, iZ);
98 if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
99 tileID = getTile(iX, iY, iZ-1);
100 flags = getFlags(iX, iY, iZ-1);
101 if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
102 tileID = getTile(iX, iY, iZ+1);
103 flags = getFlags(iX, iY, iZ+1);
104 if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
105 // Treat the bottom of the world differently - we shouldn't ever be able to look up at this, so consider tiles as invisible
106 // if they are surrounded on sides other than the bottom
107 if( iY > 0 )
108 {
109 tileID = getTile(iX, iY-1, iZ);
110 flags = getFlags(iX, iY-1, iZ);
111 if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
112 }
113 tileID = getTile(iX, iY+1, iZ);
114 flags = getFlags(iX, iY+1, iZ);
115 if( !( ( tileID == Tile_SPU::rock_Id ) || ( tileID == Tile_SPU::dirt_Id ) || ( tileID == Tile_SPU::unbreakable_Id ) || ( flags & e_flag_NoRender) ) ) continue;
116
117 // This tile is surrounded. Flag it as not requiring to be rendered by setting its id to 255.
118 setFlag(iX, iY, iZ, e_flag_NoRender);
119 }
120 }
121 }
122}
123
124#ifndef SN_TARGET_PS3_SPU
125
126void setIconSPUFromIcon(Icon_SPU* iconSpu, Icon* icon)
127{
128 iconSpu->set(icon->getX(), icon->getY(), icon->getWidth(), icon->getHeight(), icon->getSourceWidth(), icon->getSourceHeight());
129}
130
131void ChunkRebuildData::buildMaterial(int matSPUIndex, Material* mat)
132{
133 Material_SPU* matSPU = &m_tileData.materials[matSPUIndex];
134 matSPU->id = matSPUIndex;
135 matSPU->color = mat->color->col;
136 matSPU->flags =0;
137 matSPU->flags |= mat->isFlammable() ? Material_SPU::e_flammable : 0;
138 matSPU->flags |= mat->isReplaceable() ? Material_SPU::e_replaceable : 0;
139 matSPU->flags |= mat->_neverBuildable ? Material_SPU::e_neverBuildable : 0;
140 matSPU->flags |= mat->isSolid() ? Material_SPU::e_isSolid : 0;
141 matSPU->flags |= mat->isLiquid() ? Material_SPU::e_isLiquid : 0;
142 matSPU->flags |= mat->blocksLight() ? Material_SPU::e_blocksLight : 0;
143 matSPU->flags |= mat->blocksMotion() ? Material_SPU::e_blocksMotion : 0;
144}
145
146void ChunkRebuildData::buildMaterials()
147{
148 buildMaterial(Material_SPU::air_Id, Material::air);
149 buildMaterial(Material_SPU::grass_Id, Material::grass);
150 buildMaterial(Material_SPU::dirt_Id, Material::dirt);
151 buildMaterial(Material_SPU::wood_Id, Material::wood);
152 buildMaterial(Material_SPU::stone_Id, Material::stone);
153 buildMaterial(Material_SPU::metal_Id, Material::metal);
154 buildMaterial(Material_SPU::water_Id, Material::water);
155 buildMaterial(Material_SPU::lava_Id, Material::lava);
156 buildMaterial(Material_SPU::leaves_Id, Material::leaves);
157 buildMaterial(Material_SPU::plant_Id, Material::plant);
158 buildMaterial(Material_SPU::replaceable_plant_Id, Material::replaceable_plant);
159 buildMaterial(Material_SPU::sponge_Id, Material::sponge);
160 buildMaterial(Material_SPU::cloth_Id, Material::cloth);
161 buildMaterial(Material_SPU::fire_Id, Material::fire);
162 buildMaterial(Material_SPU::sand_Id, Material::sand);
163 buildMaterial(Material_SPU::decoration_Id, Material::decoration);
164 buildMaterial(Material_SPU::clothDecoration_Id, Material::clothDecoration);
165 buildMaterial(Material_SPU::glass_Id, Material::glass);
166 buildMaterial(Material_SPU::explosive_Id, Material::explosive);
167 buildMaterial(Material_SPU::coral_Id, Material::coral);
168 buildMaterial(Material_SPU::ice_Id, Material::ice);
169 buildMaterial(Material_SPU::topSnow_Id, Material::topSnow);
170 buildMaterial(Material_SPU::snow_Id, Material::snow);
171 buildMaterial(Material_SPU::cactus_Id, Material::cactus);
172 buildMaterial(Material_SPU::clay_Id, Material::clay);
173 buildMaterial(Material_SPU::vegetable_Id, Material::vegetable);
174 buildMaterial(Material_SPU::egg_Id, Material::egg);
175 buildMaterial(Material_SPU::portal_Id, Material::portal);
176 buildMaterial(Material_SPU::cake_Id, Material::cake);
177 buildMaterial(Material_SPU::web_Id, Material::web);
178 buildMaterial(Material_SPU::piston_Id, Material::piston);
179 buildMaterial(Material_SPU::buildable_glass_Id, Material::buildable_glass);
180 buildMaterial(Material_SPU::heavyMetal_Id, Material::heavyMetal);
181}
182
183int ChunkRebuildData::getMaterialID(Tile* pTile)
184{
185 Material* m = pTile->material;
186 if(m == Material::air) return Material_SPU::air_Id;
187 if(m == Material::grass) return Material_SPU::grass_Id;
188 if(m == Material::dirt) return Material_SPU::dirt_Id;
189 if(m == Material::wood) return Material_SPU::wood_Id;
190 if(m == Material::stone) return Material_SPU::stone_Id;
191 if(m == Material::metal) return Material_SPU::metal_Id;
192 if(m == Material::water) return Material_SPU::water_Id;
193 if(m == Material::lava) return Material_SPU::lava_Id;
194 if(m == Material::leaves) return Material_SPU::leaves_Id;
195 if(m == Material::plant) return Material_SPU::plant_Id;
196 if(m == Material::replaceable_plant)return Material_SPU::replaceable_plant_Id;
197 if(m == Material::sponge) return Material_SPU::sponge_Id;
198 if(m == Material::cloth) return Material_SPU::cloth_Id;
199 if(m == Material::fire) return Material_SPU::fire_Id;
200 if(m == Material::sand) return Material_SPU::sand_Id;
201 if(m == Material::decoration) return Material_SPU::decoration_Id;
202 if(m == Material::clothDecoration) return Material_SPU::clothDecoration_Id;
203 if(m == Material::glass) return Material_SPU::glass_Id;
204 if(m == Material::explosive) return Material_SPU::explosive_Id;
205 if(m == Material::coral) return Material_SPU::coral_Id;
206 if(m == Material::ice) return Material_SPU::ice_Id;
207 if(m == Material::topSnow) return Material_SPU::topSnow_Id;
208 if(m == Material::snow) return Material_SPU::snow_Id;
209 if(m == Material::cactus) return Material_SPU::cactus_Id;
210 if(m == Material::clay) return Material_SPU::clay_Id;
211 if(m == Material::vegetable) return Material_SPU::vegetable_Id;
212 if(m == Material::egg) return Material_SPU::egg_Id;
213 if(m == Material::portal) return Material_SPU::portal_Id;
214 if(m == Material::cake) return Material_SPU::cake_Id;
215 if(m == Material::web) return Material_SPU::web_Id;
216 if(m == Material::piston) return Material_SPU::piston_Id;
217 if(m == Material::buildable_glass) return Material_SPU::buildable_glass_Id;
218 if(m == Material::heavyMetal) return Material_SPU::heavyMetal_Id;
219 assert(0);
220 return Material_SPU::air_Id;
221}
222
223
224void ChunkRebuildData::createTileData()
225{
226 // build the material data
227 buildMaterials();
228
229 // build the tile data
230 for(int i=0;i<256;i++)
231 {
232 m_tileData.mipmapEnable.set(i, Tile::mipmapEnable[i]);
233 m_tileData.solid.set(i, Tile::solid[i]);
234 m_tileData.transculent.set(i, Tile::transculent[i]);
235// m_tileData._sendTileData.set(i, Tile::_sendTileData[i]);
236 m_tileData.propagate.set(i, Tile::propagate[i]);
237 m_tileData.lightBlock[i] = Tile::lightBlock[i];
238 m_tileData.lightEmission[i] = Tile::lightEmission[i];
239 if(Tile::tiles[i])
240 {
241 m_tileData.signalSource.set(i, Tile::tiles[i]->isSignalSource());
242 m_tileData.cubeShaped.set(i, Tile::tiles[i]->isCubeShaped());
243
244 m_tileData.xx0[i] = (float)Tile::tiles[i]->getShapeX0();
245 m_tileData.yy0[i] = (float)Tile::tiles[i]->getShapeY0();
246 m_tileData.zz0[i] = (float)Tile::tiles[i]->getShapeZ0();
247 m_tileData.xx1[i] = (float)Tile::tiles[i]->getShapeX1();
248 m_tileData.yy1[i] = (float)Tile::tiles[i]->getShapeY1();
249 m_tileData.zz1[i] = (float)Tile::tiles[i]->getShapeZ1();
250 Icon* pTex = Tile::tiles[i]->icon;
251 if(pTex)
252 {
253 setIconSPUFromIcon(&m_tileData.iconData[i], pTex);
254 }
255 m_tileData.materialIDs[i] = getMaterialID(Tile::tiles[i]);
256 }
257 }
258 m_tileData.leafTile_allowSame = Tile::leaves->allowSame;
259 m_tileData.leafTile_fancyTextureSet = Tile::leaves->fancyTextureSet;
260
261
262 // Custom tile textures
263 // get the width and height of any texture, since everything uses the same texture
264 m_tileData.iconTexWidth = Tile::grass->iconTop->getSourceWidth();
265 m_tileData.iconTexHeight = Tile::grass->iconTop->getSourceHeight();
266 // Grass tile
267 setIconSPUFromIcon(&m_tileData.grass_iconTop, Tile::grass->iconTop);
268 setIconSPUFromIcon(&m_tileData.grass_iconSnowSide, Tile::grass->iconSnowSide);
269 setIconSPUFromIcon(&m_tileData.grass_iconSideOverlay, Tile::grass->iconSideOverlay);
270
271 // ThinFence
272 setIconSPUFromIcon(&m_tileData.ironFence_EdgeTexture, ((ThinFenceTile*)Tile::ironFence)->getEdgeTexture());
273 setIconSPUFromIcon(&m_tileData.thinGlass_EdgeTexture, ((ThinFenceTile*)Tile::thinGlass)->getEdgeTexture());
274
275 //FarmTile
276 setIconSPUFromIcon(&m_tileData.farmTile_Dry, ((FarmTile*)Tile::farmland)->iconDry);
277 setIconSPUFromIcon(&m_tileData.farmTile_Wet, ((FarmTile*)Tile::farmland)->iconWet);
278
279 // DoorTile
280 for(int i=0;i<8; i++)
281 {
282 setIconSPUFromIcon(&m_tileData.doorTile_Icons[i], ((DoorTile*)Tile::door_wood)->icons[i]);
283 // we're not supporting flipped icons, so manually flip here
284 if(i>=4)
285 m_tileData.doorTile_Icons[i].flipHorizontal();
286 }
287
288 // TallGrass
289 for(int i=0;i<3; i++)
290 setIconSPUFromIcon(&m_tileData.tallGrass_Icons[i], Tile::tallgrass->icons[i]);
291
292 // SandStoneTile
293 for(int i=0;i<3; i++)
294 setIconSPUFromIcon(&m_tileData.sandStone_icons[i], ((SandStoneTile*)Tile::sandStone)->icons[i]);
295 setIconSPUFromIcon(&m_tileData.sandStone_iconTop, ((SandStoneTile*)Tile::sandStone)->iconTop);
296 setIconSPUFromIcon(&m_tileData.sandStone_iconBottom, ((SandStoneTile*)Tile::sandStone)->iconBottom);
297
298 // WoodTile
299// assert(WoodTile_SPU::WOOD_NAMES_LENGTH == 4);
300 for(int i=0;i<4; i++)
301 setIconSPUFromIcon(&m_tileData.woodTile_icons[i], ((WoodTile*)Tile::wood)->icons[i]);
302
303 // TreeTile
304// assert(TreeTile_SPU::TREE_NAMES_LENGTH == 4);
305 for(int i=0;i<4; i++)
306 setIconSPUFromIcon(&m_tileData.treeTile_icons[i], ((TreeTile*)Tile::treeTrunk)->icons[i]);
307 setIconSPUFromIcon(&m_tileData.treeTile_iconTop, ((TreeTile*)Tile::treeTrunk)->iconTop);
308
309 // LeafTile
310 for(int i=0;i<2; i++)
311 for(int j=0;j<4;j++)
312 setIconSPUFromIcon(&m_tileData.leafTile_icons[i][j], ((LeafTile*)Tile::leaves)->icons[i][j]);
313
314 // CropTile
315 for(int i=0;i<8; i++)
316 setIconSPUFromIcon(&m_tileData.cropTile_icons[i], ((CropTile*)Tile::crops)->icons[i]);
317
318 // FurnaceTile
319 setIconSPUFromIcon(&m_tileData.furnaceTile_iconTop, ((FurnaceTile*)Tile::furnace)->iconTop);
320 setIconSPUFromIcon(&m_tileData.furnaceTile_iconFront, ((FurnaceTile*)Tile::furnace)->iconFront);
321 setIconSPUFromIcon(&m_tileData.furnaceTile_iconFront_lit, ((FurnaceTile*)Tile::furnace_lit)->iconFront);
322
323 //LiquidTile
324 setIconSPUFromIcon(&m_tileData.liquidTile_iconWaterStill, (Tile::water)->icons[0]);
325 setIconSPUFromIcon(&m_tileData.liquidTile_iconWaterFlow, (Tile::water)->icons[1]);
326 setIconSPUFromIcon(&m_tileData.liquidTile_iconLavaStill, (Tile::lava)->icons[0]);
327 setIconSPUFromIcon(&m_tileData.liquidTile_iconLavaFlow, (Tile::lava)->icons[1]);
328
329 //FireTile
330 for(int i=0;i<2;i++)
331 setIconSPUFromIcon(&m_tileData.fireTile_icons[i], (Tile::fire)->icons[i]);
332
333 // Sapling
334 for(int i=0;i<4;i++)
335 setIconSPUFromIcon(&m_tileData.sapling_icons[i], ((Sapling*)Tile::sapling)->icons[i]);
336
337 m_tileData.glassTile_allowSame = ((GlassTile*)Tile::glass)->allowSame;
338 m_tileData.iceTile_allowSame = ((IceTile*)Tile::ice)->allowSame;
339
340 // DispenserTile
341 setIconSPUFromIcon(&m_tileData.dispenserTile_iconTop, ((DispenserTile*)Tile::dispenser)->iconTop);
342 setIconSPUFromIcon(&m_tileData.dispenserTile_iconFront, ((DispenserTile*)Tile::dispenser)->iconFront);
343 setIconSPUFromIcon(&m_tileData.dispenserTile_iconFrontVertical, ((DispenserTile*)Tile::dispenser)->iconFrontVertical);
344
345 // RailTile
346 setIconSPUFromIcon(&m_tileData.railTile_iconTurn, ((RailTile*)Tile::rail)->iconTurn);
347 setIconSPUFromIcon(&m_tileData.railTile_iconTurnGolden, ((RailTile*)Tile::goldenRail)->iconTurn);
348
349 for(int i=0;i<2;i++)
350 setIconSPUFromIcon(&m_tileData.detectorRailTile_icons[i], ((DetectorRailTile*)Tile::detectorRail)->icons[i]);
351
352 // tntTile
353 setIconSPUFromIcon(&m_tileData.tntTile_iconBottom, ((TntTile*)Tile::tnt)->iconBottom);
354 setIconSPUFromIcon(&m_tileData.tntTile_iconTop, ((TntTile*)Tile::tnt)->iconTop);
355
356 // workbenchTile
357 setIconSPUFromIcon(&m_tileData.workBench_iconFront, ((WorkbenchTile*)Tile::workBench)->iconFront);
358 setIconSPUFromIcon(&m_tileData.workBench_iconTop, ((WorkbenchTile*)Tile::workBench)->iconTop);
359
360 // cactusTile
361 setIconSPUFromIcon(&m_tileData.cactusTile_iconTop, ((CactusTile*)Tile::cactus)->iconTop);
362 setIconSPUFromIcon(&m_tileData.cactusTile_iconBottom, ((CactusTile*)Tile::cactus)->iconBottom);
363
364 // recordPlayer
365 setIconSPUFromIcon(&m_tileData.recordPlayer_iconTop, ((RecordPlayerTile*)Tile::recordPlayer)->iconTop);
366
367 // pumpkin
368 setIconSPUFromIcon(&m_tileData.pumpkinTile_iconTop, ((PumpkinTile*)Tile::pumpkin)->iconTop);
369 setIconSPUFromIcon(&m_tileData.pumpkinTile_iconFace, ((PumpkinTile*)Tile::pumpkin)->iconFace);
370 setIconSPUFromIcon(&m_tileData.pumpkinTile_iconFaceLit, ((PumpkinTile*)Tile::litPumpkin)->iconFace);
371
372 // cakeTile
373 setIconSPUFromIcon(&m_tileData.cakeTile_iconTop, ((CakeTile*)Tile::cake)->iconTop);
374 setIconSPUFromIcon(&m_tileData.cakeTile_iconBottom, ((CakeTile*)Tile::cake)->iconBottom);
375 setIconSPUFromIcon(&m_tileData.cakeTile_iconInner, ((CakeTile*)Tile::cake)->iconInner);
376
377 // SmoothStoneBrickTile
378 for(int i=0;i<4;i++)
379 setIconSPUFromIcon(&m_tileData.smoothStoneBrick_icons[i], ((SmoothStoneBrickTile*)Tile::stoneBrickSmooth)->icons[i]);
380
381 // HugeMushroomTile
382 for(int i=0;i<2;i++)
383 setIconSPUFromIcon(&m_tileData.hugeMushroom_icons[i], ((HugeMushroomTile*)Tile::hugeMushroom1)->icons[i]);
384 setIconSPUFromIcon(&m_tileData.hugeMushroom_iconStem, ((HugeMushroomTile*)Tile::hugeMushroom1)->iconStem);
385 setIconSPUFromIcon(&m_tileData.hugeMushroom_iconInside, ((HugeMushroomTile*)Tile::hugeMushroom1)->iconInside);
386
387
388 // MelonTile
389 setIconSPUFromIcon(&m_tileData.melonTile_iconTop, ((MelonTile*)Tile::melon)->iconTop);
390
391 // StemTile
392 setIconSPUFromIcon(&m_tileData.stemTile_iconAngled, ((StemTile*)Tile::melonStem)->iconAngled);
393
394 // MycelTile
395 setIconSPUFromIcon(&m_tileData.mycelTile_iconTop, (Tile::mycel)->iconTop);
396 setIconSPUFromIcon(&m_tileData.mycelTile_iconSnowSide, (Tile::mycel)->iconSnowSide);
397
398 // NetherStalkTile
399 for(int i=0;i<3;i++)
400 setIconSPUFromIcon(&m_tileData.netherStalk_icons[i], ((NetherStalkTile*)Tile::netherStalk)->icons[i]);
401
402 // EnchantmentTableTile
403 setIconSPUFromIcon(&m_tileData.enchantmentTable_iconTop, ((EnchantmentTableTile*)Tile::enchantTable)->iconTop);
404 setIconSPUFromIcon(&m_tileData.enchantmentTable_iconBottom, ((EnchantmentTableTile*)Tile::enchantTable)->iconBottom);
405
406 //BrewingStandTile
407 setIconSPUFromIcon(&m_tileData.brewingStand_iconBase, ((BrewingStandTile*)Tile::brewingStand)->iconBase);
408
409 //RedStoneDust
410 setIconSPUFromIcon(&m_tileData.redStoneDust_iconCross, (Tile::redStoneDust)->iconCross);
411 setIconSPUFromIcon(&m_tileData.redStoneDust_iconCross, (Tile::redStoneDust)->iconLine);
412 setIconSPUFromIcon(&m_tileData.redStoneDust_iconCrossOver, (Tile::redStoneDust)->iconCrossOver);
413 setIconSPUFromIcon(&m_tileData.redStoneDust_iconLineOver, (Tile::redStoneDust)->iconLineOver);
414
415 setIconSPUFromIcon(&m_tileData.stoneSlab_iconSide, ((StoneSlabTile*)(Tile::stoneSlab))->iconSide);
416
417 for(int i=0;i<16;i++)
418 setIconSPUFromIcon(&m_tileData.clothTile_icons[i], ((ClothTile*)Tile::cloth)->icons[i]);
419
420 // CarrotTile
421 for(int i=0;i<4;i++)
422 setIconSPUFromIcon(&m_tileData.carrot_icons[i], ((CarrotTile*)Tile::carrots)->icons[i]);
423
424 // PotatoTile
425 for(int i=0;i<4;i++)
426 setIconSPUFromIcon(&m_tileData.potato_icons[i], ((PotatoTile*)Tile::potatoes)->icons[i]);
427
428 // AnvilTile
429 for(int i=0;i<3;i++)
430 setIconSPUFromIcon(&m_tileData.anvil_icons[i], ((AnvilTile*)Tile::anvil)->icons[i]);
431
432
433 // QuartzBlockTile
434 for(int i=0;i<5;i++)
435 setIconSPUFromIcon(&m_tileData.quartzBlock_icons[i], ((QuartzBlockTile*)Tile::quartzBlock)->icons[i]);
436
437 setIconSPUFromIcon(&m_tileData.quartzBlock_iconChiseledTop, ((QuartzBlockTile*)Tile::quartzBlock)->iconChiseledTop);
438 setIconSPUFromIcon(&m_tileData.quartzBlock_iconLinesTop, ((QuartzBlockTile*)Tile::quartzBlock)->iconLinesTop);
439 setIconSPUFromIcon(&m_tileData.quartzBlock_iconTop, ((QuartzBlockTile*)Tile::quartzBlock)->iconTop);
440 setIconSPUFromIcon(&m_tileData.quartzBlock_iconBottom, ((QuartzBlockTile*)Tile::quartzBlock)->iconBottom);
441}
442
443// extern int g_lastHitBlockX;
444// extern int g_lastHitBlockY;
445// extern int g_lastHitBlockZ;
446
447void ChunkRebuildData::buildForChunk( Region* region, Level* level, int x0, int y0, int z0 )
448{
449 static bool bCreatedTileData = false;
450 if(!bCreatedTileData)
451 {
452 createTileData();
453 bCreatedTileData = true;
454 }
455
456 m_tileData.stemTile_minColour = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Tile_StemMin );
457 m_tileData.stemTile_maxColour = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Tile_StemMax );
458 m_tileData.waterLily_colour = Minecraft::GetInstance()->getColourTable()->getColor( eMinecraftColour_Tile_WaterLily );
459
460 m_tileData.foliageColor_evergreenColor = FoliageColor::getEvergreenColor();
461 m_tileData.foliageColor_birchColor = FoliageColor::getBirchColor();
462
463
464// m_lastHitBlockX = g_lastHitBlockX;
465// m_lastHitBlockY = g_lastHitBlockY;
466// m_lastHitBlockZ = g_lastHitBlockZ;
467
468 m_x0 = x0-2;
469 m_y0 = y0-2;
470 m_z0 = z0-2;
471 m_pRegion = region;
472 m_flags = 0;//e_flag_EmptyChunk;
473
474// for(int iX=m_x0; iX<(m_x0+sc_size); iX++)
475// {
476// for(int iY=m_y0; iY<(m_y0+sc_size); iY++)
477// {
478// for(int iZ=m_z0; iZ<(m_z0+sc_size); iZ++)
479// {
480// buildTile(iX, iY, iZ);
481// }
482// }
483// }
484
485 BiomeCache::Block* cacheBlocks[9];
486 cacheBlocks[0] = region->getBiomeSource()->getBlockAt(m_x0, m_z0);
487 cacheBlocks[1] = region->getBiomeSource()->getBlockAt(m_x0+2, m_z0);
488 cacheBlocks[2] = region->getBiomeSource()->getBlockAt(m_x0+18, m_z0);
489
490 cacheBlocks[3] = region->getBiomeSource()->getBlockAt(m_x0, m_z0+2);
491 cacheBlocks[4] = region->getBiomeSource()->getBlockAt(m_x0+2, m_z0+2);
492 cacheBlocks[5] = region->getBiomeSource()->getBlockAt(m_x0+18, m_z0+2);
493
494 cacheBlocks[6] = region->getBiomeSource()->getBlockAt(m_x0, m_z0+18);
495 cacheBlocks[7] = region->getBiomeSource()->getBlockAt(m_x0+2, m_z0+18);
496 cacheBlocks[8] = region->getBiomeSource()->getBlockAt(m_x0+18, m_z0+18);
497
498 int cacheMap[20] = { 0,0, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 2,2};
499
500 ColourTable* pColourTable = Minecraft::GetInstance()->getColourTable();
501
502 for(int iX=m_x0; iX<(m_x0+sc_size); iX++)
503 {
504 for(int iZ=m_z0; iZ<(m_z0+sc_size); iZ++)
505 {
506 int newX = ( iX - m_x0 );
507 int newZ = ( iZ - m_z0 );
508 int index = (newX*sc_size) + newZ;
509// assert(index < 400);
510 int cacheBlockIndex = (cacheMap[iZ-m_z0]*3) + cacheMap[iX-m_x0];
511 BiomeCache::Block* pCacheBlock = cacheBlocks[cacheBlockIndex];
512// assert(region->getBiomeSource()->getBlockAt(iX, iZ) == pCacheBlock);
513 Biome* pBiome = pCacheBlock->getBiome(iX, iZ);
514 m_grassColor[index] = pColourTable->getColor(pBiome->m_grassColor);
515 m_foliageColor[index] = pColourTable->getColor(pBiome->m_foliageColor);
516 m_waterColor[index] = pColourTable->getColor(pBiome->m_waterColor);
517 }
518 }
519
520 if(isEmptyChunk())
521 return;
522
523
524 if(level->dimension->hasCeiling)
525 m_flags |= e_flag_HasCeiling;
526 for(int i=0;i<16;i++)
527 m_brightnessRamp[i] = level->dimension->brightnessRamp[i];
528 m_levelSkyDarken = level->skyDarken;
529}
530
531void ChunkRebuildData::copyFromTesselator()
532{
533 Tesselator* t = Tesselator::getInstance(); // 4J - added - static initialiser being set at the wrong time
534
535 m_tesselator.m_PPUArray = t->_array->data;
536 assert(t->p == 0);
537 m_tesselator.m_PPUOffset = 0;
538
539 // copy tesselator vars over
540 m_tesselator.vertices = t->vertices;
541 m_tesselator.u = t->u;
542 m_tesselator.v = t->v;
543 m_tesselator._tex2 = t->_tex2;
544 m_tesselator.col = t->col;
545 m_tesselator.hasColor = t->hasColor;
546 m_tesselator.hasTexture = t->hasTexture;
547 m_tesselator.hasTexture2 = t->hasTexture2;
548 m_tesselator.hasNormal = t->hasNormal;
549 m_tesselator.p = t->p;
550 m_tesselator.useCompactFormat360 = t->useCompactFormat360;
551 m_tesselator.useProjectedTexturePixelShader = t->useProjectedTexturePixelShader;
552 m_tesselator.count = t->count;
553 m_tesselator._noColor = t->_noColor;
554 m_tesselator.mode = t->mode;
555 m_tesselator.xo = t->xo;
556 m_tesselator.yo = t->yo;
557 m_tesselator.zo = t->zo;
558 m_tesselator.count = t->count ;
559 m_tesselator._normal = t->_normal;
560 m_tesselator.tesselating = t->tesselating;
561 m_tesselator.mipmapEnable = t->mipmapEnable; // 4J added
562 m_tesselator.vboId = t->vboId;
563 m_tesselator.vboCounts = t->vboCounts;
564 m_tesselator.size = t->size;
565 for(int i=0;i<6;i++)
566 m_tesselator.bounds.boundingBox[i] = t->bounds.boundingBox[i];
567
568}
569
570
571void ChunkRebuildData::buildTile(int x, int y, int z)
572{
573 int newX = ( x - m_x0 );
574 int newY = ( y - m_y0 );
575 int newZ = ( z - m_z0 );
576
577 int index = (newX*sc_size*sc_size) + (newY*sc_size) + newZ;
578
579 m_tileIds[index] = m_pRegion->getTile(x, y, z);
580 m_brightness[index] = m_pRegion->getBrightness(LightLayer::Sky, x, y, z);
581 m_brightness[index] |= (m_pRegion->getBrightness(LightLayer::Block, x, y, z)) << 4;
582 m_data_flags[index] = m_pRegion->getData(x,y,z);
583}
584
585
586void ChunkRebuildData::storeInTesselator()
587{
588 Tesselator* t = Tesselator::getInstance(); // 4J - added - static initialiser being set at the wrong time
589
590 // copy tesselator vars over
591 t->vertices = m_tesselator.vertices;
592 t->u = m_tesselator.u;
593 t->v = m_tesselator.v;
594 t->_tex2 = m_tesselator._tex2;
595 t->col = m_tesselator.col;
596 t->hasColor = m_tesselator.hasColor;
597 t->hasTexture = m_tesselator.hasTexture;
598 t->hasTexture2 = m_tesselator.hasTexture2;
599 t->hasNormal = m_tesselator.hasNormal;
600 t->p = m_tesselator.m_PPUOffset/4;
601 t->useCompactFormat360 = m_tesselator.useCompactFormat360;
602 t->useProjectedTexturePixelShader = m_tesselator.useProjectedTexturePixelShader;
603 t->count = m_tesselator.count;
604 t->_noColor = m_tesselator._noColor;
605 t->mode = m_tesselator.mode;
606 t->xo = m_tesselator.xo;
607 t->yo = m_tesselator.yo;
608 t->zo = m_tesselator.zo;
609 t->count = m_tesselator.count;
610 t->_normal = m_tesselator._normal;
611 t->tesselating = m_tesselator.tesselating;
612 t->mipmapEnable = m_tesselator.mipmapEnable; // 4J added
613 t->vboId = m_tesselator.vboId;
614 t->vboCounts = m_tesselator.vboCounts;
615 t->size = m_tesselator.size;
616 for(int i=0;i<6;i++)
617 t->bounds.boundingBox[i] = m_tesselator.bounds.boundingBox[i];
618}
619#endif // SN_TARGET_PS3_SPU
620
621
622
623void ChunkRebuildData::tesselateAllTiles(TileRenderer_SPU* pTileRenderer)
624{
625 Tile_SPU::ms_pTileData = &m_tileData;
626 // 4J - changed loop order here to leave y as the innermost loop for better cache performance
627 bool renderNextLayer = false;
628 bool rendered = false;
629 int numRenderedLayer0 = 0;
630 int startX = m_x0+2; // beginning of the chunk
631 int startY = m_y0+2; // beginning of the chunk
632 int startZ = m_z0+2; // beginning of the chunk
633
634 m_tesselator.beginData();
635 for (int z = startZ; z < (startZ+16); z++)
636 {
637 for (int x = startX; x < (startX+16); x++)
638 {
639 for (int y = startY; y < (startY+16); y++)
640 {
641 // 4J - get tile from those copied into our local array in earlier optimisation
642 int flags = getFlags(x,y,z);
643 if(flags & ChunkRebuildData::e_flag_NoRender)
644 continue;
645 unsigned char tileId = getTile(x,y,z);
646 if (tileId > 0)
647 {
648// if (m_currentLayer == 0 && m_tileData.isEntityTile[tileId])
649// {
650// shared_ptr<TileEntity> et = region->getTileEntity(x, y, z);
651// if (TileEntityRenderDispatcher::instance->hasRenderer(et))
652// {
653// renderableTileEntities.push_back(et);
654// }
655// }
656 TileRef_SPU tile(tileId);
657 int renderLayer = tile->getRenderLayer();
658
659 if (renderLayer != m_currentLayer)
660 {
661 renderNextLayer = true;
662 }
663 else //if (renderLayer == m_currentLayer)
664 {
665 if(pTileRenderer->hasRenderer(tile.getPtr()))
666 {
667 numRenderedLayer0++;
668 rendered |= pTileRenderer->tesselateInWorld(tile.getPtr(), x, y, z);
669 }
670 else
671 {
672 setFlag(x, y, z, e_flag_SPURenderCodeMissing);
673// #ifdef SN_TARGET_PS3_SPU
674// spu_print("Render code missing for tile ID %d : render shape %d\n", tile->id, tile->getRenderShape());
675// #endif
676
677 }
678 }
679 }
680 }
681 }
682 }
683 if(rendered)
684 m_flags |= e_flag_Rendered;
685
686// spu_print("(%d,%d,%d) SPU num rendered : %d\n", m_x0+2, m_y0+2, m_z0+2, numRenderedLayer0);
687
688 m_tesselator.endData();
689}
690
691bool ChunkRebuildData::isEmptyTile(int x, int y, int z)
692{
693 return getTile(x, y, z) == 0;
694}
695
696bool ChunkRebuildData::isSolidRenderTile(int x, int y, int z)
697{
698 TileRef_SPU tile(getTile(x,y,z));
699 if (tile.getPtr() == NULL) return false;
700
701
702 // 4J - addition here to make rendering big blocks of leaves more efficient. Normally leaves never consider themselves as solid, so
703 // blocks of leaves will have all sides of each block completely visible. Changing to consider as solid if this block is surrounded by
704 // other leaves. This is paired with another change in Tile::getTexture which makes such solid tiles actually visibly solid (these
705 // textures exist already for non-fancy graphics). Note: this tile-specific code is here rather than making some new virtual method in the tiles,
706 // for the sake of efficiency - I don't imagine we'll be doing much more of this sort of thing
707 if( tile->id == Tile_SPU::leaves_Id )
708 {
709 int axo[6] = { 1,-1, 0, 0, 0, 0};
710 int ayo[6] = { 0, 0, 1,-1, 0, 0};
711 int azo[6] = { 0, 0, 0, 0, 1,-1};
712 for( int i = 0; i < 6; i++ )
713 {
714 int t = getTile(x + axo[i], y + ayo[i] , z + azo[i]);
715 if( ( t != Tile_SPU::leaves_Id ) && ( ( Tile_SPU::m_tiles[t].id == -1) || !Tile_SPU::m_tiles[t].isSolidRender() ) )
716 {
717 return false;
718 }
719 }
720 return true;
721 }
722
723 return tile->isSolidRender();
724}
725
726
727bool ChunkRebuildData::isSolidBlockingTile(int x, int y, int z)
728{
729 TileRef_SPU tile(getTile(x, y, z));
730 if (tile.getPtr() == NULL) return false;
731 bool ret = tile->getMaterial()->blocksMotion() && tile->isCubeShaped();
732 return ret;
733}
734
735float ChunkRebuildData::getBrightness(int x, int y, int z, int emitt)
736{
737 int n = getRawBrightness(x, y, z);
738 if (n < emitt) n = emitt;
739 return m_brightnessRamp[n];
740}
741
742float ChunkRebuildData::getBrightness(int x, int y, int z)
743{
744 return m_brightnessRamp[getRawBrightness(x, y, z)];
745}
746
747// 4J - brought forward from 1.8.2
748int ChunkRebuildData::getBrightness(LightLayer::variety layer, int x, int y, int z)
749{
750#ifndef SN_TARGET_PS3_SPU
751 assert(Level_MAX_LEVEL_SIZE == Level::MAX_LEVEL_SIZE);
752 assert(Level_maxBuildHeight == Level::maxBuildHeight);
753 assert(Level_MAX_BRIGHTNESS == Level::MAX_BRIGHTNESS);
754#endif
755
756 if (y < 0) y = 0;
757 if (y >= Level_maxBuildHeight) y = Level_maxBuildHeight - 1;
758 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)
759 {
760 // 4J Stu - The java LightLayer was an enum class type with a member "surrounding" which is what we
761 // were returning here. Surrounding has the same value as the enum value in our C++ code, so just cast
762 // it to an int
763 return (int)layer;
764 }
765
766 if(layer == LightLayer::Sky)
767 return getBrightnessSky(x, y, z);
768 return getBrightnessBlock(x, y, z);
769}
770
771// 4J - brought forward from 1.8.2
772int ChunkRebuildData::getBrightnessPropagate(LightLayer::variety layer, int x, int y, int z)
773{
774 if (y < 0) y = 0;
775 if (y >= Level_maxBuildHeight) y = Level_maxBuildHeight - 1;
776 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)
777 {
778 // 4J Stu - The java LightLayer was an enum class type with a member "surrounding" which is what we
779 // were returning here. Surrounding has the same value as the enum value in our C++ code, so just cast
780 // it to an int
781 return (int)layer;
782 }
783
784 {
785 int id = getTile(x, y, z);
786 if (m_tileData.propagate[getTile(x, y, z)])
787 {
788 int br = getBrightness(layer, x, y + 1, z);
789 int br1 = getBrightness(layer, x + 1, y, z);
790 int br2 = getBrightness(layer, x - 1, y, z);
791 int br3 = getBrightness(layer, x, y, z + 1);
792 int br4 = getBrightness(layer, x, y, z - 1);
793 if (br1 > br) br = br1;
794 if (br2 > br) br = br2;
795 if (br3 > br) br = br3;
796 if (br4 > br) br = br4;
797 return br;
798 }
799 }
800
801 if(layer == LightLayer::Sky)
802 return getBrightnessSky(x, y, z);
803 return getBrightnessBlock(x, y, z);
804
805}
806int ChunkRebuildData::getLightColor(int x, int y, int z, int emitt) // 4J - change brought forward from 1.8.2
807{
808 int s = getBrightnessPropagate(LightLayer::Sky, x, y, z);
809 int b = getBrightnessPropagate(LightLayer::Block, x, y, z);
810 if (b < emitt) b = emitt;
811 return s << 20 | b << 4;
812}
813
814
815int ChunkRebuildData::getRawBrightness(int x, int y, int z)
816{
817 return getRawBrightness(x, y, z, true);
818}
819
820
821int ChunkRebuildData::getRawBrightness(int x, int y, int z, bool propagate)
822{
823 if (x < -Level_MAX_LEVEL_SIZE || z < -Level_MAX_LEVEL_SIZE || x >= Level_MAX_LEVEL_SIZE || z > Level_MAX_LEVEL_SIZE)
824 {
825 return Level_MAX_BRIGHTNESS;
826 }
827
828 if (propagate)
829 {
830 int id = getTile(x, y, z);
831 switch(id)
832 {
833 case Tile_SPU::stoneSlabHalf_Id:
834 case Tile_SPU::woodSlabHalf_Id:
835 case Tile_SPU::farmland_Id:
836 case Tile_SPU::stairs_stone_Id:
837 case Tile_SPU::stairs_wood_Id:
838 {
839 int br = getRawBrightness(x, y + 1, z, false);
840 int br1 = getRawBrightness(x + 1, y, z, false);
841 int br2 = getRawBrightness(x - 1, y, z, false);
842 int br3 = getRawBrightness(x, y, z + 1, false);
843 int br4 = getRawBrightness(x, y, z - 1, false);
844 if (br1 > br) br = br1;
845 if (br2 > br) br = br2;
846 if (br3 > br) br = br3;
847 if (br4 > br) br = br4;
848 return br;
849 }
850 break;
851 }
852 }
853
854 if (y < 0) return 0;
855 if (y >= Level_maxBuildHeight)
856 {
857 int br = Level_MAX_BRIGHTNESS - m_levelSkyDarken;
858 if (br < 0) br = 0;
859 return br;
860 }
861
862 return LevelChunk_getRawBrightness(x, y, z, m_levelSkyDarken);
863}
864
865int ChunkRebuildData::LevelChunk_getRawBrightness(int x, int y, int z, int skyDampen)
866{
867 int light = (m_flags & e_flag_HasCeiling) ? 0 : getBrightnessSky(x, y, z);
868 if (light > 0)
869 m_flags |= e_flag_TouchedSky;
870 light -= skyDampen;
871 int block = getBrightnessBlock(x, y, z);
872 if (block > light) light = block;
873
874 /*
875 * int xd = (absFloor(level.player.x-(this->x*16+x))); int yd =
876 * (absFloor(level.player.y-(y))); int zd =
877 * (absFloor(level.player.z-(this->z*16+z))); int dd = xd+yd+zd; if
878 * (dd<15){ int carried = 15-dd; if (carried<0) carried = 0; if
879 * (carried>15) carried = 15; if (carried > light) light = carried; }
880 */
881
882 return light;
883
884}
885
886
887Material_SPU *ChunkRebuildData::getMaterial(int x, int y, int z)
888{
889 int t = getTile(x, y, z);
890 int matID = Material_SPU::air_Id;
891 if (t != 0)
892 matID = m_tileData.materialIDs[t];
893 return &m_tileData.materials[matID];
894}