/// <summary>
/// se llama cuando se recibe los datos de la malla
/// </summary>
/// <param name="dataOfMesh"></param>
public void DataOfMeshHasBeenReceived(DataOfMesh dataOfMesh)
{
_dataOfMesh = dataOfMesh.MakeMesh();
_thereIsDataOfMeshStored = true;
_method();
}
/// <summary>
/// Algoritmo para generar dos datos de la malla. despues estos datos en el hilo principal se asociaran a un objeto de Unity
/// </summary>
/// <param name="heightMap"></param>
/// <param name="LOD"></param>
/// <returns></returns>
private DataOfMesh makeMesh(float[,] heightMap, int LOD)
{
//Calculo del incremento (salto entre vertices) para construir la malla con el LOD adecuado
int increaseOfLOD;
if (LOD != 0)
{
increaseOfLOD = LOD * 2;
}
else
{
increaseOfLOD = 1;
}
//calculo de los vértices que habrá en fila de la malla én funcion del LOD que se establezca
int vPerLine = (_sizeOfChunk - 1) / increaseOfLOD + 1;
//inicializamos la malla con el numero de vertices que tendrá, despues de calcular el LOD
DataOfMesh dataOfMesh = new DataOfMesh(vPerLine);
//1º parte del algoritmo para generar la malla 3D: con vertices compartidos.
dataOfMesh = makeMeshWithSharedVertices(dataOfMesh, heightMap, increaseOfLOD, vPerLine);
//2º parte del algoritmo para generar la malla 3D: caras indepentdientes.
dataOfMesh = transformMeshFromSharedVerticesToIndependentFaces(dataOfMesh);
return(dataOfMesh);
}
/// <summary>
/// Metodo para obtener los datos de la malla dentro del hilo
/// </summary>
/// <param name="heightMapAndColorArray"></param>
/// <param name="increaseOfLOD"></param>
/// <param name="Method"></param>
void generateMeshInThread(HeightMapAndColorArray heightMapAndColorArray, int increaseOfLOD, Action <DataOfMesh> Method)
{
//genera la los datos de la malla
DataOfMesh dataOfMesh = makeMesh(heightMapAndColorArray.HeightMap, increaseOfLOD);
//Bloqueo si algún otro hilo esta usando la cola para evitar fallos de ejecución. añade a la cola un objeto de la clase ThreadInfoMapa el metodo (metodo) y el parametro que necesita (mapaAyC)
lock (_queueDataOfMesh)
{
_queueDataOfMesh.Enqueue(new ThreadInfo <DataOfMesh>(Method, dataOfMesh));
}
}
/// <summary>
/// 2º parte del algoritmo para la generacion de la malla 3D del terreno
/// </summary>
/// <param name="dataOfMesh"></param>
/// <returns></returns>
private DataOfMesh transformMeshFromSharedVerticesToIndependentFaces(DataOfMesh dataOfMesh)
{
Vector3[] flatVertices = new Vector3[dataOfMesh.Triangles.Length];
Vector2[] flatUvs = new Vector2[dataOfMesh.Triangles.Length];
int index = 0;
while (index < dataOfMesh.Triangles.Length)
{
flatVertices[index] = dataOfMesh.Vertices[dataOfMesh.Triangles[index]];
flatUvs[index] = dataOfMesh.Uvs[dataOfMesh.Triangles[index]];
dataOfMesh.Triangles[index] = index;
index++;
}
dataOfMesh.Vertices = flatVertices;
dataOfMesh.Uvs = flatUvs;
return(dataOfMesh);
}
/// <summary>
/// 1º parte del algoritmo para la generacion de la malla 3D del terreno.
/// </summary>
/// <param name="dataOfMesh"></param>
/// <param name="heightMap"></param>
/// <param name="increaseOdLOD"></param>
/// <param name="vPerLine"></param>
/// <returns></returns>
private DataOfMesh makeMeshWithSharedVertices(DataOfMesh dataOfMesh, float[,] heightMap, int increaseOdLOD, int vPerLine)
{
float xSupLeft = (_sizeOfChunk - 1) / -2f;
float zSupLeft = xSupLeft * (-1);
int indexOfvertex = 0;
//Al acceder desde diferentes hilos a la curva genera valores erroneos, por lo que simplemente se crea una copia de la curva.
AnimationCurve curveOfHeight = new AnimationCurve(curva.keys);
for (int i = 0; i < _sizeOfChunk; i += increaseOdLOD)
{
for (int j = 0; j < _sizeOfChunk; j += increaseOdLOD)
{
//crea vertices vector3 y accede al mapa de alturas para situarlo a la altura que le corresponde. usa la curva y el multiplicador para acentuar las montañas.
//Vector3 vertice = new Vector3(xSupIzq + j, mapaAlturas[j, i], zSupIzq - i);
Vector3 vertex = new Vector3(xSupLeft + j, curveOfHeight.Evaluate(heightMap[j, i]) * _multiplier, zSupLeft - i);
dataOfMesh.Vertices[indexOfvertex] = vertex;
//actualiza el vertor de Uvs, tiene que ser entre 0 y 1.
Vector2 uv = new Vector2(j / (float)_sizeOfChunk, i / (float)_sizeOfChunk);
dataOfMesh.Uvs[indexOfvertex] = uv;
//para evitar acceder a la ultima fila y ultima columna ya que para un vértice se añade los dos triangulos que entán debajo y a la derecha.
if (j < _sizeOfChunk - 1 && i < _sizeOfChunk - 1)
{
//Añadir los 2 trianglos de abajo y derecha.
dataOfMesh.AddTriangleToMesh(indexOfvertex, indexOfvertex + vPerLine + 1, indexOfvertex + vPerLine);
dataOfMesh.AddTriangleToMesh(indexOfvertex + vPerLine + 1, indexOfvertex, indexOfvertex + 1);
}
//siguiente vertice.
indexOfvertex++;
}
}
return(dataOfMesh);
}
/// <summary>
/// Cuando se reciba la información de la malla ya calculada en un hilo externo se ejecutará este metodo
/// </summary>
/// <param name="dataOfMesh"></param>
private void applyTheMeshToTheObject(DataOfMesh dataOfMesh)
{
_meshFilter.mesh = dataOfMesh.MakeMesh();
}