Karutoh/MinecraftConsoles
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Project modernization (#630)"

Browse Source 
This code was not tested and breaks in Release builds, reverting to restore
functionality of the nightly. All in-game menus do not work and generating
a world crashes.

This reverts commit a9be52c41a.
This commit is contained in:
Loki Rautio
2026-03-07 21:12:22 -06:00
parent a9be52c41a
commit 087b7e7abf
1373 changed files with 19449 additions and 19903 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
Minecraft.World/SparseDataStorage.cpp
View File

@@ -28,7 +28,7 @@ SparseDataStorage::SparseDataStorage()
#ifdef _XBOX
unsigned char *planeIndices = (unsigned char *)XPhysicalAlloc(128 * 128, MAXULONG_PTR, 4096, PAGE_READWRITE);
#else
unsigned char *planeIndices = static_cast<unsigned char *>(malloc(128 * 128));
unsigned char *planeIndices = (unsigned char *)malloc(128 * 128);
#endif
unsigned char *data = planeIndices + 128;
planeIndices[0] = ALL_0_INDEX;
@@ -51,7 +51,7 @@ SparseDataStorage::SparseDataStorage(bool isUpper)
{
// Allocate using physical alloc. As this will (by default) return memory from the pool of 4KB pages, the address will in the range of MM_PHYSICAL_4KB_BASE upwards. We can use
// this fact to identify the allocation later, and so free it with the corresponding call to XPhysicalFree.
unsigned char *planeIndices = static_cast<unsigned char *>(malloc(128));
unsigned char *planeIndices = (unsigned char *)malloc(128);
for( int i = 0; i < 128; i++ )
{
planeIndices[i] = ALL_0_INDEX;
@@ -87,12 +87,12 @@ SparseDataStorage::~SparseDataStorage()
SparseDataStorage::SparseDataStorage(SparseDataStorage *copyFrom)
{
// Extra details of source storage
const int64_t sourceDataAndCount = copyFrom->dataAndCount;
const unsigned char *sourceIndicesAndData = (unsigned char *)(sourceDataAndCount & 0x0000ffffffffffff);
int64_t sourceDataAndCount = copyFrom->dataAndCount;
unsigned char *sourceIndicesAndData = (unsigned char *)(sourceDataAndCount & 0x0000ffffffffffff);
int sourceCount = (sourceDataAndCount >> 48 ) & 0xffff;
// Allocate & copy indices ( 128 bytes ) and any allocated planes (128 * count)
unsigned char *destIndicesAndData = static_cast<unsigned char *>(malloc(sourceCount * 128 + 128));
unsigned char *destIndicesAndData = (unsigned char *)malloc( sourceCount * 128 + 128 );
// AP - I've moved this to be before the memcpy because of a very strange bug on vita. Sometimes dataAndCount wasn't valid in time when ::get was called.
// This should never happen and this isn't a proper solution but fixes it for now.
@@ -129,10 +129,10 @@ void SparseDataStorage::setData(byteArray dataIn, unsigned int inOffset)
for( int xz = 0; xz < 256; xz++ ) // 256 in loop as 16 x 16 separate bytes need checked
{
const int pos = ( xz << 7 ) | y;
const int slot = pos >> 1;
const int part = pos & 1;
const unsigned char value = ( dataIn[slot + inOffset] >> (part * 4) ) & 15;
int pos = ( xz << 7 ) | y;
int slot = pos >> 1;
int part = pos & 1;
unsigned char value = ( dataIn[slot + inOffset] >> (part * 4) ) & 15;
if( value != 0 ) all0 = false;
}
if( all0 )
@@ -146,7 +146,7 @@ void SparseDataStorage::setData(byteArray dataIn, unsigned int inOffset)
}
// Allocate required storage
unsigned char *planeIndices = static_cast<unsigned char *>(malloc(128 * allocatedPlaneCount + 128));
unsigned char *planeIndices = (unsigned char *)malloc(128 * allocatedPlaneCount + 128);
unsigned char *data = planeIndices + 128;
XMemCpy(planeIndices, _planeIndices, 128);
@@ -158,9 +158,9 @@ void SparseDataStorage::setData(byteArray dataIn, unsigned int inOffset)
// we know they were sequentially allocated above.
if( planeIndices[y] < 128 )
{
const int part = y & 1;
int part = y & 1;
//int shift = 4 * part;
const unsigned char *pucIn = &dataIn[ (y >> 1) + inOffset];
unsigned char *pucIn = &dataIn[ (y >> 1) + inOffset];
for( int xz = 0; xz < 128; xz++ ) // 128 ( 16 x 16 x 0.5 ) in loop as packing 2 values into each destination byte
{
@@ -176,9 +176,9 @@ void SparseDataStorage::setData(byteArray dataIn, unsigned int inOffset)
// Get new data and count packed info
#pragma warning ( disable : 4826 )
int64_t newDataAndCount = reinterpret_cast<int64_t>(planeIndices) & 0x0000ffffffffffffL;
int64_t newDataAndCount = ((int64_t) planeIndices) & 0x0000ffffffffffffL;
#pragma warning ( default : 4826 )
newDataAndCount |= static_cast<int64_t>(allocatedPlaneCount) << 48;
newDataAndCount |= ((int64_t)allocatedPlaneCount) << 48;
updateDataAndCount( newDataAndCount );
}
@@ -205,10 +205,10 @@ void SparseDataStorage::getData(byteArray retArray, unsigned int retOffset)
}
else
{
const int part = y & 1;
const int shift = 4 * part;
int part = y & 1;
int shift = 4 * part;
unsigned char *pucOut = &retArray.data[ (y >> 1) + + retOffset];
const unsigned char *pucIn = &data[ planeIndices[ y ] * 128 ];
unsigned char *pucIn = &data[ planeIndices[ y ] * 128 ];
for( int xz = 0; xz < 128; xz++ ) // 128 in loop (16 x 16 x 0.5) as input data is being treated in pairs of nybbles that are packed in the same byte
{
unsigned char value = (*pucIn) & 15;
@@ -237,10 +237,10 @@ int SparseDataStorage::get(int x, int y, int z)
}
else
{
const int planeIndex = x * 16 + z; // Index within this xz plane
const int byteIndex = planeIndex / 2; // Byte index within the plane (2 tiles stored per byte)
const int shift = ( planeIndex & 1 ) * 4; // Bit shift within the byte
const int retval = ( data[ planeIndices[y] * 128 + byteIndex ] >> shift ) & 15;
int planeIndex = x * 16 + z; // Index within this xz plane
int byteIndex = planeIndex / 2; // Byte index within the plane (2 tiles stored per byte)
int shift = ( planeIndex & 1 ) * 4; // Bit shift within the byte
int retval = ( data[ planeIndices[y] * 128 + byteIndex ] >> shift ) & 15;
return retval;
}
@@ -270,12 +270,12 @@ void SparseDataStorage::set(int x, int y, int z, int val)
// Either data was already allocated, or we've just done that. Now store our value into the right place.
const int planeIndex = x * 16 + z; // Index within this xz plane
const int byteIndex = planeIndex / 2; // Byte index within the plane (2 tiles stored per byte)
const int shift = ( planeIndex & 1 ) * 4; // Bit shift within the byte
const int mask = 0xf0 >> shift;
int planeIndex = x * 16 + z; // Index within this xz plane
int byteIndex = planeIndex / 2; // Byte index within the plane (2 tiles stored per byte)
int shift = ( planeIndex & 1 ) * 4; // Bit shift within the byte
int mask = 0xf0 >> shift;
const int idx = planeIndices[y] * 128 + byteIndex;
int idx = planeIndices[y] * 128 + byteIndex;
data[idx] = ( data[idx] & mask ) | ( val << shift );
}
@@ -288,7 +288,7 @@ void SparseDataStorage::set(int x, int y, int z, int val)
int SparseDataStorage::setDataRegion(byteArray dataIn, int x0, int y0, int z0, int x1, int y1, int z1, int offset, tileUpdatedCallback callback, void *param, int yparam)
{
// Actual setting of data happens when calling set method so no need to lock here
const unsigned char *pucIn = &dataIn.data[offset];
unsigned char *pucIn = &dataIn.data[offset];
if( callback )
{
for( int x = x0; x < x1; x++ )
@@ -296,11 +296,11 @@ int SparseDataStorage::setDataRegion(byteArray dataIn, int x0, int y0, int z0, i
for( int z = z0; z < z1; z++ )
{
// Emulate how data was extracted from DataLayer... see comment above
const int yy0 = y0 & 0xfffffffe;
const int len = ( y1 - y0 ) / 2;
int yy0 = y0 & 0xfffffffe;
int len = ( y1 - y0 ) / 2;
for( int i = 0; i < len; i++ )
{
const int y = yy0 + ( i * 2 );
int y = yy0 + ( i * 2 );
int toSet = (*pucIn) & 15;
if( get(x, y, z) != toSet )
@@ -326,11 +326,11 @@ int SparseDataStorage::setDataRegion(byteArray dataIn, int x0, int y0, int z0, i
for( int z = z0; z < z1; z++ )
{
// Emulate how data was extracted from DataLayer... see comment above
const int yy0 = y0 & 0xfffffffe;
const int len = ( y1 - y0 ) / 2;
int yy0 = y0 & 0xfffffffe;
int len = ( y1 - y0 ) / 2;
for( int i = 0; i < len; i++ )
{
const int y = yy0 + ( i * 2 );
int y = yy0 + ( i * 2 );
set(x, y, z, (*pucIn) & 15 );
set(x, y + 1, z, ((*pucIn) >> 4 ) & 15 );
@@ -339,9 +339,9 @@ int SparseDataStorage::setDataRegion(byteArray dataIn, int x0, int y0, int z0, i
}
}
}
const ptrdiff_t count = pucIn - &dataIn.data[offset];
ptrdiff_t count = pucIn - &dataIn.data[offset];
return static_cast<int>(count);
return (int)count;
}
// Updates the data at offset position dataInOut with a region of data information - external ordering compatible with java DataLayer
@@ -357,11 +357,11 @@ int SparseDataStorage::getDataRegion(byteArray dataInOut, int x0, int y0, int z0
for( int z = z0; z < z1; z++ )
{
// Emulate how data was extracted from DataLayer... see comment above
const int yy0 = y0 & 0xfffffffe;
const int len = ( y1 - y0 ) / 2;
int yy0 = y0 & 0xfffffffe;
int len = ( y1 - y0 ) / 2;
for( int i = 0; i < len; i++ )
{
const int y = yy0 + ( i * 2 );
int y = yy0 + ( i * 2 );
*pucOut = get( x, y, z);
*pucOut |= get( x, y + 1, z) << 4;
@@ -369,9 +369,9 @@ int SparseDataStorage::getDataRegion(byteArray dataInOut, int x0, int y0, int z0
}
}
}
const ptrdiff_t count = pucOut - &dataInOut.data[offset];
ptrdiff_t count = pucOut - &dataInOut.data[offset];
return static_cast<int>(count);
return (int)count;
}
void SparseDataStorage::addNewPlane(int y)
@@ -380,34 +380,34 @@ void SparseDataStorage::addNewPlane(int y)
do
{
// Get last packed data pointer & count
const int64_t lastDataAndCount = dataAndCount;
int64_t lastDataAndCount = dataAndCount;
// Unpack count & data pointer
const int lastLinesUsed = static_cast<int>((lastDataAndCount >> 48) & 0xffff);
int lastLinesUsed = (int)(( lastDataAndCount >> 48 ) & 0xffff);
unsigned char *lastDataPointer = (unsigned char *)(lastDataAndCount & 0x0000ffffffffffff);
// Find out what to prefill the newly allocated line with
const unsigned char planeIndex = lastDataPointer[y];
unsigned char planeIndex = lastDataPointer[y];
if( planeIndex < ALL_0_INDEX ) return; // Something has already allocated this line - we're done
int linesUsed = lastLinesUsed + 1;
// Allocate new memory storage, copy over anything from old storage, and initialise remainder
auto dataPointer = static_cast<unsigned char *>(malloc(linesUsed * 128 + 128));
unsigned char *dataPointer = (unsigned char *)malloc(linesUsed * 128 + 128);
XMemCpy( dataPointer, lastDataPointer, 128 * lastLinesUsed + 128);
XMemSet( dataPointer + ( 128 * lastLinesUsed ) + 128, 0, 128 );
dataPointer[y] = lastLinesUsed;
// Get new data and count packed info
#pragma warning ( disable : 4826 )
int64_t newDataAndCount = reinterpret_cast<int64_t>(dataPointer) & 0x0000ffffffffffffL;
int64_t newDataAndCount = ((int64_t) dataPointer) & 0x0000ffffffffffffL;
#pragma warning ( default : 4826 )
newDataAndCount |= static_cast<int64_t>(linesUsed) << 48;
newDataAndCount |= ((int64_t)linesUsed) << 48;
// Attempt to update the data & count atomically. This command will Only succeed if the data stored at
// dataAndCount is equal to lastDataAndCount, and will return the value present just before the write took place
const int64_t lastDataAndCount2 = InterlockedCompareExchangeRelease64( &dataAndCount, newDataAndCount, lastDataAndCount );
int64_t lastDataAndCount2 = InterlockedCompareExchangeRelease64( &dataAndCount, newDataAndCount, lastDataAndCount );
if( lastDataAndCount2 == lastDataAndCount )
{
@@ -430,7 +430,7 @@ void SparseDataStorage::addNewPlane(int y)
void SparseDataStorage::getPlaneIndicesAndData(unsigned char **planeIndices, unsigned char **data)
{
unsigned char *indicesAndData = reinterpret_cast<unsigned char *>(dataAndCount & 0x0000ffffffffffff);
unsigned char *indicesAndData = (unsigned char *)(dataAndCount & 0x0000ffffffffffff);
*planeIndices = indicesAndData;
*data = indicesAndData + 128;
@@ -448,10 +448,10 @@ void SparseDataStorage::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
const int freeIndex = ( deleteQueueIndex + 1 ) % 3;
int freeIndex = ( deleteQueueIndex + 1 ) % 3;
// printf("Free queue: %d, %d\n",deleteQueue[freeIndex].GetEntryCount(),deleteQueue[freeIndex].GetAllocated());
unsigned char *toFree = nullptr;
unsigned char *toFree = NULL;
do
{
toFree = deleteQueue[freeIndex].Pop();
@@ -480,12 +480,12 @@ void SparseDataStorage::updateDataAndCount(int64_t newDataAndCount)
bool success = false;
do
{
const int64_t lastDataAndCount = dataAndCount;
unsigned char *lastDataPointer = reinterpret_cast<unsigned char *>(lastDataAndCount & 0x0000ffffffffffff);
int64_t lastDataAndCount = dataAndCount;
unsigned char *lastDataPointer = (unsigned char *)(lastDataAndCount & 0x0000ffffffffffff);
// Attempt to update the data & count atomically. This command will Only succeed if the data stored at
// dataAndCount is equal to lastDataAndCount, and will return the value present just before the write took place
const int64_t lastDataAndCount2 = InterlockedCompareExchangeRelease64( &dataAndCount, newDataAndCount, lastDataAndCount );
int64_t lastDataAndCount2 = InterlockedCompareExchangeRelease64( &dataAndCount, newDataAndCount, lastDataAndCount );
if( lastDataAndCount2 == lastDataAndCount )
{
@@ -508,7 +508,7 @@ int SparseDataStorage::compress()
unsigned char _planeIndices[128];
bool needsCompressed = false;
const int64_t lastDataAndCount = dataAndCount;
int64_t lastDataAndCount = dataAndCount;
unsigned char *planeIndices = (unsigned char *)(lastDataAndCount & 0x0000ffffffffffff);
unsigned char *data = planeIndices + 128;
@@ -522,7 +522,7 @@ int SparseDataStorage::compress()
}
else
{
const unsigned char *pucData = &data[ 128 * planeIndices[i] ];
unsigned char *pucData = &data[ 128 * planeIndices[i] ];
bool all0 = true;
for( int j = 0; j < 128; j++ ) // 16 x 16 x 4-bits
{
@@ -543,7 +543,7 @@ int SparseDataStorage::compress()
if( needsCompressed )
{
unsigned char *newIndicesAndData = static_cast<unsigned char *>(malloc(128 + 128 * planesToAlloc));
unsigned char *newIndicesAndData = (unsigned char *)malloc( 128 + 128 * planesToAlloc );
unsigned char *pucData = newIndicesAndData + 128;
XMemCpy( newIndicesAndData, _planeIndices, 128 );
@@ -560,11 +560,11 @@ int SparseDataStorage::compress()
#pragma warning ( disable : 4826 )
int64_t newDataAndCount = ((int64_t) newIndicesAndData) & 0x0000ffffffffffffL;
#pragma warning ( default : 4826 )
newDataAndCount |= static_cast<int64_t>(planesToAlloc) << 48;
newDataAndCount |= ((int64_t)planesToAlloc) << 48;
// Attempt to update the data & count atomically. This command will Only succeed if the data stored at
// dataAndCount is equal to lastDataAndCount, and will return the value present just before the write took place
const int64_t lastDataAndCount2 = InterlockedCompareExchangeRelease64( &dataAndCount, newDataAndCount, lastDataAndCount );
int64_t lastDataAndCount2 = InterlockedCompareExchangeRelease64( &dataAndCount, newDataAndCount, lastDataAndCount );
if( lastDataAndCount2 != lastDataAndCount )
{
@@ -586,7 +586,7 @@ int SparseDataStorage::compress()
}
else
{
return static_cast<int>((lastDataAndCount >> 48) & 0xffff);
return (int)((lastDataAndCount >> 48 ) & 0xffff);
}
}
@@ -594,7 +594,7 @@ int SparseDataStorage::compress()
bool SparseDataStorage::isCompressed()
{
const int count = ( dataAndCount >> 48 ) & 0xffff;
int count = ( dataAndCount >> 48 ) & 0xffff;
return (count < 127);
@@ -602,24 +602,24 @@ bool SparseDataStorage::isCompressed()
void SparseDataStorage::write(DataOutputStream *dos)
{
const int count = ( dataAndCount >> 48 ) & 0xffff;
int count = ( dataAndCount >> 48 ) & 0xffff;
dos->writeInt(count);
unsigned char *dataPointer = (unsigned char *)(dataAndCount & 0x0000ffffffffffff);
const byteArray wrapper(dataPointer, count * 128 + 128);
byteArray wrapper(dataPointer, count * 128 + 128);
dos->write(wrapper);
}
void SparseDataStorage::read(DataInputStream *dis)
{
const int count = dis->readInt();
unsigned char *dataPointer = static_cast<unsigned char *>(malloc(count * 128 + 128));
const byteArray wrapper(dataPointer, count * 128 + 128);
int count = dis->readInt();
unsigned char *dataPointer = (unsigned char *)malloc(count * 128 + 128);
byteArray wrapper(dataPointer, count * 128 + 128);
dis->readFully(wrapper);
#pragma warning ( disable : 4826 )
int64_t newDataAndCount = reinterpret_cast<int64_t>(dataPointer) & 0x0000ffffffffffffL;
int64_t newDataAndCount = ((int64_t) dataPointer) & 0x0000ffffffffffffL;
#pragma warning ( default : 4826 )
newDataAndCount |= static_cast<int64_t>(count) << 48;
newDataAndCount |= ((int64_t)count) << 48;
updateDataAndCount(newDataAndCount);
}