mirror of https://github.com/buggins/dlangui.git
dminer - chunk
This commit is contained in:
Vadim Lopatin
parent
e31fd88107
commit
23fc79142f
|
|
@ -0,0 +1,451 @@
|
||||||
|
module dminer.core.chunk;
|
||||||
|
|
||||||
|
import dminer.core.minetypes;
|
||||||
|
import dminer.core.blocks;
|
||||||
|
|
||||||
|
enum USE_NEW_WORLD_IMPL = true;
|
||||||
|
|
||||||
|
|
||||||
|
// Y range: 0..CHUNK_DY-1
|
||||||
|
immutable int CHUNK_DY_SHIFT = 7;
|
||||||
|
immutable int CHUNK_DY = (1<<CHUNK_DY_SHIFT);
|
||||||
|
immutable int CHUNK_DY_MASK = (CHUNK_DY - 1);
|
||||||
|
immutable int CHUNK_DY_INV_MASK = ~CHUNK_DY_MASK;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
immutable int CHUNKS_Y = 128 / 8;
|
||||||
|
immutable int CHUNKS_BITS_X = 9;
|
||||||
|
immutable int CHUNKS_BITS_Z = 9;
|
||||||
|
immutable int CHUNKS_X = (1 << CHUNKS_BITS_X); // X range: -CHUNKS_X*8 .. CHUNKS_X*8
|
||||||
|
immutable int CHUNKS_Z = (1 << CHUNKS_BITS_Z); // Z range: -CHUNKS_Z*8 .. CHUNKS_Z*8
|
||||||
|
immutable int CHUNKS_X_MASK = (CHUNKS_X << 1) - 1;
|
||||||
|
immutable int CHUNKS_Z_MASK = (CHUNKS_Z << 1) - 1;
|
||||||
|
|
||||||
|
// vertical stack of chunks with same X, Z, and different Y
|
||||||
|
struct ChunkStack {
|
||||||
|
protected int _minChunkY;
|
||||||
|
protected int _chunkCount;
|
||||||
|
SmallChunk ** _chunks;
|
||||||
|
/// get chunk from stack by chunk Y index
|
||||||
|
SmallChunk * get(int chunkY) {
|
||||||
|
int idx = chunkY - _minChunkY;
|
||||||
|
if (idx < 0 || idx >= _chunkCount)
|
||||||
|
return null;
|
||||||
|
return _chunks[idx];
|
||||||
|
}
|
||||||
|
@property int topNonEmptyY() {
|
||||||
|
return ((_minChunkY + _chunkCount) << 3) - 1;
|
||||||
|
}
|
||||||
|
void set(int chunkY, SmallChunk * item) {
|
||||||
|
int idx = chunkY - _minChunkY;
|
||||||
|
if (idx >= 0 && idx < _chunkCount) {
|
||||||
|
if (_chunks[idx]) {
|
||||||
|
if (_chunks[idx] is item)
|
||||||
|
return;
|
||||||
|
SmallChunk.free(_chunks[idx]);
|
||||||
|
}
|
||||||
|
_chunks[idx] = item;
|
||||||
|
return;
|
||||||
|
} else if (!_chunkCount) {
|
||||||
|
// need to reallocate
|
||||||
|
// initial allocation
|
||||||
|
_minChunkY = chunkY;
|
||||||
|
_chunkCount = 1;
|
||||||
|
_chunks = allocChunks(1);
|
||||||
|
_chunks[0] = item;
|
||||||
|
} else {
|
||||||
|
// need to reallocate
|
||||||
|
// realloc
|
||||||
|
int newMinY;
|
||||||
|
int newChunkCount;
|
||||||
|
if (chunkY < _minChunkY) {
|
||||||
|
newMinY = chunkY;
|
||||||
|
newChunkCount = _minChunkY + _chunkCount - newMinY;
|
||||||
|
} else {
|
||||||
|
newMinY = _minChunkY;
|
||||||
|
newChunkCount = chunkY - _minChunkY + 1;
|
||||||
|
}
|
||||||
|
SmallChunk ** newChunks = allocChunks(newChunkCount);
|
||||||
|
// copy old data
|
||||||
|
for(int i = 0; i < _chunkCount; i++)
|
||||||
|
newChunks[i + _minChunkY - newMinY] = _chunks[i];
|
||||||
|
newChunks[chunkY - newMinY] = item;
|
||||||
|
freeChunks(_chunks);
|
||||||
|
_chunkCount = newChunkCount;
|
||||||
|
_minChunkY = newMinY;
|
||||||
|
_chunks = newChunks;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
private SmallChunk ** allocChunks(int len) {
|
||||||
|
if (len <= 0)
|
||||||
|
return null;
|
||||||
|
import core.stdc.stdlib : malloc;
|
||||||
|
SmallChunk ** res = cast(SmallChunk **) malloc(len * (SmallChunk *).sizeof);
|
||||||
|
for(int i = 0; i < len; i++)
|
||||||
|
res[i] = null;
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
private void freeChunks(ref SmallChunk ** chunks) {
|
||||||
|
if (chunks) {
|
||||||
|
import core.stdc.stdlib : free;
|
||||||
|
free(chunks);
|
||||||
|
chunks = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
void clear() {
|
||||||
|
if (_chunkCount) {
|
||||||
|
for(int i = 0; i < _chunkCount; i++) {
|
||||||
|
SmallChunk.free(_chunks[i]);
|
||||||
|
}
|
||||||
|
freeChunks(_chunks);
|
||||||
|
}
|
||||||
|
_chunks = null;
|
||||||
|
_chunkCount = 0;
|
||||||
|
_minChunkY = -1;
|
||||||
|
}
|
||||||
|
~this() {
|
||||||
|
clear();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// 8x8x8 chunk
|
||||||
|
struct SmallChunk {
|
||||||
|
cell_t[8*8*8] cells; // 512 bytes
|
||||||
|
ubyte[8*8*8] sunlight; // 512 bytes
|
||||||
|
ulong[8] opaquePlanesX; // 64 bytes
|
||||||
|
ulong[8] opaquePlanesY; // 64 bytes
|
||||||
|
ulong[8] opaquePlanesZ; // 64 bytes
|
||||||
|
ulong[8] canPassPlanesX; // 64 bytes
|
||||||
|
ulong[8] canPassPlanesY; // 64 bytes
|
||||||
|
ulong[8] canPassPlanesZ; // 64 bytes
|
||||||
|
ulong[6][6] canPassFromTo; // 288 bytes
|
||||||
|
SmallChunk * [6] nearChunks;
|
||||||
|
bool dirty;
|
||||||
|
|
||||||
|
static SmallChunk * alloc() nothrow @nogc {
|
||||||
|
import core.stdc.stdlib : malloc;
|
||||||
|
SmallChunk * res = cast(SmallChunk *)malloc(SmallChunk.sizeof);
|
||||||
|
*res = SmallChunk.init;
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void free(SmallChunk * obj) {
|
||||||
|
if (!obj)
|
||||||
|
return;
|
||||||
|
import core.stdc.stdlib : free;
|
||||||
|
free(obj);
|
||||||
|
}
|
||||||
|
|
||||||
|
cell_t getCell(int x, int y, int z) const {
|
||||||
|
return cells[((((y&7) << 3) | (z&7)) << 3) | (x&7)];
|
||||||
|
}
|
||||||
|
void setCell(int x, int y, int z, cell_t value) {
|
||||||
|
dirty = true;
|
||||||
|
cells[((((y&7) << 3) | (z&7)) << 3) | (x&7)] = value;
|
||||||
|
}
|
||||||
|
cell_t getCellNoCheck(int x, int y, int z) const {
|
||||||
|
return cells[(((y << 3) | z) << 3) | x];
|
||||||
|
}
|
||||||
|
void generateMasks() {
|
||||||
|
// x planes: z,y
|
||||||
|
for(int x = 0; x < 8; x++) {
|
||||||
|
ulong opaqueFlags = 0;
|
||||||
|
ulong canPassFlags = 0;
|
||||||
|
ulong mask = 1;
|
||||||
|
for (int y = 0; y < 8; y++) {
|
||||||
|
for (int z = 0; z < 8; z++) {
|
||||||
|
cell_t cell = cells[(((y << 3) | z) << 3) | x];
|
||||||
|
if (BLOCK_TYPE_OPAQUE.ptr[cell])
|
||||||
|
opaqueFlags |= mask;
|
||||||
|
if (BLOCK_TYPE_CAN_PASS.ptr[cell])
|
||||||
|
canPassFlags |= mask;
|
||||||
|
mask = mask << 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
opaquePlanesX[x] = opaqueFlags;
|
||||||
|
canPassPlanesX[x] = canPassFlags;
|
||||||
|
}
|
||||||
|
// y planes : x,z
|
||||||
|
for(int y = 0; y < 8; y++) {
|
||||||
|
ulong opaqueFlags = 0;
|
||||||
|
ulong canPassFlags = 0;
|
||||||
|
ulong mask = 1;
|
||||||
|
for (int z = 0; z < 8; z++) {
|
||||||
|
for (int x = 0; x < 8; x++) {
|
||||||
|
cell_t cell = cells[(((y << 3) | z) << 3) | x];
|
||||||
|
if (BLOCK_TYPE_OPAQUE.ptr[cell])
|
||||||
|
opaqueFlags |= mask;
|
||||||
|
if (BLOCK_TYPE_CAN_PASS.ptr[cell])
|
||||||
|
canPassFlags |= mask;
|
||||||
|
mask = mask << 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
opaquePlanesY[y] = opaqueFlags;
|
||||||
|
canPassPlanesY[y] = canPassFlags;
|
||||||
|
}
|
||||||
|
// z planes: x,y
|
||||||
|
for(int z = 0; z < 8; z++) {
|
||||||
|
ulong opaqueFlags = 0;
|
||||||
|
ulong canPassFlags = 0;
|
||||||
|
ulong mask = 1;
|
||||||
|
for (int y = 0; y < 8; y++) {
|
||||||
|
for (int x = 0; x < 8; x++) {
|
||||||
|
cell_t cell = cells[(((y << 3) | z) << 3) | x];
|
||||||
|
if (BLOCK_TYPE_OPAQUE.ptr[cell])
|
||||||
|
opaqueFlags |= mask;
|
||||||
|
if (BLOCK_TYPE_CAN_PASS.ptr[cell])
|
||||||
|
canPassFlags |= mask;
|
||||||
|
mask = mask << 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
opaquePlanesZ[z] = opaqueFlags;
|
||||||
|
canPassPlanesZ[z] = canPassFlags;
|
||||||
|
}
|
||||||
|
// can pass from to
|
||||||
|
for (Dir from = Dir.min; from <= Dir.max; ++from) {
|
||||||
|
for (Dir to = Dir.min; to <= Dir.max; ++to) {
|
||||||
|
}
|
||||||
|
}
|
||||||
|
dirty = false;
|
||||||
|
}
|
||||||
|
static void spreadFlags(ulong src, ref ulong[8] planes, ref ulong[8] dst, int start, int end, ubyte spreadMask) {
|
||||||
|
if (start < end) {
|
||||||
|
for (int i = start; i <= end; ++i) {
|
||||||
|
ulong mask = src;
|
||||||
|
if (spreadMask & SpreadMask.SpreadLeft)
|
||||||
|
mask |= ((src << 1) & 0xFEFEFEFEFEFEFEFE);
|
||||||
|
if (spreadMask & SpreadMask.SpreadRight)
|
||||||
|
mask |= ((src >> 1) & 0x7F7F7F7F7F7F7F7F);
|
||||||
|
if (spreadMask & SpreadMask.SpreadUp)
|
||||||
|
mask |= ((src << 8) & 0xFFFFFFFFFFFFFF00);
|
||||||
|
if (spreadMask & SpreadMask.SpreadDown)
|
||||||
|
mask |= ((src >> 8) & 0x00FFFFFFFFFFFFFF);
|
||||||
|
src = planes[i] & mask;
|
||||||
|
dst[i] = src;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
for (int i = end; i >= start; --i) {
|
||||||
|
ulong mask = src;
|
||||||
|
if (spreadMask & SpreadMask.SpreadLeft)
|
||||||
|
mask |= ((src << 1) & 0xFEFEFEFEFEFEFEFE);
|
||||||
|
if (spreadMask & SpreadMask.SpreadRight)
|
||||||
|
mask |= ((src >> 1) & 0x7F7F7F7F7F7F7F7F);
|
||||||
|
if (spreadMask & SpreadMask.SpreadUp)
|
||||||
|
mask |= ((src << 8) & 0xFFFFFFFFFFFFFF00);
|
||||||
|
if (spreadMask & SpreadMask.SpreadDown)
|
||||||
|
mask |= ((src >> 8) & 0x00FFFFFFFFFFFFFF);
|
||||||
|
src = planes[i] & mask;
|
||||||
|
dst[i] = src;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ulong canPass(ulong mask, Dir dir, Dir to, ubyte dirMask = DirMask.MASK_ALL) {
|
||||||
|
ulong[8] planes;
|
||||||
|
ubyte spreadMask = DIR_AND_MASK_TO_SPREAD_FLAGS[dirMask][dir];
|
||||||
|
final switch(dir) with (Dir) {
|
||||||
|
case NORTH:
|
||||||
|
spreadFlags(mask, canPassPlanesZ, planes, 0, 7, spreadMask);
|
||||||
|
final switch (to) {
|
||||||
|
case NORTH:
|
||||||
|
return planes[7];
|
||||||
|
case SOUTH:
|
||||||
|
return planes[0];
|
||||||
|
case EAST:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case WEST:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
case UP:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case DOWN:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
}
|
||||||
|
case SOUTH:
|
||||||
|
spreadFlags(mask, canPassPlanesZ, planes, 7, 0, spreadMask);
|
||||||
|
final switch (to) {
|
||||||
|
case NORTH:
|
||||||
|
return planes[7];
|
||||||
|
case SOUTH:
|
||||||
|
return planes[0];
|
||||||
|
case EAST:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case WEST:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
case UP:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case DOWN:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
}
|
||||||
|
case WEST:
|
||||||
|
spreadFlags(mask, canPassPlanesX, planes, 7, 0, spreadMask);
|
||||||
|
final switch (to) {
|
||||||
|
case NORTH:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case SOUTH:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
case EAST:
|
||||||
|
return planes[7];
|
||||||
|
case WEST:
|
||||||
|
return planes[0];
|
||||||
|
case UP:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case DOWN:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
}
|
||||||
|
case EAST:
|
||||||
|
spreadFlags(mask, canPassPlanesX, planes, 0, 7, spreadMask);
|
||||||
|
final switch (to) {
|
||||||
|
case NORTH:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case SOUTH:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
case EAST:
|
||||||
|
return planes[7];
|
||||||
|
case WEST:
|
||||||
|
return planes[0];
|
||||||
|
case UP:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case DOWN:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
}
|
||||||
|
case UP:
|
||||||
|
spreadFlags(mask, canPassPlanesY, planes, 0, 7, spreadMask);
|
||||||
|
final switch (to) {
|
||||||
|
case NORTH:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case SOUTH:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
case EAST:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case WEST:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
case UP:
|
||||||
|
return planes[7];
|
||||||
|
case DOWN:
|
||||||
|
return planes[0];
|
||||||
|
}
|
||||||
|
case DOWN:
|
||||||
|
spreadFlags(mask, canPassPlanesY, planes, 7, 0, spreadMask);
|
||||||
|
final switch (to) {
|
||||||
|
case NORTH:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case SOUTH:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
case EAST:
|
||||||
|
return slicePlane7(planes);
|
||||||
|
case WEST:
|
||||||
|
return slicePlane0(planes);
|
||||||
|
case UP:
|
||||||
|
return planes[7];
|
||||||
|
case DOWN:
|
||||||
|
return planes[0];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static ulong slicePlane0(ref ulong[8] planes) {
|
||||||
|
ulong res = 0;
|
||||||
|
for (int i = 0; i < 8; i++) {
|
||||||
|
res |= (planes[i] & 0x0101010101010101) << i;
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
static ulong slicePlane7(ref ulong[8] planes) {
|
||||||
|
ulong res = 0;
|
||||||
|
for (int i = 0; i < 8; i++) {
|
||||||
|
res |= (planes[i] & 0x8080808080808080) >> (7 - i);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
enum SpreadMask : ubyte {
|
||||||
|
SpreadLeft = 1,
|
||||||
|
SpreadRight = 2,
|
||||||
|
SpreadUp = 4,
|
||||||
|
SpreadDown = 8,
|
||||||
|
}
|
||||||
|
|
||||||
|
ubyte dirMaskToSpreadMask(Dir dir, ubyte dirMask) {
|
||||||
|
ubyte res = 0;
|
||||||
|
final switch (dir) with (Dir) {
|
||||||
|
case NORTH: // from north
|
||||||
|
case SOUTH:
|
||||||
|
res |= (dirMask & DirMask.MASK_UP) ? SpreadMask.SpreadUp : 0;
|
||||||
|
res |= (dirMask & DirMask.MASK_DOWN) ? SpreadMask.SpreadDown : 0;
|
||||||
|
res |= (dirMask & DirMask.MASK_EAST) ? SpreadMask.SpreadLeft : 0;
|
||||||
|
res |= (dirMask & DirMask.MASK_WEST) ? SpreadMask.SpreadRight : 0;
|
||||||
|
break;
|
||||||
|
case WEST:
|
||||||
|
case EAST:
|
||||||
|
res |= (dirMask & DirMask.MASK_UP) ? SpreadMask.SpreadUp : 0;
|
||||||
|
res |= (dirMask & DirMask.MASK_DOWN) ? SpreadMask.SpreadDown : 0;
|
||||||
|
res |= (dirMask & DirMask.MASK_NORTH) ? SpreadMask.SpreadLeft : 0;
|
||||||
|
res |= (dirMask & DirMask.MASK_SOUTH) ? SpreadMask.SpreadRight : 0;
|
||||||
|
break;
|
||||||
|
case UP:
|
||||||
|
case DOWN:
|
||||||
|
res |= (dirMask & DirMask.MASK_EAST) ? SpreadMask.SpreadLeft : 0;
|
||||||
|
res |= (dirMask & DirMask.MASK_WEST) ? SpreadMask.SpreadRight : 0;
|
||||||
|
res |= (dirMask & DirMask.MASK_NORTH) ? SpreadMask.SpreadUp : 0;
|
||||||
|
res |= (dirMask & DirMask.MASK_SOUTH) ? SpreadMask.SpreadDown : 0;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
// immutable SpreadMask[DirMask][Dir] DIR_AND_MASK_TO_SPREAD_FLAGS
|
||||||
|
mixin(generateDirMaskSource());
|
||||||
|
|
||||||
|
string generateDirMaskSource() {
|
||||||
|
import std.conv : to;
|
||||||
|
char[] src;
|
||||||
|
src ~= "immutable ubyte[64][6] DIR_AND_MASK_TO_SPREAD_FLAGS = [\n";
|
||||||
|
for (Dir from = Dir.min; from <= Dir.max; from++) {
|
||||||
|
if (from)
|
||||||
|
src ~= ",\n";
|
||||||
|
src ~= " // ";
|
||||||
|
src ~= to!string(from);
|
||||||
|
src ~= "\n [";
|
||||||
|
for (ubyte mask = 0; mask < 64; mask++) {
|
||||||
|
ubyte res = dirMaskToSpreadMask(from, mask);
|
||||||
|
if (mask)
|
||||||
|
src ~= ", ";
|
||||||
|
if (mask == 32)
|
||||||
|
src ~= "\n ";
|
||||||
|
src ~= to!string(res);
|
||||||
|
}
|
||||||
|
src ~= "]";
|
||||||
|
}
|
||||||
|
src ~= "\n];\n";
|
||||||
|
return src.dup;
|
||||||
|
}
|
||||||
|
|
||||||
|
void testDirMaskToSpreadMask() {
|
||||||
|
import dlangui.core.logger;
|
||||||
|
for (Dir from = Dir.min; from <= Dir.max; from++) {
|
||||||
|
for (ubyte mask = 0; mask < 64; mask++) {
|
||||||
|
ubyte res = dirMaskToSpreadMask(from, mask);
|
||||||
|
char[]buf;
|
||||||
|
buf ~= "[";
|
||||||
|
if (mask & DirMask.MASK_NORTH) buf ~= " NORTH";
|
||||||
|
if (mask & DirMask.MASK_SOUTH) buf ~= " SOUTH";
|
||||||
|
if (mask & DirMask.MASK_WEST) buf ~= " WEST";
|
||||||
|
if (mask & DirMask.MASK_EAST) buf ~= " EAST";
|
||||||
|
if (mask & DirMask.MASK_UP) buf ~= " UP";
|
||||||
|
if (mask & DirMask.MASK_DOWN) buf ~= " DOWN";
|
||||||
|
buf ~= " ] => (";
|
||||||
|
if (res & SpreadMask.SpreadLeft) buf ~= " SpreadLeft";
|
||||||
|
if (res & SpreadMask.SpreadRight) buf ~= " SpreadRight";
|
||||||
|
if (res & SpreadMask.SpreadUp) buf ~= " SpreadUp";
|
||||||
|
if (res & SpreadMask.SpreadDown) buf ~= " SpreadDown";
|
||||||
|
buf ~= " )";
|
||||||
|
Log.d("dirMaskToSpreadMask ", from, " ", buf);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Log.d("Source: \n", generateDirMaskSource());
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue