public void ConvertAllToBlockVectors()
{
List <BlockVectorNode> chunksToConvert = new List <BlockVectorNode>();
foreach (KeyValuePair <IntVector4, B45ChunkData> kvp in _chunks)
{
BlockVectorNode bvNode = kvp.Value._bvNode;
if (bvNode == null)
{
Debug.LogError("node null!");
}
chunksToConvert.Add(bvNode);
}
for (int i = 0; i < chunksToConvert.Count; i++)
{
BlockVectorNode bvNode = chunksToConvert[i];
B45ChunkData cd = bvNode.chunk;
// convert the chunk data from byte array mode to block vector mode
//if((cd.d_state & B45ChunkData.DS_BEING_DESTROYED) > 0)
if (cd != null)
{
cd.bp();
bvNode.blockVectors = BlockVectorNode.ChunkData2BlockVectors(cd.DataVT);
}
}
}
Dictionary <IntVector3, byte[]> m_SaveBuffer;// = new Dictionary<IntVector3, byte[]>();
public void AddChunkToSaveList(B45ChunkData vc)
{
if (!chunkSaveList.Contains(vc))
{
chunkSaveList.Add(vc);
}
}
void writeExtendedBlock(int x, int y, int z, int primitiveType, int rotation, int extendDir, int length, byte materialType)
{
B45Block b0, b1;
B45Block.MakeExtendableBlock(primitiveType, rotation, extendDir, length, (int)materialType, out b0, out b1);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(x, y, z)] = b0.blockType;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(x, y, z) + 1] = b0.materialType;
int idx = B45Block.Block45Size * B45ChunkData.OneIndex(
x + Block45Kernel._2BitToExDir[extendDir * 3],
y + Block45Kernel._2BitToExDir[extendDir * 3 + 1],
z + Block45Kernel._2BitToExDir[extendDir * 3 + 2]);
chunkData[idx] = b1.blockType;
chunkData[1 + idx] = b1.materialType;
for (int i = 2; i < length; i++)
{
idx = B45Block.Block45Size * B45ChunkData.OneIndex(
x + Block45Kernel._2BitToExDir[extendDir * 3] * i,
y + Block45Kernel._2BitToExDir[extendDir * 3 + 1] * i,
z + Block45Kernel._2BitToExDir[extendDir * 3 + 2] * i);
chunkData[idx] = (byte)extendDir;
chunkData[1 + idx] = (byte)(length - 2);
}
}
public void CleanupOBChunks()
{
IntVector3 cursorPos = IntVector3.Zero;
IntVector3 viewBound = IntVector3.Zero;
List <IntVector3> vecToDispose = new List <IntVector3>();
foreach (IntVector3 key in _chunks.Keys)
{
if (Mathf.Abs(key.x - cursorPos.x) > viewBound.x ||
Mathf.Abs(key.y - cursorPos.y) > viewBound.y ||
Mathf.Abs(key.z - cursorPos.z) > viewBound.z)
{
vecToDispose.Add(key);
}
}
for (int i = 0; i < vecToDispose.Count; i++)
{
IntVector3 vec = vecToDispose[i];
B45ChunkData cd = _chunks[vec];
if (cd != null)
{
cd.ClearMem();
cd.DestroyChunkGO();
}
}
}
public static void BlockVectors2ChunkData(List <BlockVector> list, B45ChunkData chunkData)
{
for (int i = 0; i < list.Count; i++)
{
BlockVector bv = list[i];
chunkData.WriteVoxelAtIdx(bv.x, bv.y, bv.z, new B45Block(bv.byte0, bv.byte1));
}
}
void test1()
{
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(0, 0, 0)] = B45Block.MakeBlockType(1, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(0, 0, 0) + 1] = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(0, 0, 1)] = B45Block.MakeBlockType(2, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(0, 0, 1) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(0, 0, 2)] = B45Block.MakeBlockType(4, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(0, 0, 2) + 1] = 2;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(0, 0, 3)] = B45Block.MakeBlockType(3, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(0, 0, 3) + 1] = 3;
}
public void writeChunk(int x, int y, int z, B45ChunkData vc, int lod = 0)
{
try
{
IntVector4 index = new IntVector4(x, y, z, lod);
_chunks[index] = vc;
}
catch (Exception)
{
Debug.LogError(string.Format("writeB45Chunk Exception. Max Length:({0}, {1}, {2}}), CurPos({3}, {4}, {5})"));
}
}
public void writeChunk(int x, int y, int z, B45ChunkData vc, int lod = 0)
{
try
{
IntVector3 index = new IntVector3(x % _chunkNumX, y % _chunkNumY, z % _chunkNumZ);
_chunks[index] = vc;
// _chunks[x % _chunkNumX, y % _chunkNumY, z % _chunkNumZ] = vc;
}
catch (Exception)
{
Debug.LogError(string.Format("writeB45Chunk Exception. Max Length:({0}, {1}, {2}}), CurPos({3}, {4}, {5})"));
}
//vc. = new IntVector4(x,y,z,0);
}
B45ChunkData CreateChunk(IntVector4 index)
{
B45ChunkData chunk = new B45ChunkData(colliderMan);
chunk.BuildList = _chunkRebuildList;
writeChunk(index.x, index.y, index.z, chunk);
chunk.ChunkPosLod_w = new IntVector4(
(index.x),
(index.y),
(index.z), 0);
chunk.bp();
chunk.AddToBuildList();
// make the bv node.
if (true)
{
IntVector3 shiftVec = IntVector3.Zero;
shiftVec.x = index.x << Block45Constants._shift;
shiftVec.y = index.y << Block45Constants._shift;
shiftVec.z = index.z << Block45Constants._shift;
try{ // Add try for StackOverflowException
BlockVectorNode newRootNode = bvtRoot.reroot(shiftVec);
bvtRoot = newRootNode;
}
catch (Exception e)
{
Debug.LogWarning("Unexpected exception while creating chunk to" + index + e);
return(chunk);
}
BlockVectorNode bvNode = BlockVectorNode.readNode(shiftVec, bvtRoot);
if (bvNode.chunk != null)
{
// already a chunk has been assigned to this node. something is wrong here.
return(chunk);
}
bvNode.chunk = chunk;
chunk._bvNode = bvNode;
bvNode.isByteArrayMode = true;
}
return(chunk);
}
IEnumerator SetChunksCollider()
{
Dictionary <IntVector4, B45ChunkData> chunks = ((B45OctreeDataSource)_blockDS).ChunksDictionary;
while (true)
{
if (_observer == null)
{
yield return(0);
continue;
}
//int collidersCreated = 0;
foreach (KeyValuePair <IntVector4, B45ChunkData> kvp in chunks)
{
B45ChunkData chunk = kvp.Value;
if (chunk == null || kvp.Key.w != 0)
{
continue;
}
B45ChunkGo goChunk = chunk.ChunkGo;
if (goChunk != null && goChunk._meshCollider.sharedMesh == null)
{
colliderBuilding = true;
SetChunkCollider(goChunk);
chunk.safeToRemoveCollider();
chunk.setNotInQueue();
if (bBuildColliderAsync)
{
goto ColliderSetFin;
}
}
}
colliderBuilding = false;
ColliderSetFin:
yield return(0);
}
}
void Update()
{
if (bStartRead)
{
bStartRead = false;
int index = _data.IsHollow ? 0 : B45ChunkData.OneIndexNoPrefix(xnpre, ynpre, znpre);
int indexVT = index * B45Block.Block45Size;
vol = _data.DataVT[indexVT];
}
if (bApplyWrite)
{
bApplyWrite = false;
int index = _data.IsHollow ? 0 : B45ChunkData.OneIndexNoPrefix(xnpre, ynpre, znpre);
int indexVT = index * B45Block.Block45Size;
_data.WriteVoxelAtIdx(xnpre - VoxelTerrainConstants._numVoxelsPrefix,
ynpre - VoxelTerrainConstants._numVoxelsPrefix,
znpre - VoxelTerrainConstants._numVoxelsPrefix,
new B45Block(vol, _data.DataVT[indexVT + 1]));
}
}
void deferredRemoval()
{
for (int i = deferredRemoveList.Count - 1; i >= 0; i--)
{
B45ChunkData cd = deferredRemoveList[i];
cd.bp();
// if(colliderMan.isColliderBeingRebuilt(cd.ChunkPos.XYZ)){
// Debug.LogError("the replacement collider is not done rebuilding.");
// }
if (cd != null && cd.isInQueue == false && colliderMan.isColliderBeingRebuilt(cd.ChunkPos.XYZ) == false)
{
cd.bp();
if (_chunks.Remove(new IntVector4(cd.ChunkPos.XYZ, 0)) == false)
{
Debug.LogError("a chunk can not be removed from the dictionary");
}
cd.ClearMem();
cd.DestroyChunkGO();
deferredRemoveList.RemoveAt(i);
}
}
}
void test2()
{
UnityEngine.Random.seed = 1223;
for (int z = 0; z < Block45Constants._numVoxelsPerAxis; z++)
{
// for(int y =0; y < Block45Constants._numVoxelsPerAxis;y++)
{
for (int x = 0; x < Block45Constants._numVoxelsPerAxis; x++)
{
int rot = (Mathf.RoundToInt(UnityEngine.Random.value * 256)) % 4;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(x, 0, z)] =
B45Block.MakeBlockType(((x + z * Block45Constants._numVoxelsPerAxis + 0
* Block45Constants._numVoxelsPerAxis * Block45Constants._numVoxelsPerAxis) % 6) + 1, rot);
rot = (Mathf.RoundToInt(UnityEngine.Random.value * 256)) % 4;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(x, 1, z)] =
B45Block.MakeBlockType(((x + z * Block45Constants._numVoxelsPerAxis + 0
* Block45Constants._numVoxelsPerAxis * Block45Constants._numVoxelsPerAxis) % 6) + 1, rot);
}
}
}
}
void addChunksToOcl()
{
_stampsInBuildList.Clear();
_chunksInBuildList.Clear();
for (int curlod = 0; curlod <= LODOctreeMan.MaxLod; curlod++)
{
int nChunkToBuild = _chunkToBuildList.Count;
for (int i = nChunkToBuild - 1; i >= 0; i--)
{
//if(_chunkToBuildList[i].w == curlod)
{
int stamp = _chunkToBuildList.GetKeyByIdx_Unsafe(i);
B45ChunkData chunkData = _chunkToBuildList.GetValueByKey_Unsafe(stamp);
if (!chunkData.IsStampIdentical(stamp))
{
_chunkToBuildList.RemoveAt(i);
Debug.Log("RemoveChunkInSet" + chunkData.ChunkPosLod + ":" + stamp + "|" + chunkData.StampOfChnkUpdating);
continue;
}
if (chunkData.LOD == curlod)
{
_chunkToBuildList.RemoveAt(i);
_stampsInBuildList.Add(stamp);
_chunksInBuildList.Add(chunkData);
b45proc.AddChunkVolumeData(chunkData.DataVT);
if (b45proc.numChunks() >= cpuBlock45.MAX_CHUNKS - 1)
{
return;
}
}
}
}
}
return;
}
public static string OccupiedVecsStr(byte[] byteData)
{
string str = "";
for (int z = 0; z < Block45Constants.VOXEL_ARRAY_AXIS_SIZE; z++)
{
for (int y = 0; y < Block45Constants.VOXEL_ARRAY_AXIS_SIZE; y++)
{
for (int x = 0; x < Block45Constants.VOXEL_ARRAY_AXIS_SIZE; x++)
{
B45Block blk;
blk.blockType = byteData[B45ChunkData.OneIndexNoPrefix(x, y, z) * B45Block.Block45Size];
//blk.materialType = _chunkData[OneIndexNoPrefix(x,y,z) * B45Block.Block45Size + 1];
if (blk.blockType != 0)
{
str += "(" + (x - 1) + "," + (y - 1) + "," + (z - 1) + "); ";
}
}
}
}
return(str);
}
void test3()
{
UnityEngine.Random.seed = 1223;
for (int z = 0; z < Block45Constants._numVoxelsPerAxis; z++)
{
// for(int y =0; y < Block45Constants._numVoxelsPerAxis;y++)
{
for (int x = 0; x < Block45Constants._numVoxelsPerAxis; x++)
{
int rot = (Mathf.RoundToInt(UnityEngine.Random.value * 256)) % 4;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(x, 0, z)] =
B45Block.MakeBlockType(((x + z * Block45Constants._numVoxelsPerAxis + 0
* Block45Constants._numVoxelsPerAxis * Block45Constants._numVoxelsPerAxis) % 6) + 1, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(x, 0, z) + 1] = (byte)(x % 3);
rot = (Mathf.RoundToInt(UnityEngine.Random.value * 256)) % 4;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(x, 1, z)] =
B45Block.MakeBlockType(((x + z * Block45Constants._numVoxelsPerAxis + 0
* Block45Constants._numVoxelsPerAxis * Block45Constants._numVoxelsPerAxis) % 6) + 1, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(x, 1, z) + 1] = (byte)(z % 3);
}
}
}
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,0)] = B45Block.MakeBlockType(1,0);
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,0)+1] = 0;
//
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,1)] = B45Block.MakeBlockType(1,0);
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,1)+1] = 1;
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,2)] = B45Block.MakeBlockType(1,0);
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,2)+1] = 2;
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,3)] = B45Block.MakeBlockType(1,0);
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,3)+1] = 0;
//
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,3)] = B45Block.MakeBlockType(1,0);
// chunkData[B45Block.Block45Size*B45ChunkData.OneIndex(0,0,3)+1] = 3;
}
B45ChunkData CreateChunk(IntVector3 index)
{
//LODOctreeNode tmpNode = new LODOctreeNode(null, 0,
// new IntVector3(
// (index.x<<Block45Constants._shift) / Block45Constants._scaleInverted,
// (index.y<<Block45Constants._shift) / Block45Constants._scaleInverted,
// (index.z<<Block45Constants._shift) / Block45Constants._scaleInverted));
//B45ChunkData chunk = new B45ChunkData(tmpNode, new byte[B45Block.Block45Size]);
B45ChunkData chunk = new B45ChunkData(new byte[B45Block.Block45Size]);
chunk.BuildList = _chunkRebuildList;
writeChunk(index.x, index.y, index.z, chunk);
chunk.ChunkPosLod_w = new IntVector4(
(index.x),
(index.y),
(index.z), 0);
// chunk.ChunkPosLod_w = new IntVector4((x<<Block45Constants._shift) * Block45Constants._scale,
// (y<<Block45Constants._shift) * Block45Constants._scale,
// (z<<Block45Constants._shift) * Block45Constants._scale, 0);
chunk.AddToBuildList();
return(chunk);
}
void ComputeOne(byte[] LODChunkData, List <byte[]> srcChunkData, int cid, IntVector3 destChunkOfs)
{
byte[] eightTypes = new byte[8];
byte[] eightMat = new byte[8];
byte[] eightOccu = new byte[8];
for (int z = 0; z < Block45Constants._numVoxelsPerAxis; z += 2)
{
for (int y = 0; y < Block45Constants._numVoxelsPerAxis; y += 2)
{
for (int x = 0; x < Block45Constants._numVoxelsPerAxis; x += 2)
{
eightTypes[0] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x, y, z)]);
eightTypes[1] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x, y, z + 1)]);
eightTypes[2] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x + 1, y, z + 1)]);
eightTypes[3] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x + 1, y, z)]);
eightTypes[4] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x, y + 1, z)]);
eightTypes[5] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x, y + 1, z + 1)]);
eightTypes[6] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x + 1, y + 1, z + 1)]);
eightTypes[7] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x + 1, y + 1, z)]);
eightMat[0] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x, y, z) + 1]);
eightMat[1] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x, y, z + 1) + 1]);
eightMat[2] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x + 1, y, z + 1) + 1]);
eightMat[3] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x + 1, y, z) + 1]);
eightMat[4] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x, y + 1, z) + 1]);
eightMat[5] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x, y + 1, z + 1) + 1]);
eightMat[6] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x + 1, y + 1, z + 1) + 1]);
eightMat[7] = (byte)(srcChunkData[cid][B45Block.Block45Size * B45ChunkData.OneIndex(x + 1, y + 1, z) + 1]);
eightOccu[0] = TypeToOccupancy[eightTypes[0] >> 2];
eightOccu[1] = TypeToOccupancy[eightTypes[1] >> 2];
eightOccu[2] = TypeToOccupancy[eightTypes[2] >> 2];
eightOccu[3] = TypeToOccupancy[eightTypes[3] >> 2];
eightOccu[4] = TypeToOccupancy[eightTypes[4] >> 2];
eightOccu[5] = TypeToOccupancy[eightTypes[5] >> 2];
eightOccu[6] = TypeToOccupancy[eightTypes[6] >> 2];
eightOccu[7] = TypeToOccupancy[eightTypes[7] >> 2];
int sum = eightOccu[0] + eightOccu[1] + eightOccu[2] + eightOccu[3] +
eightOccu[4] + eightOccu[5] + eightOccu[6] + eightOccu[7];
///if( sum > 0){
/// int sdl= 0;
///}
List <int> indices = GetSimilarIndices(sum, 3);
int smallestError = 255;
int bestMatchI = -1, bestMatchR = -1;
for (int i = 0; i < indices.Count; i++)
{
int errorSum = CalculateError(eightOccu, indices[i], 0);
if (smallestError > errorSum)
{
smallestError = errorSum;
bestMatchI = indices[i];
bestMatchR = 3;
}
errorSum = CalculateError(eightOccu, indices[i], 1);
if (smallestError > errorSum)
{
smallestError = errorSum;
bestMatchI = indices[i];
bestMatchR = 2;
}
errorSum = CalculateError(eightOccu, indices[i], 2);
if (smallestError > errorSum)
{
smallestError = errorSum;
bestMatchI = indices[i];
bestMatchR = 1;
}
errorSum = CalculateError(eightOccu, indices[i], 3);
if (smallestError > errorSum)
{
smallestError = errorSum;
bestMatchI = indices[i];
bestMatchR = 0;
}
}
B45Block blk;
blk.blockType = B45Block.MakeBlockType(bestMatchI, bestMatchR);
blk.materialType = 0;
// determine the material type for this lod block.
byte largestOccu = 0;
for (int i = 0; i < 8; i++)
{
if (eightOccu[i] > largestOccu)
{
largestOccu = eightOccu[i];
blk.materialType = eightMat[i];
}
}
int tmpIdx = B45Block.Block45Size * B45ChunkData.OneIndex(
destChunkOfs.x * Block45Constants._numVoxelsPerAxis / 2 + x / 2,
destChunkOfs.y * Block45Constants._numVoxelsPerAxis / 2 + y / 2,
destChunkOfs.z * Block45Constants._numVoxelsPerAxis / 2 + z / 2
);
LODChunkData[tmpIdx] = blk.blockType;
LODChunkData[tmpIdx + 1] = blk.materialType;
}
}
}
}
public bool IsChunkInBuild(B45ChunkData chunk)
{
return(_chunkToBuildList.ContainsValue(chunk) || _chunksInBuildList.Contains(chunk));
}
void test4()
{
IntVector3 bPos = new IntVector3(0, 0, 0);
int rot = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 0)] = B45Block.MakeBlockType(1, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 0) + 1] = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 1)] = B45Block.MakeBlockType(1, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 1) + 1] = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 1)] = B45Block.MakeBlockType(1, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 1) + 1] = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 0)] = B45Block.MakeBlockType(1, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 0) + 1] = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 0)] = B45Block.MakeBlockType(1, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 0) + 1] = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 1)] = B45Block.MakeBlockType(1, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 1) + 1] = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 1)] = B45Block.MakeBlockType(1, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 1) + 1] = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 0)] = B45Block.MakeBlockType(1, 0);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 0) + 1] = 0;
////
bPos = new IntVector3(2, 0, 0);
rot = 3;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 0)] = B45Block.MakeBlockType(1, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 0) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 1)] = B45Block.MakeBlockType(2, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 1) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 1)] = B45Block.MakeBlockType(2, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 1) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 0)] = B45Block.MakeBlockType(1, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 0) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 0)] = B45Block.MakeBlockType(2, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 0) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 1)] = B45Block.MakeBlockType(0, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 1) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 1)] = B45Block.MakeBlockType(0, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 1) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 0)] = B45Block.MakeBlockType(2, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 0) + 1] = 1;
/////////////////
bPos = new IntVector3(4, 0, 0);
rot = 0;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 0)] = B45Block.MakeBlockType(1, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 0) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 1)] = B45Block.MakeBlockType(1, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 0, bPos.z + 1) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 1)] = B45Block.MakeBlockType(2, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 1) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 0)] = B45Block.MakeBlockType(2, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 0, bPos.z + 0) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 0)] = B45Block.MakeBlockType(2, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 0) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 1)] = B45Block.MakeBlockType(2, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 0, bPos.y + 1, bPos.z + 1) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 1)] = B45Block.MakeBlockType(0, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 1) + 1] = 1;
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 0)] = B45Block.MakeBlockType(0, rot);
chunkData[B45Block.Block45Size * B45ChunkData.OneIndex(bPos.x + 1, bPos.y + 1, bPos.z + 0) + 1] = 1;
}
public void OctreeUpdate(IntVector3 cursorPos)
{
List <BlockVectorNode> blkNodeToConv = new List <BlockVectorNode>();
// check if there are block vector nodes that should be converted into lod chunks.
// BlockVectorNode.rec_findLod(cursorPos, bvtRoot, blkNodeToConv);
// for(int i = 0; i < blkNodeToConv.Count; i++){
// BlockVectorNode bvNode = blkNodeToConv[i];
//
// // shift xyz
// IntVector4 shiftXYZ = IntVector4.Zero;
// shiftXYZ.x = bvNode.Pos.x >> Block45Constants._shift;
// shiftXYZ.y = bvNode.Pos.y >> Block45Constants._shift;
// shiftXYZ.z = bvNode.Pos.z >> Block45Constants._shift;
// shiftXYZ.w = bvNode.Pos.w;
//
//
// if(!_chunks.ContainsKey(shiftXYZ) )
// {
//
// B45ChunkData newChunk = CreateChunk(shiftXYZ);
//
// bvNode.chunk = newChunk;
// newChunk._bvNode = bvNode;
//
// _chunks[shiftXYZ] = newChunk;
// newChunk.bp();
// }
// if(bvNode.blockVectors != null && bvNode.chunk != null){
// bvNode.chunk.bp();
// try
// {
// BlockVectorNode.BlockVectors2ChunkData(bvNode.blockVectors, bvNode.chunk.DataVT);
// }
// catch(Exception ex){
// int sdkf = 0;
// }
// bvNode.blockVectors.Clear();
// bvNode.blockVectors = null;
// }
// }
// check if there are block vector nodes that should be converted into real chunks(byte array mode).
BlockVectorNode.rec_find(cursorPos, bvtRoot, blkNodeToConv);
// for(int i = 0; i < blkNodeToConv.Count; i++){
//// blkNodeToConv[i].makeCube();
// }
//// B45LODNode.makeCubeRec(bvtRoot as B45LODNode);
int elementCount1 = 0;
int fills1 = 0;
int fillsIn_Chunks1 = 0;
if (b45Building.DebugMode)
{
elementCount1 = BlockVectorNode.rec_count(bvtRoot);
fills1 = BlockVectorNode.rec_count_dbg(bvtRoot);
fillsIn_Chunks1 = countpoints();
}
for (int i = 0; i < blkNodeToConv.Count; i++)
{
BlockVectorNode bvNode = blkNodeToConv[i];
// shift xyz
IntVector4 shiftXYZ = IntVector4.Zero;
shiftXYZ.x = bvNode.Pos.x >> Block45Constants._shift;
shiftXYZ.y = bvNode.Pos.y >> Block45Constants._shift;
shiftXYZ.z = bvNode.Pos.z >> Block45Constants._shift;
if (!_chunks.ContainsKey(shiftXYZ))
{
B45ChunkData newChunk = CreateChunk(shiftXYZ);
bvNode.chunk = newChunk;
newChunk._bvNode = bvNode;
_chunks[shiftXYZ] = newChunk;
newChunk.bp();
}
if (bvNode.blockVectors != null && bvNode.chunk != null)
{
bvNode.chunk.bp();
try
{
BlockVectorNode.BlockVectors2ChunkData(bvNode.blockVectors, bvNode.chunk.DataVT);
}
catch {
//int sdkf = 0;
}
bvNode.blockVectors.Clear();
bvNode.blockVectors = null;
}
}
if (b45Building.DebugMode)
{
int elementCount2 = BlockVectorNode.rec_count(bvtRoot);
int fills2 = BlockVectorNode.rec_count_dbg(bvtRoot);
int fillsIn_Chunks2 = countpoints();
Debug.LogError("B45 Octree State: " + elementCount1 + " / " + fills1 + " / " + fillsIn_Chunks1 + " ------------- " + elementCount2 + " / " + fills2 + " / " + fillsIn_Chunks2); // check for chunks that are out of view
}
//List<BlockVectorNode> bvToDispose = new List<BlockVectorNode>();
List <B45ChunkData> cdToDispose = new List <B45ChunkData>();
foreach (KeyValuePair <IntVector4, B45ChunkData> kvp in _chunks)
{
BlockVectorNode bvNode = kvp.Value._bvNode;
B45ChunkData cd = kvp.Value;
if (bvNode == null)
{
Debug.LogError("node null!");
}
if (!bvNode.isCloseTo(cursorPos)
&&
cd != null
)
{
// this node is too far from the camera, put it in the dispose list
cd.bp();
cdToDispose.Add(cd);
// _chunks.Remove(kvp.Key);
}
}
for (int i = 0; i < cdToDispose.Count; i++)
{
B45ChunkData cd = cdToDispose[i];
// convert the chunk data from byte array mode to block vector mode
if (cd != null && cd.isBeingDestroyed == false)
{
cd.setBeingDestroyed();
cd.bp();
cd._bvNode.blockVectors = BlockVectorNode.ChunkData2BlockVectors(cd.DataVT);
cd._bvNode.isByteArrayMode = false;
cd._bvNode.removeCube();
// remove this chunk from memory
cd._bvNode.chunk = null;
deferredRemoveList.Add(cd);
}
else
{
//int sdgf = 0;
}
}
deferredRemoval();
}
