void ApplyModifications()
{
applyingModifications = true;
while (modifications.Count > 0)
{
Queue <VoxelMod> queue = modifications.Dequeue();
while (queue.Count > 0)
{
VoxelMod v = queue.Dequeue();
ChunkCoord c = GetChunkCoordFromVector3(v.position);
if (chunks[c.x, c.z] == null)
{
chunks[c.x, c.z] = new Chunk(c, this);
chunksToCreate.Add(c);
}
chunks[c.x, c.z].modifications.Enqueue(v);
}
}
applyingModifications = false;
}
IEnumerator ApplyModifications()
{
applyingModifications = true;
int count = 0;
while (modifications.Count > 0)
{
VoxelMod v = modifications.Dequeue();
ChunkCoord c = GetChunkCoordFromVector3(v.position);
if (chunks[c.x, c.z] == null)
{
chunks[c.x, c.z] = new Chunk(c, this, true);
activeChunks.Add(c);
}
chunks[c.x, c.z].modifications.Enqueue(v);
if (!chunksToUpdate.Contains(chunks[c.x, c.z]))
{
chunksToUpdate.Add(chunks[c.x, c.z]);
}
count++;
if (count > 200)
{
count = 0;
yield return(null);
}
}
applyingModifications = false;
}
public void UpdateChunk()
{
while (modifications.Count > 0)
{
VoxelMod v = modifications.Dequeue();
blocks[(int)v.position.x, (int)v.position.z, (int)v.position.y] = v.id;
}
ClearMeshData();
for (int z = 0; z < VoxelData.chunkHeight; z++)
{
for (int x = 0; x < VoxelData.chunkSize; x++)
{
for (int y = 0; y < VoxelData.chunkSize; y++)
{
if (world.blockTypes[blocks[x, y, z]].isSolid)
{
AddVoxelDataToChunck(new Vector3(x, z, y));
}
}
}
}
CreateMesh();
}
void ApplyModifications()
{
applyingModifications = true;
while (modifications.Count > 0)
{
Queue <VoxelMod> queue = modifications.Dequeue();
//try
//{
while (queue.Count > 0)
{
VoxelMod v = queue.Dequeue();
worldData.SetVoxel(v.position, v.id);
}
//}
//catch (System.NullReferenceException)
//{
// Debug.Log("Nullreference Exception again...");
//}
}
applyingModifications = false;
}
private void _updateChunk()
{
threadLocked = true;
while (modifications.Count > 0)
{
VoxelMod v = modifications.Dequeue();
Vector3 pos = v.position -= position;
voxelMap[(int)pos.x, (int)pos.y, (int)pos.z] = v.id;
}
ClearMeshData();
for (int y = 0; y < VoxelData.ChunkHeight; y++)
{
for (int x = 0; x < VoxelData.ChunkWidth; x++)
{
for (int z = 0; z < VoxelData.ChunkWidth; z++)
{
if (world.blocktypes[voxelMap[x, y, z]].isSolid)
{
UpdateMeshData(new Vector3(x, y, z));
}
}
}
}
lock (world.chunksToDraw) {
world.chunksToDraw.Enqueue(this);
}
threadLocked = false;
}
public void UpdateChunk()
{
while (modifications.Count > 0)
{
VoxelMod v = modifications.Dequeue();
Vector3 pos = v.position -= position;
voxelMap[(int)pos.x, (int)pos.y, (int)pos.z].id = v.id;
}
ClearMeshData();
CalculateLight();
for (int y = 0; y < VoxelData.ChunkHeight; y++)
{
for (int x = 0; x < VoxelData.ChunkWidth; x++)
{
for (int z = 0; z < VoxelData.ChunkWidth; z++)
{
if (world.blockTypes[voxelMap[x, y, z].id].isSolid)
{
UpdateMeshData(new Vector3(x, y, z));
}
}
}
}
lock (world.chunksToDraw) {
world.chunksToDraw.Enqueue(this);
}
}
public void UpdateChunk()
{
while (modifications.Count > 0)
{
VoxelMod v = modifications.Dequeue();
Vector3 pos = v.position -= position;
voxelMap[(int)pos.x, (int)pos.y, (int)pos.z] = v.id;
}
_isUpdating = true;
ClearMeshData();
for (int y = 0; y < Voxel.ChunkHeight; y++)
{
for (int x = 0; x < Voxel.ChunkWidth; x++)
{
for (int z = 0; z < Voxel.ChunkWidth; z++)
{
// Only render if block is solid
if (world.blocktypes[voxelMap[x, y, z]].isSolid)
{
UpdateMeshData(new Vector3(x, y, z));
}
}
}
}
_isUpdating = false;
world.chunksToDraw.Enqueue(this);
}
IEnumerator UpdateChunk()
{
isUpdatingChunks = true;
while (modifications.Count > 0)
{
VoxelMod v = modifications.Dequeue();
ChunkCoord c = getChunkCoord(v.position);
if (Chunks[c.x, c.z] == null)
{
Chunks[c.x, c.z] = new Chunk(this, c, true);
activeChunks.Add(c);
}
Chunks[c.x, c.z].modifications.Enqueue(v);
if (!ChunksToUpdate.Contains(Chunks[c.x, c.z]))
{
ChunksToUpdate.Add(Chunks[c.x, c.z]);
}
}
for (int i = 0; i < ChunksToUpdate.Count; i++)
{
ChunksToUpdate[0].UpdateChunk();
ChunksToUpdate.RemoveAt(0);
yield return(null);
}
isUpdatingChunks = false;
}
void ApplyModifications()
{
applyingModifications = true;
while (modifications.Count > 0)
{
Queue <VoxelMod> queue = modifications.Dequeue();
while (queue.Count > 0)
{
VoxelMod v = queue.Dequeue();
ChunkCoord c = GetChunkCoordFromVector3(v.position);
ChunkCoord newChunkCoord = new ChunkCoord(c.x, c.z);
if (!chunkMap.ContainsKey(newChunkCoord))
{
chunkMap.TryAdd(newChunkCoord, new Chunk(c, this));
chunksToCreate.Add(c);
}
chunkMap[newChunkCoord].modifications.Enqueue(v);
}
}
applyingModifications = false;
}
public void UpdateChunk()
{
while (modifications.Count > 0)
{
VoxelMod v = modifications.Dequeue();
Vector3 pos = v.position -= position;
voxelMap[(int)pos.x, (int)pos.y, (int)pos.z] = v.id;
}
ClearMeshData();
for (int y = 0; y < VoxelData.ChunkHeight; y++)
{
for (int x = 0; x < VoxelData.ChunkWidth; x++)
{
for (int z = 0; z < VoxelData.ChunkWidth; z++)
{
if (world.blocktypes[voxelMap[x, y, z]].isSolid)
{
UpdateMeshData(new Vector3(x, y, z));
}
}
}
}
CreateMesh();
}
void ApplyModifications()
{
applyingModifications = true;
while (modifications.Count > 0)
{
Queue <VoxelMod> queue = modifications.Dequeue();
while (/* queue.Peek() != null && */ queue.Count > 0)
{
VoxelMod v = queue.Dequeue();
ChunkCoord c = GetChunkCoordFromVector3(v.position);
if (chunks[c.x, c.z] == null)
{
chunks[c.x, c.z] = new Chunk(c, this);
activeChunks.Add(c);
}
chunks[c.x, c.z].modifications.Enqueue(v);
if (!chunksToUpdate.Contains(chunks[c.x, c.z]))
{
chunksToUpdate.Add(chunks[c.x, c.z]);
}
}
}
applyingModifications = false;
}
public void UpdateChunk()
{
while (modifications.Count > 0)
{
VoxelMod v = modifications[0]; //removes from list and take
modifications.RemoveAt(0);
Vector3 pos = v.position -= position;
voxelMap[(int)pos.x, (int)pos.y, (int)pos.z] = v.id;
}
}
void ApplyModifications()
{
applyingModifications = true;
while (modifications.Count > 0)
{
Queue <VoxelMod> queue = modifications.Dequeue();
while (queue.Count > 0)
{
VoxelMod v = queue.Dequeue();
worldData.SetVoxel(v.position, v.id);
}
}
applyingModifications = false;
}
private static void AddVoxelMod(VoxelMod voxelMod, Vector3Int offset)
{
Vector3Int chunkCoord = WorldData.GlobalPosToChunkCoord(voxelMod._pos + offset);
Vector3Int pos = (voxelMod._pos + offset) - WorldData.ChunkCoordToGlobalPos(chunkCoord);
if (_voxelMods.ContainsKey(chunkCoord))
{
_voxelMods[chunkCoord].Add(new VoxelMod(pos, voxelMod._id)); // Override other voxel.
}
else
{
_voxelMods.Add(chunkCoord, new List <VoxelMod>()
{
new VoxelMod(pos, voxelMod._id)
});
}
}
//tree pa
void ApplyModifications()
{
lock (modifications)
{
applyingModifications = true;
int count = 0;
while (modifications.Count > 0 && count < 100)
{
count++;
VoxelMod v = modifications.Dequeue();
worldData.SetVoxel(v.position, v.id);
}
applyingModifications = false;
}
}
void GenerateWorld()
{
for (int x = ((VoxelData.WorldSizeInChunks / 2) - VoxelData.ViewDistanceInChunks); x < ((VoxelData.WorldSizeInChunks / 2) + VoxelData.ViewDistanceInChunks); x++)
{
for (int z = ((VoxelData.WorldSizeInChunks / 2) - VoxelData.ViewDistanceInChunks); z < ((VoxelData.WorldSizeInChunks / 2) + VoxelData.ViewDistanceInChunks); z++)
{
chunks[x, z] = new Chunk(new ChunkCoord(x, z), this, true);
activeChunks.Add(new ChunkCoord(x, z));
}
}
while (modifications.Count > 0)
{
VoxelMod v = modifications.Dequeue();
ChunkCoord c = GetChunkCoordFromVector3(v.position);
if (IsChunkInWorld(c))
{
if (chunks[c.x, c.z] == null)
{
chunks[c.x, c.z] = new Chunk(c, this, true);
activeChunks.Add(c);
}
// adding global modification to each chunk's modifications
chunks[c.x, c.z].modifications.Enqueue(v);
if (!chunksToUpdate.Contains(chunks[c.x, c.z]))
{
chunksToUpdate.Add(chunks[c.x, c.z]);
}
}
}
for (int i = 0; i < chunksToUpdate.Count; i++)
{
chunksToUpdate[0].UpdateChunk();
chunksToUpdate.RemoveAt(0);
}
player.position = spawnPosition;
}
void ApplyModifications()
{
applyingModifications = true;
while (modifications.Count > 0)
{
Queue <VoxelMod> queue = modifications.Dequeue();
try
{
queue = modifications.Dequeue();
if (queue is null)
{
Debug.Log("Queue is null, continue");
continue;
}
}
catch (Exception err)
{
if (err.GetBaseException() is NullReferenceException)
{
Debug.Log("queue is null");
}
continue;
}
while (queue.Count > 0)
{
VoxelMod v = queue.Dequeue();
ChunkCoord c = GetChunkCoordFromVector3(v.position);
if (chunks[c.x, c.z] == null)
{
chunks[c.x, c.z] = new Chunk(c, this);
chunksToCreate.Add(c);
}
chunks[c.x, c.z].modifications.Enqueue(v);
}
}
applyingModifications = false;
}
void GenerateWorld()
{
for (int x = (VoxelData.WorldSizeInChunks / 2) - VoxelData.viewDistanceInChunks; x < (VoxelData.WorldSizeInChunks / 2) + VoxelData.viewDistanceInChunks; x++) // generating the world
{
for (int z = (VoxelData.WorldSizeInChunks / 2) - VoxelData.viewDistanceInChunks; z < (VoxelData.WorldSizeInChunks / 2) + VoxelData.viewDistanceInChunks; z++)
{
chunks[x, z] = new Chunk(new ChunkCoord(x, z), this, true);
//CreateNewChunk(x, z);
activeChunks.Add(new ChunkCoord(x, z));
}
}
while (modifications.Count > 0) // loop til no more mods
{
VoxelMod v = modifications[0]; // global list
modifications.RemoveAt(0);
ChunkCoord c = GetChunkCoordFromVector3(v.position);
if (chunks[c.x, c.z] == null) // if something crosses over chunks we need to add it
{
chunks[c.x, c.z] = new Chunk(c, this, true);
activeChunks.Add(c); // all chunks in game must be here
}
chunks[c.x, c.z].modifications.Insert(0, v);
if (!chunksToUpdate.Contains(chunks[c.x, c.z]))
{
chunksToUpdate.Add(chunks[c.x, c.z]);
}
}
for (int i = 0; i < chunksToUpdate.Count; i++)
{
chunksToUpdate[i].UpdateChunk();
chunksToUpdate.RemoveAt(i);
}
player.position = spawnPosition;
}
