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.
43 kB · 1362 lines
C++
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362#include "stdafx.h"#include "CompressedTileStorage.h"
#ifdef __PSVITA__#define PSVITA_PRECOMPUTED_TABLE#endif
#ifdef __PS3__#include "..\SPU_Tasks\CompressedTileStorage_compress\CompressedTileStorage_compress.h"#include "C4JSpursJob.h"static const int sc_maxCompressTiles = 64;static CompressedTileStorage_compress_dataIn g_compressTileDataIn[sc_maxCompressTiles] __attribute__((__aligned__(16)));static int g_currentCompressTiles = 0;//#define DISABLE_SPU_CODE#endif //__PS3__
// Note: See header for an overview of this class
int CompressedTileStorage::deleteQueueIndex;XLockFreeStack <unsigned char> CompressedTileStorage::deleteQueue[3];
CRITICAL_SECTION CompressedTileStorage::cs_write;
#ifdef PSVITA_PRECOMPUTED_TABLE// AP - this will create a precomputed table to speed up getDatastatic int *CompressedTile_StorageIndexTable = NULL;
void CompressedTileStorage_InitTable(){ if( CompressedTile_StorageIndexTable == NULL ) { CompressedTile_StorageIndexTable = (int*) malloc(sizeof(int) * 64); for(int j = 0;j < 64;j += 1 ) { int index = ( ( j & 0x30 ) << 7) | ( ( j & 0x0c ) << 5 ) | ( j & 0x03 ); CompressedTile_StorageIndexTable[j] = index; } }}#endif
CompressedTileStorage::CompressedTileStorage(){ indicesAndData = NULL; allocatedSize = 0;
#ifdef PSVITA_PRECOMPUTED_TABLE CompressedTileStorage_InitTable();#endif}
CompressedTileStorage::CompressedTileStorage(CompressedTileStorage *copyFrom){ EnterCriticalSection(&cs_write); allocatedSize = copyFrom->allocatedSize; if(allocatedSize > 0) { indicesAndData = (unsigned char *)XPhysicalAlloc(allocatedSize, MAXULONG_PTR, 4096, PAGE_READWRITE);//(unsigned char *)malloc(allocatedSize); XMemCpy(indicesAndData, copyFrom->indicesAndData, allocatedSize); } else { indicesAndData = NULL; } LeaveCriticalSection(&cs_write);
#ifdef PSVITA_PRECOMPUTED_TABLE CompressedTileStorage_InitTable();#endif}
CompressedTileStorage::CompressedTileStorage(byteArray initFrom, unsigned int initOffset){ indicesAndData = NULL; allocatedSize = 0;
// We need 32768 bytes for a fully uncompressed chunk, plus 1024 for the index. Rounding up to nearest 4096 bytes for allocation indicesAndData = (unsigned char *)XPhysicalAlloc(32768+4096, MAXULONG_PTR, 4096, PAGE_READWRITE);
unsigned short *indices = (unsigned short *)indicesAndData; unsigned char *data = indicesAndData + 1024;
int offset = 0; for( int i = 0; i < 512; i++ ) { indices[i] = INDEX_TYPE_0_OR_8_BIT | ( offset << 1 );
if( initFrom.data ) { for( int j = 0; j < 64; j++ ) { *data++ = initFrom[getIndex(i,j) + initOffset]; } } else { for( int j = 0; j < 64; j++ ) { *data++ = 0; } }
offset += 64; }
allocatedSize = 32768 + 1024; // This is used for copying (see previous ctor), and as such it only needs to be the actual size of the data used rather than the one rounded up to a page size actually allocated
#ifdef PSVITA_PRECOMPUTED_TABLE CompressedTileStorage_InitTable();#endif}
bool CompressedTileStorage::isCompressed(){ return allocatedSize != 32768 + 1024;}
CompressedTileStorage::CompressedTileStorage(bool isEmpty){ indicesAndData = NULL; allocatedSize = 0;
// Empty and already compressed, so we only need 1K. Rounding up to nearest 4096 bytes for allocation#ifdef __PS3__ // XPhysicalAlloc just maps to malloc on PS3, so allocate the smallest amount indicesAndData = (unsigned char *)XPhysicalAlloc(1024, MAXULONG_PTR, 4096, PAGE_READWRITE);#else indicesAndData = (unsigned char *)XPhysicalAlloc(4096, MAXULONG_PTR, 4096, PAGE_READWRITE);#endif //__PS3__ unsigned short *indices = (unsigned short *)indicesAndData; //unsigned char *data = indicesAndData + 1024;
//int offset = 0; for( int i = 0; i < 512; i++ ) { indices[i] = INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG; }
allocatedSize = 1024; // This is used for copying (see previous ctor), and as such it only needs to be the actual size of the data used rather than the one rounded up to a page size actually allocated
#ifdef PSVITA_PRECOMPUTED_TABLE CompressedTileStorage_InitTable();#endif}
bool CompressedTileStorage::isRenderChunkEmpty(int y) // y == 0, 16, 32... 112 (representing a 16 byte range) { int block; unsigned short *blockIndices = (unsigned short *)indicesAndData;
for( int x = 0; x < 16; x += 4 ) for( int z = 0; z < 16; z += 4 ) { getBlock(&block, x, y, z); __uint64 *comp = (__uint64 *)&blockIndices[block]; // Are the 4 y regions stored here all zero? (INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG ) if( ( *comp ) != 0x0007000700070007L ) return false; } return true;}
bool CompressedTileStorage::isSameAs(CompressedTileStorage *other){ EnterCriticalSection(&cs_write); if( allocatedSize != other->allocatedSize ) { LeaveCriticalSection(&cs_write); return false; }
// Attempt to compare as much as we can in 64-byte chunks (8 groups of 8 bytes) int quickCount = allocatedSize / 64; __int64 *pOld = (__int64 *)indicesAndData; __int64 *pNew = (__int64 *)other->indicesAndData; for( int i = 0; i < quickCount; i++ ) { __int64 d0 = pOld[0] ^ pNew[0]; __int64 d1 = pOld[1] ^ pNew[1]; __int64 d2 = pOld[2] ^ pNew[2]; __int64 d3 = pOld[3] ^ pNew[3]; __int64 d4 = pOld[4] ^ pNew[4]; __int64 d5 = pOld[5] ^ pNew[5]; __int64 d6 = pOld[6] ^ pNew[6]; __int64 d7 = pOld[7] ^ pNew[7]; d0 |= d1; d2 |= d3; d4 |= d5; d6 |= d7; d0 |= d2; d4 |= d6; if( d0 | d4 ) { LeaveCriticalSection(&cs_write); return false; } pOld += 8; pNew += 8; }
// Now test anything remaining just byte at a time unsigned char *pucOld = (unsigned char *)pOld; unsigned char *pucNew = (unsigned char *)pNew; for( int i = 0; i < allocatedSize - (quickCount * 64); i++ ) { if( *pucOld++ != *pucNew++ ) { LeaveCriticalSection(&cs_write); return false; } }
LeaveCriticalSection(&cs_write); return true;}
CompressedTileStorage::~CompressedTileStorage(){#if 1 if(indicesAndData) XPhysicalFree(indicesAndData);#else if( (unsigned int)indicesAndData >= MM_PHYSICAL_4KB_BASE ) { if(indicesAndData) XPhysicalFree(indicesAndData); } else { if(indicesAndData) free(indicesAndData); }#endif}
// Get an index into the normal ordering of tiles for the java game, given a block index (0 to 511) and a tile index (0 to 63)inline int CompressedTileStorage::getIndex(int block, int tile){ // bits for index into data is: xxxxzzzzyyyyyyy // we want block(b) & tile(t) spread out as: // from: ______bbbbbbbbb // to: bb__bb__bbbbb__ // // from: _________tttttt // to: __tt__tt_____tt
int index = ( ( block & 0x180) << 6 ) | ( ( block & 0x060 ) << 4 ) | ( ( block & 0x01f ) << 2 ); index |= ( ( tile & 0x30 ) << 7) | ( ( tile & 0x0c ) << 5 ) | ( tile & 0x03 );
return index;}
// Get the block and tile (reversing getIndex above) for a given x, y, z coordinate//// bits for index into data is: xxxxzzzzyyyyyyy// bbttbbttbbbbbtt//// so x is: ___________xxxx// and maps to this bit of b ______bb_______// and this bit of t _________tt____//// y is: ________yyyyyyy// and maps to this bit of b __________bbbbb// and this bit of t _____________tt//// and z is: ___________zzzz// and maps to this bit of b ________bb_____// and this bit of t ___________tt__//
inline void CompressedTileStorage::getBlockAndTile(int *block, int *tile, int x, int y, int z){ *block = ( ( x & 0x0c ) << 5 ) | ( ( z & 0x0c ) << 3 ) | ( y >> 2 ); *tile = ( ( x & 0x03 ) << 4 ) | ( ( z & 0x03 ) << 2 ) | ( y & 0x03 );}
inline void CompressedTileStorage::getBlock(int *block, int x, int y, int z){ *block = ( ( x & 0x0c ) << 5 ) | ( ( z & 0x0c ) << 3 ) | ( y >> 2 );}
// Set all tile values from a data array of length 32768 (128 x 16 x 16).void CompressedTileStorage::setData(byteArray dataIn, unsigned int inOffset){ unsigned short _blockIndices[512];
EnterCriticalSection(&cs_write); unsigned char *data = dataIn.data + inOffset;
// Is the destination fully uncompressed? If so just write our data in - this happens when writing schematics and we don't want this setting of data to trigger compression if( allocatedSize == ( 32768 + 1024 ) ) { //unsigned short *indices = (unsigned short *)indicesAndData; unsigned char *dataOut = indicesAndData + 1024;
for( int i = 0; i < 512; i++ ) { for( int j = 0; j < 64; j++ ) { *dataOut++ = data[getIndex(i,j)]; } } LeaveCriticalSection(&cs_write); return; }
int offsets[512]; int memToAlloc = 0;// static int type0 = 0, type1 = 0, type2 = 0, type4 = 0, type8 = 0, chunkTotal = 0; // Loop round all blocks for( int i = 0; i < 512; i++ ) { offsets[i] = memToAlloc; // Count how many unique tile types are in the block - if unpacked_data isn't set then there isn't any data so we can't compress any further and require no storage. // Store flags for each tile type used in an array of 4 64-bit flags.
#ifdef __PSVITA__ // AP - Vita isn't so great at shifting 64bits. The top biggest CPU time sink after profiling is __ashldi3 (64bit shift) at 3% // Let's use 32bit instead unsigned int usedFlags[8] = {0,0,0,0,0,0,0,0}; __int32 i32_1 = 1; for( int j = 0; j < 64; j++ ) // This loop of 64 is to go round the 4 x 4 tiles in the block { int tile = data[getIndex(i,j)]; if( tile < (64<<2) ) { usedFlags[tile & 7] |= ( i32_1 << ( tile >> 3 ) ); } } int count = 0; for( int tile = 0; tile < 256; tile++ ) // This loop of 256 is to go round the 256 possible values that the tiles might have had to find how many are actually used { if( usedFlags[tile & 7] & ( i32_1 << ( tile >> 3 ) ) ) { count++; } }#else __uint64 usedFlags[4] = {0,0,0,0}; __int64 i64_1 = 1; // MGH - instead of 1i64, which is MS specific for( int j = 0; j < 64; j++ ) // This loop of 64 is to go round the 4 x 4 tiles in the block { int tile = data[getIndex(i,j)];
usedFlags[tile & 3] |= ( i64_1 << ( tile >> 2 ) ); } int count = 0; for( int tile = 0; tile < 256; tile++ ) // This loop of 256 is to go round the 256 possible values that the tiles might have had to find how many are actually used { if( usedFlags[tile & 3] & ( i64_1 << ( tile >> 2 ) ) ) { count++; } }#endif if( count == 1 ) { _blockIndices[i] = INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG;// type0++; } else if( count == 2 ) { _blockIndices[i] = INDEX_TYPE_1_BIT; memToAlloc += 10; // 8 bytes + 2 tile index// type1++; } else if ( count <= 4 ) { _blockIndices[i] = INDEX_TYPE_2_BIT; memToAlloc += 20; // 16 bytes + 4 tile index// type2++; } else if ( count <= 16 ) { _blockIndices[i] = INDEX_TYPE_4_BIT; memToAlloc += 48; // 32 bytes + 16 tile index// type4++; } else { _blockIndices[i] = INDEX_TYPE_0_OR_8_BIT; memToAlloc = ( memToAlloc + 3 ) & 0xfffc; // Make sure we are 4-byte aligned for 8-bit storage memToAlloc += 64;// type8++; } }
// chunkTotal++;// printf("%d: %d (0) %d (1) %d (2) %d (4) %d (8)\n", chunkTotal, type0 / chunkTotal, type1 / chunkTotal, type2 / chunkTotal, type4 / chunkTotal, type8 / chunkTotal);
memToAlloc += 1024; // For the indices unsigned char *newIndicesAndData = (unsigned char *)XPhysicalAlloc(memToAlloc, MAXULONG_PTR, 4096, PAGE_READWRITE);//(unsigned char *)malloc( memToAlloc ); unsigned char *pucData = newIndicesAndData + 1024; unsigned short usDataOffset = 0; unsigned short *newIndices = (unsigned short *) newIndicesAndData;
// Now pass through again actually making the final compressed data for( int i = 0; i < 512; i++ ) { unsigned short indexTypeNew = _blockIndices[i] & INDEX_TYPE_MASK; newIndices[i] = indexTypeNew;
if( indexTypeNew == INDEX_TYPE_0_OR_8_BIT ) { if( _blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) { newIndices[i] = INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG | (((unsigned short)data[getIndex(i,0)]) << INDEX_TILE_SHIFT); } else { usDataOffset = (usDataOffset + 3 ) & 0xfffc; for( int j = 0; j < 64; j++ ) // This loop of 64 is to go round the 4 x 4 x 4 tiles in the block { pucData[usDataOffset + j] = data[getIndex(i,j)]; } newIndices[i] |= ( usDataOffset & INDEX_OFFSET_MASK) << INDEX_OFFSET_SHIFT; usDataOffset += 64; } } else { // Need to repack - TODO - from here onwards! unsigned char ucMappings[256] = {0}; for( int j = 0; j < 256; j++ ) { ucMappings[j] = 255; }
unsigned char *repacked = NULL;
int bitspertile = 1 << indexTypeNew; // will be 1, 2 or 4 (from index values of 0, 1, 2) int tiletypecount = 1 << bitspertile; // will be 2, 4 or 16 (from index values of 0, 1, 2) //int tiletypemask = tiletypecount - 1; // will be 1, 3 or 15 (from index values of 0, 1, 2) int tiledatasize = 8 << indexTypeNew; // will be 8, 16 or 32 (from index values of 0, 1, 2) int indexshift = 3 - indexTypeNew; // will be 3, 2 or 1 (from index values of 0, 1, 2) int indexmask_bits = 7 >> indexTypeNew; // will be 7, 3 or 1 (from index values of 0, 1, 2) int indexmask_bytes = 62 >> indexshift; // will be 7, 15 or 31 (from index values of 0, 1, 2)
unsigned char *tile_types = pucData + usDataOffset; repacked = tile_types + tiletypecount; XMemSet(tile_types, 255, tiletypecount); XMemSet(repacked, 0,tiledatasize); newIndices[i] |= ( usDataOffset & INDEX_OFFSET_MASK) << INDEX_OFFSET_SHIFT; usDataOffset += tiletypecount + tiledatasize; int count = 0; for( int j = 0; j < 64; j++ ) { int tile = data[getIndex(i,j)]; if( ucMappings[tile] == 255 ) { ucMappings[tile] = count; tile_types[count++] = tile; } int idx = (j >> indexshift) & indexmask_bytes; int bit = ( j & indexmask_bits ) * bitspertile; repacked[idx] |= ucMappings[tile] << bit; } } }
if( indicesAndData ) { queueForDelete( indicesAndData ); } indicesAndData = newIndicesAndData; allocatedSize = memToAlloc; LeaveCriticalSection(&cs_write);}
#ifdef PSVITA_PRECOMPUTED_TABLE
// AP - When called in pairs from LevelChunk::getBlockData this version of getData reduces the time from ~5.2ms to ~1.6ms on the Vita// Gets all tile values into an array of length 32768.void CompressedTileStorage::getData(byteArray retArray, unsigned int retOffset){ unsigned short *blockIndices = (unsigned short *)indicesAndData; unsigned char *data = indicesAndData + 1024;
int k = 0; unsigned char *Array = &retArray.data[retOffset]; int *Table = CompressedTile_StorageIndexTable; for( int i = 0; i < 512; i++ ) { int indexType = blockIndices[i] & INDEX_TYPE_MASK;
int index = ( ( i & 0x180) << 6 ) | ( ( i & 0x060 ) << 4 ) | ( ( i & 0x01f ) << 2 ); unsigned char *NewArray = &Array[index];
if( indexType == INDEX_TYPE_0_OR_8_BIT ) { if( blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) { unsigned char val = ( blockIndices[i] >> INDEX_TILE_SHIFT ) & INDEX_TILE_MASK; for( int j = 0; j < 64; j++ ) { NewArray[Table[j]] = val; } } else { // 8-bit reads are just directly read from the 64 long array of values stored for the block unsigned char *packed = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK );
for( int j = 0; j < 64; j++ ) { NewArray[Table[j]] = packed[j]; } } } else { // 1, 2, or 4 bits per block packed format
int bitspertile = 1 << indexType; // will be 1, 2 or 4 (from index values of 0, 1, 2) int tiletypecount = 1 << bitspertile; // will be 2, 4 or 16 (from index values of 0, 1, 2) int tiletypemask = tiletypecount - 1; // will be 1, 3 or 15 (from index values of 0, 1, 2) int indexshift = 3 - indexType; // will be 3, 2 or 1 (from index values of 0, 1, 2) int indexmask_bits = 7 >> indexType; // will be 7, 3 or 1 (from index values of 0, 1, 2) int indexmask_bytes = 62 >> indexshift; // will be 7, 15 or 31 (from index values of 0, 1, 2)
unsigned char *tile_types = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK ); unsigned char *packed = tile_types + tiletypecount;
for( int j = 0; j < 64; j++ ) { int idx = ( j >> indexshift ) & indexmask_bytes; int bit = ( j & indexmask_bits ) << indexType; NewArray[Table[j]] = tile_types[( packed[idx] >> bit ) & tiletypemask]; } } }}
#else
// Gets all tile values into an array of length 32768.void CompressedTileStorage::getData(byteArray retArray, unsigned int retOffset){ unsigned short *blockIndices = (unsigned short *)indicesAndData; unsigned char *data = indicesAndData + 1024;
for( int i = 0; i < 512; i++ ) { int indexType = blockIndices[i] & INDEX_TYPE_MASK; if( indexType == INDEX_TYPE_0_OR_8_BIT ) { if( blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) { for( int j = 0; j < 64; j++ ) { retArray[getIndex(i,j) + retOffset] = ( blockIndices[i] >> INDEX_TILE_SHIFT ) & INDEX_TILE_MASK; } } else { // 8-bit reads are just directly read from the 64 long array of values stored for the block unsigned char *packed = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK );
for( int j = 0; j < 64; j++ ) { retArray[getIndex(i,j) + retOffset] = packed[j]; } } } else { // 1, 2, or 4 bits per block packed format
int bitspertile = 1 << indexType; // will be 1, 2 or 4 (from index values of 0, 1, 2) int tiletypecount = 1 << bitspertile; // will be 2, 4 or 16 (from index values of 0, 1, 2) int tiletypemask = tiletypecount - 1; // will be 1, 3 or 15 (from index values of 0, 1, 2) int indexshift = 3 - indexType; // will be 3, 2 or 1 (from index values of 0, 1, 2) int indexmask_bits = 7 >> indexType; // will be 7, 3 or 1 (from index values of 0, 1, 2) int indexmask_bytes = 62 >> indexshift; // will be 7, 15 or 31 (from index values of 0, 1, 2)
unsigned char *tile_types = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK ); unsigned char *packed = tile_types + tiletypecount;
for( int j = 0; j < 64; j++ ) { int idx = ( j >> indexshift ) & indexmask_bytes; int bit = ( j & indexmask_bits ) * bitspertile; retArray[getIndex(i,j) + retOffset] = tile_types[( packed[idx] >> bit ) & tiletypemask]; } } }}
#endif
// Get an individual tile valueint CompressedTileStorage::get(int x, int y, int z){ if(!indicesAndData) return 0;
unsigned short *blockIndices = (unsigned short *)indicesAndData; unsigned char *data = indicesAndData + 1024;
int block, tile; getBlockAndTile( &block, &tile, x, y, z ); int indexType = blockIndices[block] & INDEX_TYPE_MASK;
if( indexType == INDEX_TYPE_0_OR_8_BIT ) { if( blockIndices[block] & INDEX_TYPE_0_BIT_FLAG ) { // 0 bit reads are easy - the value is packed in the index return ( blockIndices[block] >> INDEX_TILE_SHIFT ) & INDEX_TILE_MASK; } else { // 8-bit reads are just directly read from the 64 long array of values stored for the block unsigned char *packed = data + ( ( blockIndices[block] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK ); return packed[tile]; } } else { int bitspertile = 1 << indexType; // will be 1, 2 or 4 (from index values of 0, 1, 2) int tiletypecount = 1 << bitspertile; // will be 2, 4 or 16 (from index values of 0, 1, 2) int tiletypemask = tiletypecount - 1; // will be 1, 3 or 15 (from index values of 0, 1, 2) int indexshift = 3 - indexType; // will be 3, 2 or 1 (from index values of 0, 1, 2) int indexmask_bits = 7 >> indexType; // will be 7, 3 or 1 (from index values of 0, 1, 2) int indexmask_bytes = 62 >> indexshift; // will be 7, 15 or 31 (from index values of 0, 1, 2)
unsigned char *tile_types = data + ( ( blockIndices[block] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK ); unsigned char *packed = tile_types + tiletypecount; int idx = ( tile >> indexshift ) & indexmask_bytes; int bit = ( tile & indexmask_bits ) * bitspertile; return tile_types[( packed[idx] >> bit ) & tiletypemask]; } return 0;}
// Set an individual tile valuevoid CompressedTileStorage::set(int x, int y, int z, int val){ EnterCriticalSection(&cs_write); assert(val !=255 ); int block, tile; getBlockAndTile( &block, &tile, x, y, z );
// 2 passes - first pass will try and store within the current levels of compression, then if that fails will // upgrade the block we are writing to (so more bits can be stored) to achieve the storage required for( int pass = 0; pass < 2; pass++ ) { unsigned short *blockIndices = (unsigned short *)indicesAndData; unsigned char *data = indicesAndData + 1024;
int indexType = blockIndices[block] & INDEX_TYPE_MASK;
if( indexType == INDEX_TYPE_0_OR_8_BIT ) { if( blockIndices[block] & INDEX_TYPE_0_BIT_FLAG ) { // 0 bits - if its the value already, we're done, otherwise continue on to upgrade storage if ( val == ( ( blockIndices[block] >> INDEX_TILE_SHIFT ) & INDEX_TILE_MASK ) ) { LeaveCriticalSection(&cs_write); return; } } else { // 8 bits - just store directly and we're done unsigned char *packed = data + ( ( blockIndices[block] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK ); packed[ tile ] = val; LeaveCriticalSection(&cs_write); return; } } else { int bitspertile = 1 << indexType; // will be 1, 2 or 4 (from index values of 0, 1, 2) int tiletypecount = 1 << bitspertile; // will be 2, 4 or 16 (from index values of 0, 1, 2) int tiletypemask = tiletypecount - 1; // will be 1, 3 or 15 (from index values of 0, 1, 2) int indexshift = 3 - indexType; // will be 3, 2 or 1 (from index values of 0, 1, 2) int indexmask_bits = 7 >> indexType; // will be 7, 3 or 1 (from index values of 0, 1, 2) int indexmask_bytes = 62 >> indexshift; // will be 7, 15 or 31 (from index values of 0, 1, 2)
unsigned char *tile_types = data + ( ( blockIndices[block] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK );
for( int i = 0; i < tiletypecount; i++ ) { if( ( tile_types[i] == val ) || ( tile_types[i] == 255 ) ) { tile_types[i] = val; unsigned char *packed = tile_types + tiletypecount; int idx = ( tile >> indexshift ) & indexmask_bytes; int bit = ( tile & indexmask_bits ) * bitspertile; packed[idx] &= ~( tiletypemask << bit ); packed[idx] |= i << bit; LeaveCriticalSection(&cs_write); return; } } } if( pass == 0 ) { compress(block); } }; LeaveCriticalSection(&cs_write);}
// Sets a region of tile values with the data at offset position in the array dataIn - external ordering compatible with java DataLayerint CompressedTileStorage::setDataRegion(byteArray dataIn, int x0, int y0, int z0, int x1, int y1, int z1, int offset, tileUpdatedCallback callback, void *param, int yparam){ unsigned char *pucIn = &dataIn.data[offset];
if( callback ) { for( int x = x0; x < x1; x++ ) { for( int z = z0; z < z1; z++ ) { for( int y = y0; y < y1; y++ ) { if(get(x, y, z) != *pucIn) { set(x, y, z, *pucIn); callback(x, y, z, param, yparam); } pucIn++; } } } } else { for( int x = x0; x < x1; x++ ) { for( int z = z0; z < z1; z++ ) { for( int y = y0; y < y1; y++ ) { set(x, y, z, *pucIn++); } } } } ptrdiff_t count = pucIn - &dataIn.data[offset];
return (int)count;}
// Tests whether setting data would actually change anythingbool CompressedTileStorage::testSetDataRegion(byteArray dataIn, int x0, int y0, int z0, int x1, int y1, int z1, int offset){ unsigned char *pucIn = &dataIn.data[offset]; for( int x = x0; x < x1; x++ ) { for( int z = z0; z < z1; z++ ) { for( int y = y0; y < y1; y++ ) { if(get(x, y, z) != *pucIn++) { return true; } } } } return false;}
// Updates the data at offset position dataInOut with a region of tile information - external ordering compatible with java DataLayerint CompressedTileStorage::getDataRegion(byteArray dataInOut, int x0, int y0, int z0, int x1, int y1, int z1, int offset){ unsigned char *pucOut = &dataInOut.data[offset]; for( int x = x0; x < x1; x++ ) { for( int z = z0; z < z1; z++ ) { for( int y = y0; y < y1; y++ ) { *pucOut++ = get(x, y, z); } } } ptrdiff_t count = pucOut - &dataInOut.data[offset];
return (int)count;}
void CompressedTileStorage::staticCtor(){ InitializeCriticalSectionAndSpinCount(&cs_write, 5120); for( int i = 0; i < 3; i++ ) { deleteQueue[i].Initialize(); }}
void CompressedTileStorage::queueForDelete(unsigned char *data){ // Add this into a queue for deleting. This shouldn't be actually deleted until tick has been called twice from when // the data went into the queue. if( data ) { deleteQueue[deleteQueueIndex].Push( data ); }}
void CompressedTileStorage::tick(){ // We have 3 queues for deleting. Always delete from the next one after where we are writing to, so it should take 2 ticks // before we ever delete something, from when the request to delete it came in int freeIndex = ( deleteQueueIndex + 1 ) % 3;
// printf("Free queue: %d, %d\n",deleteQueue[freeIndex].GetEntryCount(),deleteQueue[freeIndex].GetAllocated()); unsigned char *toFree = NULL; do { toFree = deleteQueue[freeIndex].Pop();// if( toFree ) printf("Deleting 0x%x\n", toFree);#if 1 if( toFree ) XPhysicalFree(toFree);#else // Determine correct means to free this data - could have been allocated either with XPhysicalAlloc or malloc if( (unsigned int)toFree >= MM_PHYSICAL_4KB_BASE ) { XPhysicalFree(toFree); } else { free(toFree); }#endif } while( toFree );
deleteQueueIndex = ( deleteQueueIndex + 1 ) % 3;}
#ifdef __PS3__void CompressedTileStorage::compress_SPU(int upgradeBlock/*=-1*/){ EnterCriticalSection(&cs_write); static unsigned char compBuffer[32768+4096] __attribute__((__aligned__(16))); CompressedTileStorage_compress_dataIn& dataIn = g_compressTileDataIn[0]; dataIn.allocatedSize = allocatedSize; dataIn.indicesAndData = indicesAndData; dataIn.newIndicesAndData = compBuffer; dataIn.upgradeBlock = upgradeBlock;
static C4JSpursJobQueue::Port p("CompressedTileStorage::compress_SPU"); C4JSpursJob_CompressedTileStorage_compress compressJob(&dataIn); p.submitJob(&compressJob); p.waitForCompletion();
if(dataIn.neededCompressed) { unsigned char *newIndicesAndData = (unsigned char *)XPhysicalAlloc(dataIn.newAllocatedSize, MAXULONG_PTR, 4096, PAGE_READWRITE);//(unsigned char *)malloc( memToAlloc ); memcpy(newIndicesAndData, compBuffer, dataIn.newAllocatedSize); queueForDelete( indicesAndData ); indicesAndData = newIndicesAndData; allocatedSize = dataIn.newAllocatedSize; }
LeaveCriticalSection(&cs_write);
}#endif
// Compresses the data currently stored in one of two ways:// (1) Attempt to compresses every block as much as possible (if upgradeBlock is -1)// (2) Copy all blocks as-is apart from the block specified by upgradeBlock ( if > -1 ), which is changed to be the next-most-accomodating storage from its current statevoid CompressedTileStorage::compress(int upgradeBlock/*=-1*/){#if defined __PS3__ && !defined DISABLE_SPU_CODE compress_SPU(upgradeBlock); return;#endif
unsigned char tempdata[64]; unsigned short _blockIndices[512];
// If this is already fully compressed, early out if( ( allocatedSize == 1024 ) && ( upgradeBlock == -1 ) ) return;
bool needsCompressed = ( upgradeBlock > -1 ); // If an upgrade block is specified, we'll always need to recompress - otherwise default to false
EnterCriticalSection(&cs_write);
unsigned short *blockIndices = (unsigned short *)indicesAndData; unsigned char *data = indicesAndData + 1024;
int memToAlloc = 0; for( int i = 0; i < 512; i++ ) { unsigned short indexType = blockIndices[i] & INDEX_TYPE_MASK;
unsigned char *unpacked_data = NULL; unsigned char *packed_data;
// First task is to find out what type of storage each block needs. Need to unpack each where required. // Note that we don't need to fully unpack the data at this stage since we are only interested in working out how many unique types of tiles are in each block, not // what those actual tile ids are. if( upgradeBlock == -1 ) { if( indexType == INDEX_TYPE_0_OR_8_BIT ) { // Note that we are only interested in data that can be packed further, so we don't need to consider things that are already at their most compressed // (ie with INDEX_TYPE_0_BIT_FLAG set) if( ( blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) == 0 ) { unpacked_data = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK ); } } else { int bitspertile = 1 << indexType; // will be 1, 2 or 4 (from index values of 0, 1, 2) int tiletypecount = 1 << bitspertile; // will be 2, 4 or 16 int tiletypemask = tiletypecount - 1; // will be 1, 3 or 15 int indexshift = 3 - indexType; // will be 3, 2 or 1 (from index values of 0, 1, 2) int indexmask_bits = 7 >> indexType; // will be 7, 3 or 1 (from index values of 0, 1, 2) int indexmask_bytes = 62 >> indexshift; // will be 7, 15 or 31 (from index values of 0, 1, 2)
unpacked_data = tempdata; packed_data = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK ) + tiletypecount;
for( int j = 0; j < 64; j++ ) { int idx = (j >> indexshift) & indexmask_bytes; int bit = ( j & indexmask_bits ) * bitspertile;
unpacked_data[j] = ( packed_data[idx] >> bit ) & tiletypemask; // Doesn't need the actual data for each tile, just unique values } }
if( unpacked_data ) { // Now count how many unique tile types are in the block - if unpacked_data isn't set then there isn't any data so we can't compress any further and require no storage. // Store flags for each tile type used in an array of 4 64-bit flags.
#ifdef __PSVITA__ // AP - Vita isn't so great at shifting 64bits. The top biggest CPU time sink after profiling is __ashldi3 (64bit shift) at 3% // lets use 32bit values instead unsigned int usedFlags[8] = {0,0,0,0,0,0,0,0}; __int32 i32_1 = 1; for( int j = 0; j < 64; j++ ) // This loop of 64 is to go round the 4x4x4 tiles in the block { int tiletype = unpacked_data[j]; usedFlags[tiletype & 7] |= ( i32_1 << ( tiletype >> 3 ) ); } // count the number of bits set using the 'Hammering Weight' method. This reduces ::compress total thread cpu consumption from 10% to 4% unsigned int count = 0; for( int Index = 0;Index < 8;Index += 1 ) { unsigned int i = usedFlags[Index]; i = i - ((i >> 1) & 0x55555555); i = (i & 0x33333333) + ((i >> 2) & 0x33333333); count += (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24; }#else
__uint64 usedFlags[4] = {0,0,0,0}; __int64 i64_1 = 1; // MGH - instead of 1i64, which is MS specific for( int j = 0; j < 64; j++ ) // This loop of 64 is to go round the 4x4x4 tiles in the block { int tiletype = unpacked_data[j]; usedFlags[tiletype & 3] |= ( i64_1 << ( tiletype >> 2 ) ); } int count = 0; for( int tiletype = 0; tiletype < 256; tiletype++ ) // This loop of 256 is to go round the 256 possible values that the tiles might have had to find how many are actually used { if( usedFlags[tiletype & 3] & ( i64_1 << ( tiletype >> 2 ) ) ) { count++; } }#endif
if( count == 1 ) { _blockIndices[i] = INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG;
// We'll need to compress if this isn't the same type as before. If it *was* a 0-bit one though, then unpacked_data wouldn't have been set and we wouldn't be here needsCompressed = true; } else if( count == 2 ) { _blockIndices[i] = INDEX_TYPE_1_BIT; if( indexType != INDEX_TYPE_1_BIT ) needsCompressed = true; memToAlloc += 10; // 8 bytes + 2 tile index } else if ( count <= 4 ) { _blockIndices[i] = INDEX_TYPE_2_BIT; if( indexType != INDEX_TYPE_2_BIT ) needsCompressed = true; memToAlloc += 20; // 16 bytes + 4 tile index } else if ( count <= 16 ) { _blockIndices[i] = INDEX_TYPE_4_BIT; if( indexType != INDEX_TYPE_4_BIT ) needsCompressed = true; memToAlloc += 48; // 32 bytes + 16 tile index } else { _blockIndices[i] = INDEX_TYPE_0_OR_8_BIT; memToAlloc = ( memToAlloc + 3 ) & 0xfffc; // Make sure we are 4-byte aligned for 8-bit storage memToAlloc += 64; } } else { // Already will be 0 bits, so we can't do any further compression - just copy the index over. _blockIndices[i] = blockIndices[i]; } } else { if( i == upgradeBlock ) { // INDEX_TYPE_1_BIT (0) -> INDEX_TYPE_2_BIT (1) // INDEX_TYPE_2_BIT (1) -> INDEX_TYPE_4_BIT (2) // INDEX_TYPE_4_BIT (2) -> INDEX_TYPE_0_OR_8_BIT (3) (new will be 8-bit) // INDEX_TYPE_0_OR_8_BIT (3) -> INDEX_TYPE_1_BIT (0) (assuming old was 0-bit) _blockIndices[i] = ( ( blockIndices[i] & INDEX_TYPE_MASK ) + 1 ) & INDEX_TYPE_MASK; } else { // Copy over the index, without the offset. _blockIndices[i] = blockIndices[i] & INDEX_TYPE_MASK; if( _blockIndices[i] == INDEX_TYPE_0_OR_8_BIT ) { _blockIndices[i] |= ( blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ); } } switch(_blockIndices[i]) { case INDEX_TYPE_1_BIT: memToAlloc += 10; break; case INDEX_TYPE_2_BIT: memToAlloc += 20; break; case INDEX_TYPE_4_BIT: memToAlloc += 48; break; case INDEX_TYPE_0_OR_8_BIT: memToAlloc = ( memToAlloc + 3 ) & 0xfffc; // Make sure we are 4-byte aligned for 8-bit storage memToAlloc += 64; break; // Note that INDEX_TYPE_8_BIT|INDEX_TYPE_0_BIT_FLAG not in here as it doesn't need any further allocation } } }
// If we need to do something here, then lets allocate some memory if( needsCompressed ) { memToAlloc += 1024; // For the indices unsigned char *newIndicesAndData = (unsigned char *)XPhysicalAlloc(memToAlloc, MAXULONG_PTR, 4096, PAGE_READWRITE);//(unsigned char *)malloc( memToAlloc ); if( newIndicesAndData == NULL ) { DWORD lastError = GetLastError();#ifndef _DURANGO MEMORYSTATUS memStatus; GlobalMemoryStatus(&memStatus); __debugbreak();#endif } unsigned char *pucData = newIndicesAndData + 1024; unsigned short usDataOffset = 0; unsigned short *newIndices = (unsigned short *) newIndicesAndData;
// Now pass through again actually making the final compressed data for( int i = 0; i < 512; i++ ) { unsigned short indexTypeNew = _blockIndices[i] & INDEX_TYPE_MASK; unsigned short indexTypeOld = blockIndices[i] & INDEX_TYPE_MASK; newIndices[i] = indexTypeNew;
// Is the type unmodifed? Then can just copy over bool done = false; if( indexTypeOld == indexTypeNew ) { unsigned char *packed_data; if( indexTypeOld == INDEX_TYPE_0_OR_8_BIT ) { if( ( blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) == ( _blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) ) { if( blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) { newIndices[i] = blockIndices[i]; } else { packed_data = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK); usDataOffset = (usDataOffset + 3 ) & 0xfffc; XMemCpy( pucData + usDataOffset, packed_data, 64 ); newIndices[i] |= ( usDataOffset & INDEX_OFFSET_MASK) << INDEX_OFFSET_SHIFT; usDataOffset += 64; } done = true; } } else { packed_data = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK); int dataSize = 8 << indexTypeOld; // 8, 16 or 32 bytes of per-tile storage dataSize += 1 << ( 1 << indexTypeOld ); // 2, 4 or 16 bytes to store each tile type newIndices[i] |= ( usDataOffset & INDEX_OFFSET_MASK) << INDEX_OFFSET_SHIFT; XMemCpy( pucData + usDataOffset, packed_data, dataSize ); usDataOffset += dataSize; done = true; } }
// If we're not done, then we actually need to recompress this block. First of all decompress from its current format. if( !done ) { unsigned char *unpacked_data = NULL; unsigned char *tile_types = NULL; unsigned char *packed_data = NULL; if( indexTypeOld == INDEX_TYPE_0_OR_8_BIT ) { if( blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) { unpacked_data = tempdata; int value = ( blockIndices[i] >> INDEX_TILE_SHIFT ) & INDEX_TILE_MASK; XMemSet( tempdata, value, 64 ); } else { unpacked_data = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK ); } } else { int bitspertile = 1 << indexTypeOld; // will be 1, 2 or 4 (from index values of 0, 1, 2) int tiletypecount = 1 << bitspertile; // will be 2, 4 or 16 int tiletypemask = tiletypecount - 1; // will be 1, 3 or 15 int indexshift = 3 - indexTypeOld; // will be 3, 2 or 1 (from index values of 0, 1, 2) int indexmask_bits = 7 >> indexTypeOld; // will be 7, 3 or 1 (from index values of 0, 1, 2) int indexmask_bytes = 62 >> indexshift; // will be 7, 15 or 31 (from index values of 0, 1, 2)
unpacked_data = tempdata; tile_types = data + ( ( blockIndices[i] >> INDEX_OFFSET_SHIFT ) & INDEX_OFFSET_MASK ); packed_data = tile_types + tiletypecount; for( int j = 0; j < 64; j++ ) { int idx = ( j >> indexshift ) & indexmask_bytes; int bit = ( j & indexmask_bits ) * bitspertile;
unpacked_data[j] = tile_types[(packed_data[idx] >> bit) & tiletypemask]; } }
// And finally repack unsigned char ucMappings[256] = {0};#ifdef __PSVITA__ memset(ucMappings, 255, 256);#else for( int j = 0; j < 256; j++ ) { ucMappings[j] = 255; }#endif
unsigned char *repacked = NULL;
if( indexTypeNew == INDEX_TYPE_0_OR_8_BIT ) { if( _blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) { newIndices[i] = INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG | (((unsigned short)unpacked_data[0]) << INDEX_TILE_SHIFT); } else { usDataOffset = (usDataOffset + 3 ) & 0xfffc; // Make sure offset is 4 byte aligned XMemCpy( pucData + usDataOffset, unpacked_data, 64 ); newIndices[i] |= ( usDataOffset & INDEX_OFFSET_MASK) << INDEX_OFFSET_SHIFT; usDataOffset += 64; } } else { int bitspertile = 1 << indexTypeNew; // will be 1, 2 or 4 (from index values of 0, 1, 2) int tiletypecount = 1 << bitspertile; // will be 2, 4 or 16 (from index values of 0, 1, 2) int tiletypemask = tiletypecount - 1; // will be 1, 3 or 15 (from index values of 0, 1, 2) int tiledatasize = 8 << indexTypeNew; // will be 8, 16 or 32 (from index values of 0, 1, 2) int indexshift = 3 - indexTypeNew; // will be 3, 2 or 1 (from index values of 0, 1, 2) int indexmask_bits = 7 >> indexTypeNew; // will be 7, 3 or 1 (from index values of 0, 1, 2) int indexmask_bytes = 62 >> indexshift; // will be 7, 15 or 31 (from index values of 0, 1, 2)
tile_types = pucData + usDataOffset; repacked = tile_types + tiletypecount; XMemSet(tile_types, 255, tiletypecount); XMemSet(repacked, 0,tiledatasize); newIndices[i] |= ( usDataOffset & INDEX_OFFSET_MASK) << INDEX_OFFSET_SHIFT; usDataOffset += tiletypecount + tiledatasize; int count = 0; for( int j = 0; j < 64; j++ ) { int tile = unpacked_data[j]; if( ucMappings[tile] == 255 ) { ucMappings[tile] = count; tile_types[count++] = tile; } int idx = (j >> indexshift) & indexmask_bytes; int bit = ( j & indexmask_bits ) * bitspertile; repacked[idx] |= ucMappings[tile] << bit; } } } }
queueForDelete( indicesAndData ); indicesAndData = newIndicesAndData; allocatedSize = memToAlloc; } LeaveCriticalSection(&cs_write);}
int CompressedTileStorage::getAllocatedSize(int *count0, int *count1, int *count2, int *count4, int *count8){ *count0 = 0; *count1 = 0; *count2 = 0; *count4 = 0; *count8 = 0;
unsigned short *blockIndices = (unsigned short *)indicesAndData; for(int i = 0; i < 512; i++ ) { unsigned short idxType = blockIndices[i] & INDEX_TYPE_MASK; if( idxType == INDEX_TYPE_1_BIT ) { (*count1)++; } else if( idxType == INDEX_TYPE_2_BIT ) { (*count2)++; } else if( idxType == INDEX_TYPE_4_BIT ) { (*count4)++; } else if( idxType == INDEX_TYPE_0_OR_8_BIT ) { if( blockIndices[i] & INDEX_TYPE_0_BIT_FLAG ) { (*count0)++; } else { (*count8)++; } } } return allocatedSize;}
int CompressedTileStorage::getHighestNonEmptyY(){ unsigned short *blockIndices = (unsigned short *)indicesAndData; unsigned int highestYBlock = 0; bool found = false;
// The 512 "blocks" (4x4x4 tiles) are arranged in 32 layers for(int yBlock = 31; yBlock >= 0; --yBlock) { // Each layer has 16 blocks for(unsigned int xzBlock = 0; xzBlock < 16; ++xzBlock) { // Blocks are ordered in columns int index = yBlock + (xzBlock * 32);
int indexType = blockIndices[index] & INDEX_TYPE_MASK; if( indexType == INDEX_TYPE_0_OR_8_BIT && blockIndices[index] & INDEX_TYPE_0_BIT_FLAG ) { int val = ( blockIndices[index] >> INDEX_TILE_SHIFT ) & INDEX_TILE_MASK; if(val != 0) { highestYBlock = yBlock; found = true; break; } } else { highestYBlock = yBlock; found = true; break; } }
if(found) break; } int highestNonEmptyY = -1; if(found) { // Multiply by the number of vertical tiles in a block, and then add that again to be at the top of the block highestNonEmptyY = (highestYBlock * 4) + 4; } return highestNonEmptyY;}
void CompressedTileStorage::write(DataOutputStream *dos){ dos->writeInt(allocatedSize); if(indicesAndData) { if(LOCALSYTEM_ENDIAN == BIGENDIAN) { // The first 1024 bytes are an array of shorts, so we need to reverse the endianness byteArray indicesCopy(1024); memcpy(indicesCopy.data, indicesAndData, 1024); reverseIndices(indicesCopy.data); dos->write(indicesCopy); delete [] indicesCopy.data;
// Write the rest of the data if(allocatedSize > 1024) { byteArray dataWrapper(indicesAndData + 1024, allocatedSize - 1024); dos->write(dataWrapper); } } else { byteArray wrapper(indicesAndData, allocatedSize); dos->write(wrapper); } }}
void CompressedTileStorage::read(DataInputStream *dis){ allocatedSize = dis->readInt(); if(allocatedSize > 0) { // This delete should be safe to do in a non-thread safe way as the chunk is fully read before any external reference is available to it from another thread if( indicesAndData ) { XPhysicalFree(indicesAndData); } indicesAndData = (unsigned char *)XPhysicalAlloc(allocatedSize, MAXULONG_PTR, 4096, PAGE_READWRITE);
byteArray wrapper(indicesAndData, allocatedSize); dis->readFully(wrapper); if(LOCALSYTEM_ENDIAN == BIGENDIAN) { reverseIndices(indicesAndData); }
compress(); }}
void CompressedTileStorage::reverseIndices(unsigned char *indices){ unsigned short *blockIndices = (unsigned short *)indices; for( int i = 0; i < 512; i++ ) { System::ReverseUSHORT(&blockIndices[i]); }}