static void CalculateVertexWeight(MarchingCube cube, int index, MarchingCubeChunkSetting marchingCubeSetting, NoiseSetting noiseSetting)
{
//Cube neigborCube;
//check there is exsiting noise value at neighbor
//Skip this process because we use perlin noise
//if(cubeDictionary.TryGetValue(new Vector3(vertexPosition.x - someOffset?, vertexPosition.y, vertexPosition.z), out neigborCube) {
// ...
//} else if ...
//For threading, we have to dupulicate Animation Curve
AnimationCurve weightCurve = new AnimationCurve(marchingCubeSetting.weightCurve.keys);
float height = cube.origin.y + cube.offset[index].y;
float height01 = Mathf.Lerp(1, 0, (marchingCubeSetting.mapMaxHeight - height) / (marchingCubeSetting.mapMaxHeight - marchingCubeSetting.mapMinHeight));
float weight = MarchingCubeNoise.GenerateTerrainNoise(cube.origin + cube.offset[index], noiseSetting) * weightCurve.Evaluate(height01);
if (height < marchingCubeSetting.mapMinHeight + cube.offsetDistance)
{
weight = 1;
}
else if (height > marchingCubeSetting.mapMaxHeight - cube.offsetDistance)
{
weight = 0;
}
cube.vertexSelected[index] = weight < marchingCubeSetting.ignoreVertexLevel;
cube.vertexWeight[index] = weight;
}
public void RequestMeshData(MeshData meshData, Vector3 center, MarchingCubeChunkSetting chunkSettings, NoiseSetting noiseSettings, Action <MeshData> callback)
{
ThreadStart threadStart = delegate {
ThreadMeshData(meshData, center, chunkSettings, noiseSettings, callback);
};
new Thread(threadStart).Start();
}
void ThreadMeshData(MeshData meshData, Vector3 center, MarchingCubeChunkSetting chunkSetting, NoiseSetting noiseSetting, Action <MeshData> callback)
{
List <MarchingCube> cubes = MarchingCubeChunk.InitVertices(center, chunkSetting, noiseSetting);
Vector3[] vertices = MarchingCubeChunk.GenerateVertices(cubes);
meshData.cubes = cubes;
meshData.vertices = vertices;
meshData.triangles = MarchingCubeChunk.GenerateTriangles(vertices);
meshData.uvs = biomeSetting.GenerateUVS(this.chunkSetting, vertices);
lock (meshDataThreadInfoQueue)
{
meshDataThreadInfoQueue.Enqueue(new GeneratorThreadInfo <MeshData>(callback, meshData));
}
}
public Vector2[] GenerateUVS(MarchingCubeChunkSetting settings, Vector3[] vertices)
{
Vector2[] returnUVS = new Vector2[vertices.Length];
for (int v = 0; v < vertices.Length; v++)
{
float height = vertices[v].y;
float height01 = Mathf.Lerp(1, 0, (settings.mapMaxHeight - height) / (settings.mapMaxHeight - settings.mapMinHeight));
int textureIndex = 0;
for (int b = 0; b < biomes.Length; b++)
{
if (biomes[b].startHeight <= height01)
{
textureIndex = b;
}
}
returnUVS[v] = new Vector2(textureIndex, textureIndex);
}
return(returnUVS);
}
public static List <MarchingCube> InitVertices(Vector3 center, MarchingCubeChunkSetting marchingCubeChunksettings, NoiseSetting noiseSetting)
{
List <MarchingCube> cubeList = new List <MarchingCube>();
for (int x = 0; x < marchingCubeChunksettings.numberOfVerticesPerLine; x++)
{
for (int y = 0; y < marchingCubeChunksettings.numberOfVerticesPerLine; y++)
{
for (int z = 0; z < marchingCubeChunksettings.numberOfVerticesPerLine; z++)
{
MarchingCube cube = new MarchingCube(new Vector3(x, y, z) * marchingCubeChunksettings.distanceBetweenVertex + center, marchingCubeChunksettings.distanceBetweenVertex);
cubeList.Add(cube);
for (int i = 0; i < 8; i++)
{
CalculateVertexWeight(cube, i, marchingCubeChunksettings, noiseSetting);
}
}
}
}
return(cubeList);
}
