/*
* public void GenerateOres(VoxelChunk chunk, ComponentManager components, ContentManager content,
* GraphicsDevice graphics)
* {
* Vector3 origin = chunk.Origin;
* int chunkSizeX = chunk.SizeX;
* int chunkSizeY = chunk.SizeY;
* int chunkSizeZ = chunk.SizeZ;
* Voxel v = chunk.MakeVoxel(0, 0, 0);
* for (int x = 0; x < chunkSizeX; x++)
* {
* for (int z = 0; z < chunkSizeZ; z++)
* {
* int h = chunk.GetFilledVoxelGridHeightAt(x, chunkSizeY - 1, z);
* for (int y = 1; y < chunkSizeY; y++)
* {
* foreach (
* KeyValuePair<string, VoxelLibrary.ResourceSpawnRate> spawns in VoxelLibrary.ResourceSpawns)
* {
* float s = spawns.Value.VeinSize;
* float p = spawns.Value.VeinSpawnThreshold;
* v.GridPosition = new Vector3(x, y, z);
* if (v.IsEmpty || y >= h - 1 || !(y - h/2 < spawns.Value.MaximumHeight) ||
* !(y - h/2 > spawns.Value.MinimumHeight) ||
* !(PlayState.Random.NextDouble() <= spawns.Value.Probability) || v.Type.Name != "Stone")
* {
* continue;
* }
*
* float caviness = (float) NoiseGenerator.Noise((float) (x + origin.X)*s,
* (float) (z + origin.Z)*s,
* (float) (y + origin.Y + h)*s);
*
* if (caviness > p)
* {
* v.Type = VoxelLibrary.GetVoxelType(spawns.Key);
* }
* continue;
* }
* }
* }
* }
* }
*/
public void GenerateFauna(VoxelChunk chunk, ComponentManager components, ContentManager content, GraphicsDevice graphics, FactionLibrary factions)
{
int waterHeight = (int)(SeaLevel * chunk.SizeY);
Voxel v = chunk.MakeVoxel(0, 0, 0);
for (int x = 0; x < chunk.SizeX; x++)
{
for (int z = 0; z < chunk.SizeZ; z++)
{
Vector2 vec = new Vector2(x + chunk.Origin.X, z + chunk.Origin.Z) / PlayState.WorldScale;
Overworld.Biome biome = Overworld.Map[(int)MathFunctions.Clamp(vec.X, 0, Overworld.Map.GetLength(0) - 1), (int)MathFunctions.Clamp(vec.Y, 0, Overworld.Map.GetLength(1) - 1)].Biome;
BiomeData biomeData = BiomeLibrary.Biomes[biome];
int y = chunk.GetFilledVoxelGridHeightAt(x, chunk.SizeY - 1, z);
if (!chunk.IsCellValid(x, (int)(y - chunk.Origin.Y), z))
{
continue;
}
v.GridPosition = new Vector3(x, y, z);
if (chunk.Data.Water[v.Index].WaterLevel != 0 || y <= waterHeight)
{
continue;
}
foreach (FaunaData animal in biomeData.Fauna)
{
if (y <= 0 || !(PlayState.Random.NextDouble() < animal.SpawnProbability))
{
continue;
}
EntityFactory.CreateEntity <Body>(animal.Name, chunk.Origin + new Vector3(x, y, z) + Vector3.Up * 1.0f);
break;
}
}
}
}
public static void UpdateRamps(VoxelChunk chunk)
{
Dictionary <BoxFace, bool> faceExists = new Dictionary <BoxFace, bool>();
Dictionary <BoxFace, bool> faceVisible = new Dictionary <BoxFace, bool>();
Voxel v = chunk.MakeVoxel(0, 0, 0);
Voxel vAbove = chunk.MakeVoxel(0, 0, 0);
Voxel voxelOnFace = chunk.MakeVoxel(0, 0, 0);
Voxel worldVoxel = new Voxel();
for (int x = 0; x < chunk.SizeX; x++)
{
for (int y = 0; y < Math.Min(chunk.Manager.ChunkData.MaxViewingLevel + 1, chunk.SizeY); y++)
{
for (int z = 0; z < chunk.SizeZ; z++)
{
v.GridPosition = new Vector3(x, y, z);
bool isTop = false;
if (y < chunk.SizeY - 1)
{
vAbove.GridPosition = new Vector3(x, y + 1, z);
isTop = vAbove.IsEmpty;
}
if (isTop && !v.IsEmpty && v.IsVisible && v.Type.CanRamp)
{
for (int i = 0; i < 6; i++)
{
BoxFace face = (BoxFace)i;
if (!IsSideFace(face))
{
continue;
}
Vector3 delta = FaceDeltas[face];
faceExists[face] = chunk.IsCellValid(x + (int)delta.X, y + (int)delta.Y, z + (int)delta.Z);
faceVisible[face] = true;
if (faceExists[face])
{
voxelOnFace.GridPosition = new Vector3(x + (int)delta.X, y + (int)delta.Y,
z + (int)delta.Z);
if (voxelOnFace.IsEmpty || !voxelOnFace.IsVisible)
{
faceVisible[face] = true;
}
else
{
faceVisible[face] = false;
}
}
else
{
if (!chunk.Manager.ChunkData.GetNonNullVoxelAtWorldLocation(new Vector3(x + (int)delta.X + 0.5f, y + (int)delta.Y + 0.5f, z + (int)delta.Z + 0.5f) + chunk.Origin, ref worldVoxel) || !worldVoxel.IsVisible)
{
faceVisible[face] = true;
}
else
{
faceVisible[face] = false;
}
}
if (faceVisible[face])
{
v.RampType = v.RampType | UpdateRampType(face);
}
}
if (RampIsDegenerate(v.RampType))
{
v.RampType = RampType.None;
}
}
else if (!v.IsEmpty && v.IsVisible && v.Type.CanRamp)
{
v.RampType = RampType.None;
}
}
}
}
}
public void InitializeFromChunk(VoxelChunk chunk, GraphicsDevice graphics)
{
if (chunk == null)
{
return;
}
rebuildMutex.WaitOne();
if(isRebuilding)
{
rebuildMutex.ReleaseMutex();
return;
}
isRebuilding = true;
rebuildMutex.ReleaseMutex();
accumulatedVertices.Clear();
accumulatedIndices.Clear();
faceExists.Clear();
drawFace.Clear();
Voxel v = chunk.MakeVoxel(0, 0, 0);
Voxel voxelOnFace = chunk.MakeVoxel(0, 0, 0);
Voxel[] manhattanNeighbors = new Voxel[4];
for(int x = 0; x < chunk.SizeX; x++)
{
for(int y = 0; y < Math.Min(chunk.Manager.ChunkData.MaxViewingLevel + 1, chunk.SizeY); y++)
{
for(int z = 0; z < chunk.SizeZ; z++)
{
v.GridPosition = new Vector3(x, y, z);
if((v.IsExplored && v.IsEmpty) || !v.IsVisible)
{
continue;
}
BoxPrimitive primitive = VoxelLibrary.GetPrimitive(v.Type);
if (v.IsExplored && primitive == null) continue;
else if (!v.IsExplored)
{
primitive = VoxelLibrary.GetPrimitive("Bedrock");
}
BoxPrimitive.BoxTextureCoords uvs = primitive.UVs;
if (v.Type.HasTransitionTextures)
{
uvs = v.ComputeTransitionTexture(manhattanNeighbors);
}
Voxel worldVoxel = new Voxel();
for(int i = 0; i < 6; i++)
{
BoxFace face = (BoxFace) i;
Vector3 delta = FaceDeltas[face];
faceExists[face] = chunk.IsCellValid(x + (int) delta.X, y + (int) delta.Y, z + (int) delta.Z);
drawFace[face] = true;
if(faceExists[face])
{
voxelOnFace.GridPosition = new Vector3(x + (int) delta.X, y + (int) delta.Y, z + (int) delta.Z);
drawFace[face] = voxelOnFace.IsEmpty || !voxelOnFace.IsVisible || (voxelOnFace.Type.CanRamp && voxelOnFace.RampType != RampType.None && IsSideFace(face) && ShouldDrawFace(face, voxelOnFace.RampType, v.RampType));
}
else
{
bool success = chunk.Manager.ChunkData.GetNonNullVoxelAtWorldLocation(new Vector3(x + (int) delta.X, y + (int) delta.Y, z + (int) delta.Z) + chunk.Origin, ref worldVoxel);
drawFace[face] = !success || worldVoxel.IsEmpty || !worldVoxel.IsVisible ||
(worldVoxel.Type.CanRamp && worldVoxel.RampType != RampType.None &&
IsSideFace(face) &&
ShouldDrawFace(face, worldVoxel.RampType, v.RampType));
}
}
for(int i = 0; i < 6; i++)
{
BoxFace face = (BoxFace) i;
if(!drawFace[face])
{
continue;
}
int faceIndex = 0;
int faceCount = 0;
int vertexIndex = 0;
int vertexCount = 0;
primitive.GetFace(face, uvs, out faceIndex, out faceCount, out vertexIndex, out vertexCount);
Vector2 texScale = uvs.Scales[i];
int indexOffset = accumulatedVertices.Count;
for (int vertOffset = 0; vertOffset < vertexCount; vertOffset++)
{
ExtendedVertex vert = primitive.Vertices[vertOffset + vertexIndex];
VoxelVertex bestKey = VoxelChunk.GetNearestDelta(vert.Position);
Color color = v.Chunk.Data.GetColor(x, y, z, bestKey);
Vector3 offset = Vector3.Zero;
Vector2 texOffset = Vector2.Zero;
if(v.Type.CanRamp && ShouldRamp(bestKey, v.RampType))
{
offset = new Vector3(0, -v.Type.RampSize, 0);
if(face != BoxFace.Top && face != BoxFace.Bottom)
{
texOffset = new Vector2(0, v.Type.RampSize * (texScale.Y));
}
}
ExtendedVertex newVertex = new ExtendedVertex((vert.Position + v.Position + VertexNoise.GetNoiseVectorFromRepeatingTexture(vert.Position + v.Position) + offset),
color,
uvs.Uvs[vertOffset + vertexIndex] + texOffset, uvs.Bounds[faceIndex / 6]);
accumulatedVertices.Add(newVertex);
}
for (int idx = faceIndex; idx < faceCount + faceIndex; idx++)
{
int vertexOffset = primitive.Indices[idx];
accumulatedIndices.Add((short)(indexOffset + (vertexOffset - primitive.Indices[faceIndex])));
}
}
}
}
}
Vertices = new ExtendedVertex[accumulatedVertices.Count];
accumulatedVertices.CopyTo(Vertices);
IndexBuffer = new IndexBuffer(graphics, typeof(short), accumulatedIndices.Count, BufferUsage.WriteOnly);
IndexBuffer.SetData(accumulatedIndices.ToArray());
ResetBuffer(graphics);
isRebuilding = false;
//chunk.PrimitiveMutex.WaitOne();
chunk.NewPrimitive = this;
chunk.NewPrimitiveReceived = true;
//chunk.PrimitiveMutex.ReleaseMutex();
}
public static void UpdateRamps(VoxelChunk chunk)
{
Dictionary<BoxFace, bool> faceExists = new Dictionary<BoxFace, bool>();
Dictionary<BoxFace, bool> faceVisible = new Dictionary<BoxFace, bool>();
Voxel v = chunk.MakeVoxel(0, 0, 0);
Voxel vAbove = chunk.MakeVoxel(0, 0, 0);
Voxel voxelOnFace = chunk.MakeVoxel(0, 0, 0);
Voxel worldVoxel = new Voxel();
for(int x = 0; x < chunk.SizeX; x++)
{
for(int y = 0; y < Math.Min(chunk.Manager.ChunkData.MaxViewingLevel + 1, chunk.SizeY); y++)
{
for(int z = 0; z < chunk.SizeZ; z++)
{
v.GridPosition = new Vector3(x, y, z);
bool isTop = false;
if(y < chunk.SizeY - 1)
{
vAbove.GridPosition = new Vector3(x, y + 1, z);
isTop = vAbove.IsEmpty;
}
if(isTop && !v.IsEmpty && v.IsVisible && v.Type.CanRamp)
{
for(int i = 0; i < 6; i++)
{
BoxFace face = (BoxFace) i;
if(!IsSideFace(face))
{
continue;
}
Vector3 delta = FaceDeltas[face];
faceExists[face] = chunk.IsCellValid(x + (int) delta.X, y + (int) delta.Y, z + (int) delta.Z);
faceVisible[face] = true;
if(faceExists[face])
{
voxelOnFace.GridPosition = new Vector3(x + (int) delta.X, y + (int) delta.Y,
z + (int) delta.Z);
if(voxelOnFace.IsEmpty || !voxelOnFace.IsVisible)
{
faceVisible[face] = true;
}
else
{
faceVisible[face] = false;
}
}
else
{
if (!chunk.Manager.ChunkData.GetNonNullVoxelAtWorldLocation(new Vector3(x + (int)delta.X + 0.5f, y + (int)delta.Y + 0.5f, z + (int)delta.Z + 0.5f) + chunk.Origin, ref worldVoxel) || !worldVoxel.IsVisible)
{
faceVisible[face] = true;
}
else
{
faceVisible[face] = false;
}
}
if(faceVisible[face])
{
v.RampType = v.RampType | UpdateRampType(face);
}
}
if(RampIsDegenerate(v.RampType))
{
v.RampType = RampType.None;
}
}
else if(!v.IsEmpty && v.IsVisible && v.Type.CanRamp)
{
v.RampType = RampType.None;
}
}
}
}
}
public void InitializeFromChunk(VoxelChunk chunk, GraphicsDevice graphics)
{
if (chunk == null)
{
return;
}
rebuildMutex.WaitOne();
if (isRebuilding)
{
rebuildMutex.ReleaseMutex();
return;
}
isRebuilding = true;
rebuildMutex.ReleaseMutex();
int[] ambientValues = new int[4];
int maxIndex = 0;
int maxVertex = 0;
Voxel v = chunk.MakeVoxel(0, 0, 0);
Voxel voxelOnFace = chunk.MakeVoxel(0, 0, 0);
Voxel[] manhattanNeighbors = new Voxel[4];
BoxPrimitive bedrockModel = VoxelLibrary.GetPrimitive("Bedrock");
Voxel worldVoxel = new Voxel();
if (Vertices == null)
{
Vertices = new ExtendedVertex[1024];
}
if (Indexes == null)
{
Indexes = new ushort[512];
}
for (int y = 0; y < Math.Min(chunk.Manager.ChunkData.MaxViewingLevel + 1, chunk.SizeY); y++)
{
for (int x = 0; x < chunk.SizeX; x++)
{
for (int z = 0; z < chunk.SizeZ; z++)
{
v.GridPosition = new Vector3(x, y, z);
if ((v.IsExplored && v.IsEmpty) || !v.IsVisible)
{
continue;
}
BoxPrimitive primitive = VoxelLibrary.GetPrimitive(v.Type);
if (v.IsExplored && primitive == null)
{
continue;
}
if (!v.IsExplored)
{
primitive = bedrockModel;
}
Color tint = v.Type.Tint;
BoxPrimitive.BoxTextureCoords uvs = primitive.UVs;
if (v.Type.HasTransitionTextures && v.IsExplored)
{
uvs = v.ComputeTransitionTexture(manhattanNeighbors);
}
for (int i = 0; i < 6; i++)
{
BoxFace face = (BoxFace)i;
Vector3 delta = FaceDeltas[(int)face];
faceExists[(int)face] = chunk.IsCellValid(x + (int)delta.X, y + (int)delta.Y, z + (int)delta.Z);
drawFace[(int)face] = true;
if (faceExists[(int)face])
{
voxelOnFace.GridPosition = new Vector3(x + (int)delta.X, y + (int)delta.Y, z + (int)delta.Z);
drawFace[(int)face] = (voxelOnFace.IsExplored && voxelOnFace.IsEmpty) || !voxelOnFace.IsVisible ||
(voxelOnFace.Type.CanRamp && voxelOnFace.RampType != RampType.None && IsSideFace(face) &&
ShouldDrawFace(face, voxelOnFace.RampType, v.RampType));
}
else
{
bool success = chunk.Manager.ChunkData.GetNonNullVoxelAtWorldLocation(new Vector3(x + (int)delta.X, y + (int)delta.Y, z + (int)delta.Z) + chunk.Origin, ref worldVoxel);
drawFace[(int)face] = !success || (worldVoxel.IsExplored && worldVoxel.IsEmpty) || !worldVoxel.IsVisible ||
(worldVoxel.Type.CanRamp && worldVoxel.RampType != RampType.None &&
IsSideFace(face) &&
ShouldDrawFace(face, worldVoxel.RampType, v.RampType));
}
}
for (int i = 0; i < 6; i++)
{
BoxFace face = (BoxFace)i;
if (!drawFace[(int)face])
{
continue;
}
int faceIndex = 0;
int faceCount = 0;
int vertexIndex = 0;
int vertexCount = 0;
primitive.GetFace(face, uvs, out faceIndex, out faceCount, out vertexIndex, out vertexCount);
Vector2 texScale = uvs.Scales[i];
int indexOffset = maxVertex;
for (int vertOffset = 0; vertOffset < vertexCount; vertOffset++)
{
ExtendedVertex vert = primitive.Vertices[vertOffset + vertexIndex];
VoxelVertex bestKey = primitive.Deltas[vertOffset + vertexIndex];
Color color = v.Chunk.Data.GetColor(x, y, z, bestKey);
ambientValues[vertOffset] = color.G;
Vector3 offset = Vector3.Zero;
Vector2 texOffset = Vector2.Zero;
if (v.Type.CanRamp && ShouldRamp(bestKey, v.RampType))
{
offset = new Vector3(0, -v.Type.RampSize, 0);
if (face != BoxFace.Top && face != BoxFace.Bottom)
{
texOffset = new Vector2(0, v.Type.RampSize * (texScale.Y));
}
}
if (maxVertex >= Vertices.Length)
{
ExtendedVertex[] newVertices = new ExtendedVertex[Vertices.Length * 2];
Vertices.CopyTo(newVertices, 0);
Vertices = newVertices;
}
Vertices[maxVertex] = new ExtendedVertex(vert.Position + v.Position +
VertexNoise.GetNoiseVectorFromRepeatingTexture(
vert.Position + v.Position) + offset,
color,
tint,
uvs.Uvs[vertOffset + vertexIndex] + texOffset,
uvs.Bounds[faceIndex / 6]);
maxVertex++;
}
bool flippedQuad = ambientValues[0] + ambientValues[2] >
ambientValues[1] + ambientValues[3];
for (int idx = faceIndex; idx < faceCount + faceIndex; idx++)
{
if (maxIndex >= Indexes.Length)
{
ushort[] indexes = new ushort[Indexes.Length * 2];
Indexes.CopyTo(indexes, 0);
Indexes = indexes;
}
ushort vertexOffset = flippedQuad ? primitive.FlippedIndexes[idx] : primitive.Indexes[idx];
ushort vertexOffset0 = flippedQuad? primitive.FlippedIndexes[faceIndex] : primitive.Indexes[faceIndex];
Indexes[maxIndex] =
(ushort)((int)indexOffset + (int)((int)vertexOffset - (int)vertexOffset0));
maxIndex++;
}
}
}
}
}
MaxIndex = maxIndex;
MaxVertex = maxVertex;
GenerateLightmap(chunk.Manager.ChunkData.Tilemap.Bounds);
isRebuilding = false;
//chunk.PrimitiveMutex.WaitOne();
chunk.NewPrimitive = this;
chunk.NewPrimitiveReceived = true;
//chunk.PrimitiveMutex.ReleaseMutex();
}
public void GenerateVegetation(VoxelChunk chunk, ComponentManager components, ContentManager content, GraphicsDevice graphics)
{
int waterHeight = (int)(SeaLevel * chunk.SizeY);
bool updated = false;
Voxel v = chunk.MakeVoxel(0, 0, 0);
Voxel vUnder = chunk.MakeVoxel(0, 0, 0);
for (int x = 0; x < chunk.SizeX; x++)
{
for (int z = 0; z < chunk.SizeZ; z++)
{
Vector2 vec = new Vector2(x + chunk.Origin.X, z + chunk.Origin.Z) / PlayState.WorldScale;
Overworld.Biome biome = Overworld.Map[(int)MathFunctions.Clamp(vec.X, 0, Overworld.Map.GetLength(0) - 1), (int)MathFunctions.Clamp(vec.Y, 0, Overworld.Map.GetLength(1) - 1)].Biome;
BiomeData biomeData = BiomeLibrary.Biomes[biome];
int y = chunk.GetFilledVoxelGridHeightAt(x, chunk.SizeY - 1, z);
if (!chunk.IsCellValid(x, (int)(y - chunk.Origin.Y), z))
{
continue;
}
v.GridPosition = new Vector3(x, y, z);
if (!v.IsEmpty || chunk.Data.Water[v.Index].WaterLevel != 0 || y <= waterHeight)
{
continue;
}
foreach (VegetationData veg in biomeData.Vegetation)
{
if (y <= 0)
{
continue;
}
if (!MathFunctions.RandEvent(veg.SpawnProbability))
{
continue;
}
if (NoiseGenerator.Noise(vec.X / veg.ClumpSize, veg.NoiseOffset, vec.Y / veg.ClumpSize) < veg.ClumpThreshold)
{
continue;
}
int yh = chunk.GetFilledVoxelGridHeightAt(x, y, z);
if (yh > 0)
{
vUnder.GridPosition = new Vector3(x, yh - 1, z);
if (!vUnder.IsEmpty && vUnder.TypeName == biomeData.GrassVoxel)
{
vUnder.Type = VoxelLibrary.GetVoxelType(biomeData.SoilVoxel);
updated = true;
float offset = veg.VerticalOffset;
if (vUnder.RampType != RampType.None)
{
offset -= 0.25f;
}
float treeSize = MathFunctions.Rand() * veg.SizeVariance + veg.MeanSize;
EntityFactory.CreateEntity <Body>(veg.Name, chunk.Origin + new Vector3(x, y, z) + new Vector3(0, treeSize * offset, 0), Blackboard.Create("Scale", treeSize));
}
}
break;
}
}
}
if (updated)
{
chunk.ShouldRebuild = true;
}
}
