public void ConstructMesh() { //array of vertices = r^2 vertices = new Vector3[resolution * resolution]; //total number of meshes (3 connected vertecies) = (r-1)^2 * 2 //total number of meshes * (vertecies each mesh uses) = ((r-1)^2 * 2) * 3 int[] triangles = new int[(resolution - 1) * (resolution - 1) * 2 * 3]; int triIndex = 0; Vector2[] uv = (mesh.uv.Length == vertices.Length) ? mesh.uv : new Vector2[vertices.Length]; for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { //index counter int i = x + y * resolution; //it varies between 0-1 //starts with 0, each time added by a fraction Vector2 percent = new Vector2(x, y) / (resolution - 1); //the percent usage is very tricky and nice Vector3 pointOnUnitCube = localUp //point position on the facing axis + (percent.x - 0.5f) * 2 * axisA //point position on the "relative" +x + (percent.y - 0.5f) * 2 * axisB; //point position on the "relative" -y Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; //vertices[i] = pointOnUnitCube; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].y = unscaledElevation; //I can not create any mesh on the edge if (x != resolution - 1 && y != resolution - 1) { //first triangle triangles[triIndex + 0] = i; triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; //second triangle triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; triIndex += 6; } } } mesh.Clear(); //clear previous data mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = uv; }
// ********************************************************************** // public void ConstructMesh() { // Make a mesh out of lots of small triangles defined over a grid of resolution size 'resolution' Vector3[] vertices = new Vector3[resolution * resolution]; int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; // this many triangles as a function of number of vertices on each dimension (i.e. resolution). int triIndex = 0; Vector2[] uv = (mesh.uv.Length == vertices.Length) ? mesh.uv : new Vector2[vertices.Length]; // if uv is correct length then all good, otherwise make a new one for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { int i = x + y * resolution; // this is a counter, same as setting int i=0 outside y loop and incrementing on inner loop Vector2 percent = new Vector2(x, y) / (resolution - 1); Vector3 pointOnUnitCube = localUp + (percent.x - 0.5f) * 2 * axisA + (percent.y - 0.5f) * 2 * axisB; // geometry magic from youtube tutorial //vertices[i] = pointOnUnitCube; // if you want a cube use this // Turn the cube into a sphere Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].y = unscaledElevation; // Note that vertices are labelled as: e.g. 0 1 2 // 3 4 5 // 6 7 8 // and so triangles making up each square in this grid are indexed as e.g. 0-4-3; 0-1-4; 1-5-4; etc if ((x != resolution - 1) && (y != resolution - 1)) { // first triangle triangles[triIndex] = i; triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; triIndex += 6; } } } mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = uv; }
public void ConstructMesh() { Vector3[] vertices = new Vector3[resolution * resolution]; //-> 6 = number of triangles to make a square * number of vertices to make a triangle (2*3) int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; int i = 0; int triIndex = 0; Vector2[] UV = (mesh.uv.Length == vertices.Length) ? mesh.uv : new Vector2[vertices.Length]; for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { // how close to complete each of these loops is Vector2 percent = new Vector2(x, y) / (resolution - 1); Vector3 pointOnUnitCube = localUp + (percent.x - .5f) * 2 * axisA + (percent.y - .5f) * 2 * axisB; // transform the current planar cube as a spherical/round plane Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); // using the y axis for the biomes UV[i].y = unscaledElevation; // make a square for this mesh if (x != resolution - 1 && y != resolution - 1) { // first triangle triangles[triIndex] = i; triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; // second triangle triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; // we added 6 vertices, update the index count triIndex += 6; } ++i; } } // clear all the data from the mesh to prevent // adding to the previous lower resolution mesh mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = UV; }
public void ConstructMesh() { Vector3[] vertices = new Vector3[resolution * resolution]; int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; // number of triangles for a square mesh with resolution vertices per side, times 3 for the number of vertex triplets int triIndex = 0; Vector2[] uv = (mesh.uv.Length == vertices.Length) ? mesh.uv : new Vector2[vertices.Length]; // save uv before resetting mesh, to avoid recalculating for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { int i = x + y * resolution; // number of total iterations Vector2 percent = new Vector2(x, y) / (resolution - 1); // percent on the x-axis and y-axis, between 0 and 1 Vector3 pointOnUnitCube = localUp + (percent.x - .5f) * 2 * axisA + (percent.y - .5f) * 2 * axisB; // sum of base vectors Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].y = unscaledElevation; // Create the triangles, if not on right or bottom edges if (x != resolution - 1 && y != resolution - 1) { // Create triangle South-East triangles[triIndex] = i; triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; // Create triangle East-South triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; // Increment triIndex triIndex += 6; } } } // Refresh mesh mesh.Clear(); // clear all data to avoid errors when downgrading resolution mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = uv; // reassigned saved uv }
public void ConstructMesh() { Vector3[] vertices = new Vector3[resolution * resolution]; int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; int triIndex = 0; Vector2[] uv; if (mesh.uv.Length == vertices.Length) { uv = mesh.uv; } else { uv = new Vector2[vertices.Length]; } for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { int i = x + y * resolution; Vector2 percent = new Vector2(x, y) / (resolution - 1); Vector3 pointOnUnitCube = localUp + (percent.x - .5f) * 2 * axisA + (percent.y - .5f) * 2 * axisB; Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].y = unscaledElevation; if (x != resolution - 1 && y != resolution - 1) { triangles[triIndex] = i; triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; triIndex += 6; } } } mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = uv; meshCollider.sharedMesh = mesh; }
public void ConstructMesh() { Vector3[] _vertices = new Vector3[resolution * resolution]; int[] _triangles = new int[(resolution - 1) * (resolution - 1) * 6]; int _triangleIndex = 0; Vector2[] _uvData = (mesh.uv.Length == _vertices.Length) ? mesh.uv : new Vector2[_vertices.Length]; for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { int _index = y * resolution + x; Vector2 _percent = new Vector2(x, y) / (resolution - 1); Vector3 _pointOnUnitCube = localUp + (_percent.x - 0.5f) * 2 * axisA + (_percent.y - 0.5f) * 2 * axisB; Vector3 _pointOnUnitSphere = _pointOnUnitCube.normalized; float _unscaledElevation = shapeGenerator.CalculateUnscaledElevation(_pointOnUnitSphere); _vertices[_index] = _pointOnUnitSphere * shapeGenerator.GetScaledElevation(_unscaledElevation); _uvData[_index].y = _unscaledElevation; if (x != resolution - 1 && y != resolution - 1) { // first triangle in square _triangles[_triangleIndex] = _index; _triangles[_triangleIndex + 1] = _index + resolution + 1; _triangles[_triangleIndex + 2] = _index + resolution; // second triangle in square _triangles[_triangleIndex + 3] = _index; _triangles[_triangleIndex + 4] = _index + 1; _triangles[_triangleIndex + 5] = _index + resolution + 1; _triangleIndex += 6; } } } mesh.Clear(); mesh.vertices = _vertices; mesh.triangles = _triangles; mesh.RecalculateNormals(); mesh.uv = _uvData; }
public void ConstructMesh() { var vertices = new Vector3[resolution * resolution]; var triangles = new int[(resolution - 1) * (resolution - 1) * 6]; var triIndex = 0; var uv = mesh.uv.Length == vertices.Length ? mesh.uv : new Vector2[vertices.Length]; for (var y = 0; y < resolution; y++) { for (var x = 0; x < resolution; x++) { var i = x + y * resolution; var percent = new Vector2(x, y) / (resolution - 1); var pointOnCube = localUp + (percent.x - .5f) * 2 * axisA + (percent.y - .5f) * 2 * axisB; var pointOnSphere = pointOnCube.normalized; var unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnSphere); vertices[i] = pointOnSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].y = unscaledElevation; if (x == resolution - 1 || y == resolution - 1) { continue; } triangles[triIndex] = i; triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; triIndex += 6; } } mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = uv; }
public void ConstructMesh() { Vector3[] vertices = new Vector3[resolution * resolution]; int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; // https://prnt.sc/r6if91 int triIndex = 0; Vector2[] uv = (mesh.uv.Length == vertices.Length) ? mesh.uv : new Vector2[vertices.Length]; for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { int i = x + y * resolution; Vector2 percent = new Vector2(x, y) / (resolution - 1); Vector3 pointOnUnitCube = axisY + (percent.x - 0.5f) * 2 * axisX + (percent.y - 0.5f) * 2 * axisZ; Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].y = unscaledElevation; // do not construct for the border of the mesh if (x != resolution - 1 && y != resolution - 1) { triangles[triIndex] = i; triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; triIndex += 6; } } } mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = uv; }
public void ConstructMesh() { Vector3[] vertices = new Vector3[resolution * resolution]; //Store all vertices int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; //Int array to indeces of all triangles. size = resolution-1 squared(number of squares) * 2 (number of triangles per square) * 3 (number of vertices per triangle) int triIndex = 0; //Debug.Log(mesh); //mesh is setto null for some reason... Vector2[] uv = (mesh.uv.Length == vertices.Length)?mesh.uv:new Vector2[vertices.Length]; for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) //Iterate over entire face { int i = x + y * resolution; Vector2 percent = new Vector2(x, y) / (resolution - 1); //Tells us how far through the loop we are Vector3 pointOnUnitCube = localUp + (percent.x - .5f) * 2 * axisA + (percent.y - .5f) * 2 * axisB; Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; //used to go from a cube to a sphere float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].y = unscaledElevation; if (x != resolution - 1 && y != resolution - 1) //vertex is not along the right or bottom edges { triangles[triIndex] = i; //Build the two triangles that make up a square by defining their 6 points (3 per triangle) triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; triIndex += 6; } } } mesh.Clear(); //If we update with a lower resolution, then when we set mesh.vertices, mesh.triangles will reference vertices that no longer exist and will throw an error. Therefore we need to clear the mesh before setting the new vertices mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = uv; }
public void GenerateMesh() { var vertices = new Vector3[resolution * resolution]; var triangles = new int[(resolution - 1) * (resolution - 1) * 6]; Vector2[] uv = (mesh.uv.Length == vertices.Length) ? mesh.uv : new Vector2[vertices.Length]; int triIndex = 0; for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { int i = x + y * resolution; var percent = new Vector2(x, y) / (resolution - 1); var pointOnUnitCube = localUp + (percent.x - 0.5f) * 2 * axisA + (percent.y - 0.5f) * 2 * axisB; var pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].y = unscaledElevation; if (x != resolution - 1 && y != resolution - 1) { triangles[triIndex] = i; triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; triIndex += 6; } } } mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = uv; }
public void ConstructMesh() { Vector3[] vertices = new Vector3[resolution * resolution]; int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; int triIndex = 0; Vector2[] uv = (mesh.uv.Length == vertices.Length) ? mesh.uv : new Vector2[vertices.Length]; for (int y = 0, i = 0; y < resolution; ++y) { for (int x = 0; x < resolution; ++x, ++i) { Vector2 percent = new Vector2(x, y) / (resolution - 1); Vector3 pointOnUnitCube = localUp + (percent.x - 0.5f) * 2 * axisA + (percent.y - 0.5f) * 2 * axisB; Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].y = unscaledElevation; if (x != resolution - 1 && y != resolution - 1) { triangles[triIndex++] = i; triangles[triIndex++] = i + resolution + 1; triangles[triIndex++] = i + resolution; triangles[triIndex++] = i; triangles[triIndex++] = i + 1; triangles[triIndex++] = i + resolution + 1; } } } mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); mesh.uv = uv; }
public void ConstructMesh(int levelOfDetail) { int simplificationIncriment = levelOfDetail; //levelOfDetail==0?1:levelOfDetail*2; int verticesPerLine = (resolution - 1) / simplificationIncriment + 1; //LOD MeshData meshData = new MeshData(verticesPerLine, verticesPerLine); int vertexIndex = 0; Vector3[] vertices = new Vector3[resolution * resolution]; int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; Vector2[] uv = (mesh.uv.Length == vertices.Length)?mesh.uv:new Vector2[vertices.Length]; for (int y = 0; y < resolution; y += simplificationIncriment) { for (int x = 0; x < resolution; x += simplificationIncriment) { //LOD //vertexIndex=x + y * resolution; Vector2 percent = new Vector2(x, y) / (resolution - 1); Vector3 pointOnUnitCube = localUp + (percent.x - .5f * subfaceNumber + (subfaceIndex % subfaceNumber)) * (2f / subfaceNumber) * axisA + (percent.y - .5f * subfaceNumber + (subfaceIndex / subfaceNumber)) * (2f / subfaceNumber) * axisB; Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); //LOD meshData.vertices[vertexIndex] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); meshData.uvs[vertexIndex].y = unscaledElevation; if (x < resolution - 1 && y < resolution - 1) { meshData.AddTriangle(vertexIndex, vertexIndex + verticesPerLine + 1, vertexIndex + verticesPerLine); meshData.AddTriangle(vertexIndex, vertexIndex + 1, vertexIndex + verticesPerLine + 1); } vertexIndex++; } } mesh.Clear(); mesh = meshData.CreateMesh(mesh); }
public void ConstructMesh(int xMesh, int yMesh, int divisions, Vector3 center) { Vector3[] vertices = new Vector3[resolution * resolution]; int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; int[] realTriangles = new int[(resolution - 1) * (resolution - 1) * 6]; int triIndex = 0; Vector2[] uv = (mesh.uv.Length == vertices.Length)?mesh.uv:new Vector2[vertices.Length]; Vector3[] norms = new Vector3[resolution * resolution]; for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { int i = x + y * resolution; Vector2 percent = new Vector2(x - 0, y - 0) / (resolution - 1 - 0); Vector3 pointOnUnitCube = localUp + ((float)xMesh / divisions + percent.x / divisions - .5f) * 2 * axisA + ((float)yMesh / divisions + percent.y / divisions - .5f) * 2 * axisB; Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); vertices[i] = pointOnUnitSphere * shapeGenerator.GetScaledElevation(unscaledElevation); uv[i].x = (unscaledElevation > 0) ? unscaledElevation : unscaledElevation * 1; if (unscaledElevation > 0.2f) { //Debug.Log(unscaledElevation); } if (x < resolution - 1 && y < resolution - 1) { triangles[triIndex] = i; triangles[triIndex + 1] = i + resolution + 1; triangles[triIndex + 2] = i + resolution; triangles[triIndex + 3] = i; triangles[triIndex + 4] = i + 1; triangles[triIndex + 5] = i + resolution + 1; if (x < hiddenResolution - 1 && y < hiddenResolution - 1) { realTriangles[triIndex] = i; realTriangles[triIndex + 1] = i + resolution + 1; realTriangles[triIndex + 2] = i + resolution; realTriangles[triIndex + 3] = i; realTriangles[triIndex + 4] = i + 1; realTriangles[triIndex + 5] = i + resolution + 1; } triIndex += 6; } } } mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); //mesh.triangles = realTriangles; mesh.uv = uv; norms = mesh.normals; for (int y = 0; y < resolution; y++) { for (int x = 0; x < resolution; x++) { if (x == 0 || x == (resolution - 1) || y == 0 || y == (resolution - 1)) { int i = x + y * resolution; Vector2 percent = new Vector2(x - 0, y - 0) / (resolution - 1 - 0); Vector3 pointOnUnitCube = localUp + ((float)xMesh / divisions + percent.x / divisions - .5f) * 2 * axisA + ((float)yMesh / divisions + percent.y / divisions - .5f) * 2 * axisB; Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; norms[i] = pointOnUnitSphere; } } } mesh.normals = norms; }
public void ConstructMesh() { Vector3[] vertices = new Vector3[resolution * resolution]; int[] triangles = new int[(resolution - 1) * (resolution - 1) * 6]; Vector3[] borderVertices = new Vector3[resolution * 4 + 4]; int[] borderTriangles = new int[24 * resolution]; int triIndex = 0; int borderTriIndex = 0; Vector2[] uv = (mesh.uv.Length == vertices.Length) ? mesh.uv : new Vector2[vertices.Length]; int[,] vertexIndicesMap = new int[borderedResolution, borderedResolution]; int meshVertexIndex = 0; int borderVertexIndex = -1; for (int y = 0; y < borderedResolution; y++) { for (int x = 0; x < borderedResolution; x++) { bool isBorderVertex = y == 0 || y == borderedResolution - 1 || x == 0 || x == borderedResolution - 1; if (isBorderVertex) { vertexIndicesMap[x, y] = borderVertexIndex; borderVertexIndex--; } else { vertexIndicesMap[x, y] = meshVertexIndex; meshVertexIndex++; } } } for (int y = 0; y < borderedResolution; y++) { for (int x = 0; x < borderedResolution; x++) { int i = vertexIndicesMap[x, y]; Vector2 percent = new Vector2(x - 1, y - 1) / (resolution - 1); Vector3 pointOnUnitCube = localUp + (percent.x - 0.5f) * 2 * axisA + (percent.y - 0.5f) * 2 * axisB; Vector3 pointOnUnitSphere = pointOnUnitCube.normalized; float unscaledElevation = shapeGenerator.CalculateUnscaledElevation(pointOnUnitSphere); float scaledElevation = shapeGenerator.GetScaledElevation(unscaledElevation); // shapeGenerator.elevationMinMax.AddValue(scaledElevation); Vector3 vertexPosition = pointOnUnitSphere * scaledElevation; float vertexUV = unscaledElevation; AddVertex(vertexPosition, vertexUV, i, ref vertices, ref uv, ref borderVertices); if (x != borderedResolution - 1 && y != borderedResolution - 1) { int a = vertexIndicesMap[x, y]; int b = vertexIndicesMap[x + 1, y]; int c = vertexIndicesMap[x, y + 1]; int d = vertexIndicesMap[x + 1, y + 1]; AddTriangle(a, d, c, ref triIndex, ref borderTriIndex, ref triangles, ref borderTriangles); AddTriangle(d, a, b, ref triIndex, ref borderTriIndex, ref triangles, ref borderTriangles); } } } mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.normals = CalculateNormals(ref triangles, ref borderTriangles, ref vertices, ref borderVertices); mesh.uv = uv; }