Procedural Planet Terrain Engine

Howdy!

Back again, this time I'm working on a Procedural planet generator. So far I've been able to get a Subdivided Plane converted into a sphere (victory!) but am hitting some snags with the UV side of the house. I more or less understand the concept...I think. I essentially need the four corners of a subdivided square, but I'm not sure how that then gets applied to the pieces composing the quad face....

Attached is a screen grab of what I've got and the code as it sits right now. The textures are manually applied because I've been focusing on getting the geometry right. So the UV coordinates per patch object are working great, so I know I at least haven't screwed those up to bad. Now I just need each face to be one continuous UV space, which will then be mapped with a Cube Map...and procedural textures.

Yeah, so...basically: I need help turning 4 (or however many sub-divisions the user has) into 1 large UV space instead of 4 or 6 or 8 or 3 or whatever individual UV spaces.

Code!

Code (CSharp):

1. using UnityEngine;
2. using System.Collections.Generic;
3. using System;
4.  
5. public class ProceduralPlanet : MonoBehaviour
6. {
7.     //Define the number of Subdivions for patch side.
8.     public int patchSubdivisions = 1;
9.     //Define the number of vertices per of each patch segment.
10.     public int patchResolution = 2;
11.     //Define the planets radius
12.     public int planetRadius = 10;
13.  
14.     public Vector3[] patchVertices;
15.  
16.     private int patchID = 0;
17.     private int vertIndex = 0;
18.  
19.     public enum CubeIndex { TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT }
20.  
21.     public List<SurfacePatch> surfacePatches = new List<SurfacePatch>();
22.  
23.     void Start()
24.     {
25.         patchVertices = new Vector3[((patchSubdivisions * patchSubdivisions) * 4) * 6];
26.         // First we have define our dimensions:
27.         //          +Z
28.         //   -1,1    |    1,1
29.         //      +----|----+
30.         //      |    |    |
31.         //-X --------0-------- +X
32.         //      |    |    |
33.         //      +----|----+
34.         //  -1,-1    |    1,-1
35.         //          -Z
36.         //
37.         // First we have to figure out what our distance increment is going to be. Since we
38.         // know that our total width is 2 we can figure that out using the following:
39.         float increment = 2.0f / patchSubdivisions;
40.         // We can then find the patchHalfWidth using the following:
41.         float patchHalfWidth = (patchSubdivisions / 2.0f) * increment;
42.         //Next we plot the vertices for all of the sub-patches:
43.         if (patchSubdivisions > 0)
44.         {
45.             //Loop through the 'z' positions
46.             for (int z = 0; z < patchSubdivisions; z++)
47.             {
48.                 //Each time through we define the starting 'z' position for each sub-patch and the
49.                 //next 'z' position of the sub-patch.
50.                 float _z  = z * increment;
51.                 float _z1 = (z + 1) * increment;
52.            
53.                 for (int x = 0; x < patchSubdivisions; x++)
54.                 {
55.                     //Each time through we define the starting 'z' position for each sub-patch and the
56.                     //next 'z' position of the sub-patch.
57.                     float _x  = x * increment;
58.                     float _x1 = (x + 1) * increment;
59.  
60.                     //Pass our generated data to CreateSubPatch which then defines the coordinates for
61.                     //each side of the Cube.
62.                     for (int i = 0; i < 6; i++)
63.                     {
64.                         CreatePatch(patchHalfWidth, _x, _x1, _z, _z1, (CubeIndex)i, x, z);
65.                     }                  
66.                 }            
67.             }
68.         }
69.     }
70.  
71.     void CreatePatch(float half, float x, float x1, float z, float z1,  CubeIndex index, int sX, int sZ)
72.     {
73.         //A Vector Array to hold our Patch Vertices...
74.         Vector3 lowLeft  = Vector3.zero;
75.         Vector3 topLeft  = Vector3.zero;
76.         Vector3 topRight = Vector3.zero;
77.         Vector3 lowRight = Vector3.zero;
78.  
79.         switch (index)
80.         {
81.             case CubeIndex.TOP:
82.                 lowLeft = new Vector3(x - half, half, z - half);
83.                 topLeft = new Vector3(x - half, half, z1 - half);
84.                 topRight = new Vector3(x1 - half, half, z1 - half);
85.                 lowRight = new Vector3(x1 - half, half, z - half);
86.  
87.                 //patchVertices[vertIndex] = lowLeft;
88.                 //patchVertices[vertIndex + 1] = topLeft;
89.                 //patchVertices[vertIndex + 2] = topRight;
90.                 //patchVertices[vertIndex + 3] = lowRight;
91.                 break;
92.  
93.             case CubeIndex.BOTTOM:
94.                 lowLeft = new Vector3(x - half, -half, z - half);
95.                 topLeft = new Vector3(x - half, -half, z1 - half);
96.                 topRight = new Vector3(x1 - half, -half, z1 - half);
97.                 lowRight = new Vector3(x1 - half, -half, z - half);
98.            
99.                 //patchVertices[vertIndex] = lowLeft;
100.                 //patchVertices[vertIndex + 1] = topLeft;
101.                 //patchVertices[vertIndex + 2] = topRight;
102.                 //patchVertices[vertIndex + 3] = lowRight;
103.                 break;
104.  
105.             case CubeIndex.FRONT:
106.                 lowLeft = new Vector3(x - half, half - x1, half);
107.                 topLeft = new Vector3(x - half, half - z, half);
108.                 topRight = new Vector3(x1 - half, half - z, half);
109.                 lowRight = new Vector3(x1 - half, half - z1, half);
110.                            
111.                 //patchVertices[vertIndex] = lowLeft;
112.                 //patchVertices[vertIndex + 1] = topLeft;
113.                 //patchVertices[vertIndex + 2] = topRight;
114.                 //patchVertices[vertIndex + 3] = lowRight;
115.                 break;
116.  
117.             case CubeIndex.BACK:
118.                 lowLeft = new Vector3(x - half, half - x1, -half);
119.                 topLeft = new Vector3(x - half, half - z, -half);
120.                 topRight = new Vector3(x1 - half, half - z, -half);
121.                 lowRight = new Vector3(x1 - half, half - z1, -half);
122.                            
123.                 //patchVertices[vertIndex] = lowLeft;
124.                 //patchVertices[vertIndex + 1] = topLeft;
125.                 //patchVertices[vertIndex + 2] = topRight;
126.                 //patchVertices[vertIndex + 3] = lowRight;
127.                 break;
128.  
129.             case CubeIndex.LEFT:
130.                 lowLeft = new Vector3(-half, half - x1, -half + x);
131.                 topLeft = new Vector3(-half, half - z, -half + x);
132.                 topRight = new Vector3(-half, half - z, -half + x1);
133.                 lowRight = new Vector3(-half, half - z1, -half + x1);
134.                            
135.                 patchVertices[vertIndex] = lowLeft;
136.                 patchVertices[vertIndex + 1] = topLeft;
137.                 patchVertices[vertIndex + 2] = topRight;
138.                 patchVertices[vertIndex + 3] = lowRight;
139.                 break;
140.  
141.             case CubeIndex.RIGHT:
142.                 lowLeft = new Vector3(half, half - x1, -half + x);
143.                 topLeft = new Vector3(half, half - z, -half + x);
144.                 topRight = new Vector3(half, half - z, -half + x1);
145.                 lowRight = new Vector3(half, half - z1, -half + x1);
146.                            
147.                 //patchVertices[vertIndex] = lowLeft;
148.                 //patchVertices[vertIndex + 1] = topLeft;
149.                 //patchVertices[vertIndex + 2] = topRight;
150.                 //patchVertices[vertIndex + 3] = lowRight;
151.                 break;
152.         }
153.  
154.         CreatePatchObject(patchID, lowLeft, topLeft, topRight, lowRight, index, sX, sZ);
155.         //Increment the patchID number after the sub-patch has been created.
156.         patchID++;
157.         vertIndex += 4;
158.     }
159.  
160.     void CreatePatchObject(int id, Vector3 lowLeft, Vector3 topLeft, Vector3 topRight, Vector3 lowRight,  CubeIndex index, int sX, int sZ)
161.     {
162.         GameObject patchObject = new GameObject(id + " " + index + " PatchObject (" + sX + " , " + sZ + ")");
163.         patchObject.layer = gameObject.layer;
164.         patchObject.tag = gameObject.tag;
165.         patchObject.transform.parent = transform;
166.         patchObject.transform.position = transform.position;
167.    
168.         SurfacePatch patch = patchObject.AddComponent<SurfacePatch>();
169.         patch.InitPatchGenerator(lowLeft, topLeft, topRight, lowRight, this, index, null, sX, sZ);
170.         patch.GeneratePatchCoordinates(patchSubdivisions, patchResolution);
171.         patch.Add(patch);
172.     }
173.  
174.  
175.  
176.     /*private void OnDrawGizmos ()
177.     {
178.         if (patchVertices == null)
179.         {
180.             return;
181.         }
182.  
183.         for (int i = 0; i < patchVertices.Length; i++)
184.         {
185.             Gizmos.color = Color.black;
186.             Gizmos.DrawWireSphere(patchVertices[i], 0.0625f);
187.         }
188.         //Gizmos.color = Color.yellow;
189.         //Gizmos.DrawRay(vertices[i], normals[i]);
190.     }*/
191. }
192.  

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3.  
4. public class SurfacePatch : MonoBehaviour
5. {
6.     public Vector3 _lowLeft;
7.     public Vector3 _topLeft;
8.     public Vector3 _topRight;
9.     public Vector3 _lowRight;
10.  
11.     public Mesh patch;
12.  
13.     public ProceduralPlanet _planet;
14.     public SurfacePatch _parent;
15.     public ProceduralPlanet.CubeIndex _index;
16.     public int _sX, _sZ;
17.  
18.     float patchWidth;
19.     private Vector3[] patchVertices;
20.  
21.     private int vertIndex = 0;
22.     private int[] vertBuffer;
23.     private Vector2[] patchUV;
24.     private Vector3[] patchNormals;
25.  
26.     public void InitPatchGenerator(Vector3 lowLeft, Vector3 topLeft, Vector3 topRight, Vector3 lowRight, ProceduralPlanet planet, ProceduralPlanet.CubeIndex index, SurfacePatch parent, int sX, int sZ)
27.     {
28.         _planet = planet;
29.         _index = index;
30.         _parent = parent;
31.         _sX = sX;
32.         _sZ = sZ;
33.  
34.         _lowLeft = lowLeft;
35.         _topLeft = topLeft;
36.         _topRight = topRight;
37.         _lowRight = lowRight;
38.  
39.         if (patch == null)
40.         {
41.             MeshFilter meshFilter = gameObject.AddComponent<MeshFilter>();
42.             patch = meshFilter.sharedMesh = new Mesh();
43.  
44.             gameObject.AddComponent<MeshRenderer>();
45.             GetComponent<Renderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
46.             GetComponent<Renderer>().receiveShadows = true;
47.             GetComponent<Renderer>().enabled = true;
48.         }
49.     }
50.  
51.     public void GeneratePatchCoordinates(int patchSubdivisions, int patchResolution)
52.     {
53.         patchVertices = new Vector3[patchResolution * patchResolution];
54.         vertBuffer = new int[(patchResolution - 1) * (patchResolution - 1) * 6];
55.         patchUV = new Vector2[patchVertices.Length];
56.         patchNormals = new Vector3[patchVertices.Length];
57.  
58.         if (_index == ProceduralPlanet.CubeIndex.FRONT || _index == ProceduralPlanet.CubeIndex.BACK || _index == ProceduralPlanet.CubeIndex.TOP || _index == ProceduralPlanet.CubeIndex.BOTTOM)
59.         {
60.             patchWidth = _topRight.x - _lowLeft.x;
61.         }
62.  
63.         if (_index == ProceduralPlanet.CubeIndex.LEFT || _index == ProceduralPlanet.CubeIndex.RIGHT)
64.         {
65.             patchWidth = _topRight.z - _lowLeft.z;
66.         }
67.  
68.         float increment = patchWidth / (patchResolution - 1);
69.         float patchHalfWidth = ((patchResolution - 1) / patchWidth) * increment;
70.  
71.         for (int z = 0; z < patchResolution; z++)
72.         {
73.             float _z = z * increment;
74.             float _z1 = (z + 1) * increment;
75.  
76.             for (int x = 0; x < patchResolution; x++)
77.             {
78.                 float _x = x * increment;
79.                 float _x1 = (x + 1) * increment;
80.  
81.                 CreatePatchMesh(patchHalfWidth, _x, _x1, _z, _z1, patchSubdivisions, patchResolution);
82.             }
83.         }
84.     }
85.  
86.     private void CreatePatchMesh(float half, float x, float x1, float z, float z1, int subDiv, int resolution)
87.     {
88.         float xIncrement = ((float)_sX / (float)subDiv) * 2;
89.         float zIncrement = ((float)_sZ / (float)subDiv) * 2;
90.  
91.         switch(_index)
92.         {
93.             case ProceduralPlanet.CubeIndex.TOP:
94.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, _lowLeft.y, z - half + zIncrement);
95.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
96.                 patchVertices[vertIndex] *= _planet.planetRadius;
97.                 //Assign UV coordinates
98.                 patchUV[vertIndex] = new Vector2(x, z);
99.                 //Draw the triangles
100.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
101.                 {
102.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
103.                     {
104.                         vertBuffer[ti] = vi;
105.                         vertBuffer[ti + 1] = vi + resolution;
106.                         vertBuffer[ti + 2] = vi + 1;
107.  
108.                         vertBuffer[ti + 3] = vi + resolution;
109.                         vertBuffer[ti + 4] = vi + resolution + 1;
110.                         vertBuffer[ti + 5] = vi + 1;
111.                     }
112.                 }
113.                 break;
114.  
115.             case ProceduralPlanet.CubeIndex.BOTTOM:
116.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, _lowLeft.y, z - half + zIncrement);
117.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
118.                 patchVertices[vertIndex] *= _planet.planetRadius;
119.                 //Assign UV coordinates
120.                 patchUV[vertIndex] = new Vector2(x, z);
121.                 //Draw the triangles
122.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
123.                 {
124.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
125.                     {
126.                         vertBuffer[ti] = vi + 1;
127.                         vertBuffer[ti + 1] = vi + resolution;
128.                         vertBuffer[ti + 2] = vi;
129.  
130.                         vertBuffer[ti + 3] = vi + 1;
131.                         vertBuffer[ti + 4] = vi + resolution + 1;
132.                         vertBuffer[ti + 5] = vi + resolution;
133.                     }
134.                 }
135.                 break;
136.  
137.             case ProceduralPlanet.CubeIndex.FRONT:
138.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, z - half + zIncrement, _lowLeft.z);
139.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
140.                 patchVertices[vertIndex] *= _planet.planetRadius;
141.                 //Assign UV coordinates
142.                 patchUV[vertIndex] = new Vector2(x, z);
143.                 //Draw the triangles
144.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
145.                 {
146.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
147.                     {
148.                         vertBuffer[ti] = vi + 1;
149.                         vertBuffer[ti + 1] = vi + resolution;
150.                         vertBuffer[ti + 2] = vi;
151.  
152.                         vertBuffer[ti + 3] = vi + 1;
153.                         vertBuffer[ti + 4] = vi + resolution + 1;
154.                         vertBuffer[ti + 5] = vi + resolution;
155.                     }
156.                 }
157.                 break;
158.        
159.             case ProceduralPlanet.CubeIndex.BACK:
160.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, z - half + zIncrement, _lowLeft.z);
161.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
162.                 patchVertices[vertIndex] *= _planet.planetRadius;
163.                 //Assign UV coordinates
164.                 patchUV[vertIndex] = new Vector2(x, z);
165.                 //Draw the triangles
166.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
167.                 {
168.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
169.                     {
170.                         vertBuffer[ti] = vi;
171.                         vertBuffer[ti + 1] = vi + resolution;
172.                         vertBuffer[ti + 2] = vi + 1;
173.  
174.                         vertBuffer[ti + 3] = vi + resolution;
175.                         vertBuffer[ti + 4] = vi + resolution + 1;
176.                         vertBuffer[ti + 5] = vi + 1;
177.                     }
178.                 }
179.                 break;
180.  
181.             case ProceduralPlanet.CubeIndex.LEFT:
182.                 patchVertices[vertIndex] = new Vector3(_lowLeft.x, x - half + zIncrement, -half + z + xIncrement);
183.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
184.                 patchVertices[vertIndex] *= _planet.planetRadius;
185.                 //Assign UV coordinates
186.                 patchUV[vertIndex] = new Vector2(x, z);
187.                 //Draw the triangles
188.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
189.                 {
190.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
191.                     {
192.                         vertBuffer[ti] = vi;
193.                         vertBuffer[ti + 1] = vi + resolution;
194.                         vertBuffer[ti + 2] = vi + 1;
195.  
196.                         vertBuffer[ti + 3] = vi + resolution;
197.                         vertBuffer[ti + 4] = vi + resolution + 1;
198.                         vertBuffer[ti + 5] = vi + 1;
199.                     }
200.                 }
201.                 break;
202.  
203.             case ProceduralPlanet.CubeIndex.RIGHT:
204.                 patchVertices[vertIndex] = new Vector3(_lowLeft.x, x - half + zIncrement, -half + z + xIncrement);
205.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
206.                 patchVertices[vertIndex] *= _planet.planetRadius;
207.                 //Assign UV coordinates
208.                 patchUV[vertIndex] = new Vector2(x, z);
209.                 //Draw the triangles
210.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
211.                 {
212.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
213.                     {
214.                         vertBuffer[ti] = vi + 1;
215.                         vertBuffer[ti + 1] = vi + resolution;
216.                         vertBuffer[ti + 2] = vi;
217.  
218.                         vertBuffer[ti + 3] = vi + 1;
219.                         vertBuffer[ti + 4] = vi + resolution + 1;
220.                         vertBuffer[ti + 5] = vi + resolution;
221.                     }
222.                 }
223.                 break;
224.         }
225.  
226.         patch.vertices = patchVertices;
227.         patch.uv = patchUV;
228.         patch.triangles = vertBuffer;
229.         patch.RecalculateNormals();
230.  
231.         vertIndex++;
232.     }
233.  
234.     public void Add(SurfacePatch patch)
235.     {
236.  
237.     }
238.  
239.     public static Vector3 MapToSphere(Vector3 point)
240.     {
241.         float dX2, dY2, dZ2;
242.         float dX2Half, dY2Half, dZ2Half;
243.  
244.         dX2 = point.x * point.x;
245.         dY2 = point.y * point.y;
246.         dZ2 = point.z * point.z;
247.  
248.         dX2Half = dX2 * 0.5f;
249.         dY2Half = dY2 * 0.5f;
250.         dZ2Half = dZ2 * 0.5f;
251.  
252.         point.x = point.x * Mathf.Sqrt(1f - dY2Half - dZ2Half + (dY2 * dZ2) * (1f / 3f));
253.         point.y = point.y * Mathf.Sqrt(1f - dZ2Half - dX2Half + (dZ2 * dX2) * (1f / 3f));
254.         point.z = point.z * Mathf.Sqrt(1f - dX2Half - dY2Half + (dX2 * dY2) * (1f / 3f));
255.  
256.         return point;
257.     }
258.  
259.     /*private void OnDrawGizmos()
260.     {
261.         if (patchVertices == null)
262.         {
263.             return;
264.         }
265.  
266.         for (int i = 0; i < patchVertices.Length; i++)
267.         {
268.             if (_index == ProceduralPlanet.CubeIndex.TOP)
269.             {
270.                 Gizmos.color = Color.red;
271.             }
272.  
273.             if (_index == ProceduralPlanet.CubeIndex.BOTTOM)
274.             {
275.                 Gizmos.color = Color.magenta;
276.             }
277.  
278.             if (_index == ProceduralPlanet.CubeIndex.FRONT)
279.             {
280.                 Gizmos.color = Color.green;
281.             }
282.  
283.             if (_index == ProceduralPlanet.CubeIndex.BACK)
284.             {
285.                 Gizmos.color = Color.blue;
286.             }
287.  
288.             Gizmos.DrawSphere(patchVertices[i], 0.0125f);
289.         }
290.         //Gizmos.color = Color.yellow;
291.         //Gizmos.DrawRay(vertices[i], normals[i]);
292.     }*/
293. }
294.  

V/R

Brad

 

Forgot...the relevant code is located in the CreatePatchMesh function in the case statements.

 

Well, good news! I solved the UV issue I was having, but now I'm having issues applying the perlin noise as a height modifier to my vertices...Here is a screen shot of what's going on and also the most current code. Any help would be awesome! I suspect the issue lies in how I'm handling stepping through the texture to find the height info...The first tile on the top part of the sphere has zero deformation and then the tile to the right of it looks kind of right...but not really. You can see the craziness of the other tiles as well. Any help sorting this out would be great!

Code (CSharp):

1. using UnityEngine;
2. using System.Collections.Generic;
3. using System;
4. using LibNoise;
5. using LibNoise.Generator;
6. using LibNoise.Operator;
7.  
8.  
9.  
10. public class ProceduralPlanet : MonoBehaviour
11. {
12.     //Define the number of Subdivions for patch side.
13.     public int patchSubdivisions = 1;
14.     //Define the number of vertices per of each patch segment.
15.     public int patchResolution = 2;
16.     //Define the planets radius
17.     public int planetRadius = 10;
18.  
19.     public float xOrg = 10.0f;
20.     public float yOrg = 10.0f;
21.     public float scale = 1.0f;
22.     public int textureSize = 128;
23.  
24.     //public Vector3[] patchVertices;
25.  
26.     private int patchID = 0;
27.     //private int vertIndex = 0;
28.  
29.     public enum CubeIndex { TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT }
30.  
31.     private Material baseMaterial;
32.     public Texture2D[] textures = new Texture2D[6];
33.     Color[] pixelColor;
34.  
35.     public List<SurfacePatch> surfacePatches = new List<SurfacePatch>();
36.  
37.     void Start()
38.     {
39.         pixelColor = new Color[textureSize * textureSize];
40.         //patchVertices = new Vector3[((patchSubdivisions * patchSubdivisions) * 4) * 6];
41.         // First we have define our dimensions:
42.         //          +Z
43.         //   -1,1    |    1,1
44.         //      +----|----+
45.         //      |    |    |
46.         //-X --------0-------- +X
47.         //      |    |    |
48.         //      +----|----+
49.         //  -1,-1    |    1,-1
50.         //          -Z
51.         //
52.         // First we have to figure out what our distance increment is going to be. Since we
53.         // know that our total width is 2 we can figure that out using the following:
54.         float increment = 2.0f / patchSubdivisions;
55.         // We can then find the patchHalfWidth using the following:
56.         float patchHalfWidth = (patchSubdivisions / 2.0f) * increment;
57.         //Next we plot the vertices for all of the sub-patches:
58.         if (patchSubdivisions > 0)
59.         {
60.             //Loop through the 'z' positions
61.             for (int z = 0; z < patchSubdivisions; z++)
62.             {
63.                 //Each time through we define the starting 'z' position for each sub-patch and the
64.                 //next 'z' position of the sub-patch.
65.                 float _z  = z * increment;
66.                 float _z1 = (z + 1) * increment;
67.                
68.                 for (int x = 0; x < patchSubdivisions; x++)
69.                 {
70.                     //Each time through we define the starting 'z' position for each sub-patch and the
71.                     //next 'z' position of the sub-patch.
72.                     float _x  = x * increment;
73.                     float _x1 = (x + 1) * increment;
74.  
75.                     //Pass our generated data to CreateSubPatch which then defines the coordinates for
76.                     //each side of the Cube.
77.                     for (int i = 0; i < 6; i++)
78.                     {
79.                         CreatePatch(patchHalfWidth, _x, _x1, _z, _z1, (CubeIndex)i, x, z);
80.                     }                      
81.                 }              
82.             }
83.         }
84.     }
85.  
86.     void CreatePatch(float half, float x, float x1, float z, float z1,  CubeIndex index, int sX, int sZ)
87.     {
88.         //A Vector Array to hold our Patch Vertices...
89.         Vector3 lowLeft  = Vector3.zero;
90.         Vector3 topLeft  = Vector3.zero;
91.         Vector3 topRight = Vector3.zero;
92.         Vector3 lowRight = Vector3.zero;
93.  
94.         switch (index)
95.         {
96.             case CubeIndex.TOP:
97.                 lowLeft = new Vector3(x - half, half, z - half);
98.                 topLeft = new Vector3(x - half, half, z1 - half);
99.                 topRight = new Vector3(x1 - half, half, z1 - half);
100.                 lowRight = new Vector3(x1 - half, half, z - half);
101.  
102.                 //patchVertices[vertIndex] = lowLeft;
103.                 //patchVertices[vertIndex + 1] = topLeft;
104.                 //patchVertices[vertIndex + 2] = topRight;
105.                 //patchVertices[vertIndex + 3] = lowRight;
106.                 break;
107.  
108.             case CubeIndex.BOTTOM:
109.                 lowLeft = new Vector3(x - half, -half, z - half);
110.                 topLeft = new Vector3(x - half, -half, z1 - half);
111.                 topRight = new Vector3(x1 - half, -half, z1 - half);
112.                 lowRight = new Vector3(x1 - half, -half, z - half);
113.                
114.                 //patchVertices[vertIndex] = lowLeft;
115.                 //patchVertices[vertIndex + 1] = topLeft;
116.                 //patchVertices[vertIndex + 2] = topRight;
117.                 //patchVertices[vertIndex + 3] = lowRight;
118.                 break;
119.  
120.             case CubeIndex.FRONT:
121.                 lowLeft = new Vector3(x - half, half - x1, half);
122.                 topLeft = new Vector3(x - half, half - z, half);
123.                 topRight = new Vector3(x1 - half, half - z, half);
124.                 lowRight = new Vector3(x1 - half, half - z1, half);
125.                                
126.                 //patchVertices[vertIndex] = lowLeft;
127.                 //patchVertices[vertIndex + 1] = topLeft;
128.                 //patchVertices[vertIndex + 2] = topRight;
129.                 //patchVertices[vertIndex + 3] = lowRight;
130.                 break;
131.  
132.             case CubeIndex.BACK:
133.                 lowLeft = new Vector3(x - half, half - x1, -half);
134.                 topLeft = new Vector3(x - half, half - z, -half);
135.                 topRight = new Vector3(x1 - half, half - z, -half);
136.                 lowRight = new Vector3(x1 - half, half - z1, -half);
137.                                
138.                 //patchVertices[vertIndex] = lowLeft;
139.                 //patchVertices[vertIndex + 1] = topLeft;
140.                 //patchVertices[vertIndex + 2] = topRight;
141.                 //patchVertices[vertIndex + 3] = lowRight;
142.                 break;
143.  
144.             case CubeIndex.LEFT:
145.                 lowLeft = new Vector3(-half, half - x1, -half + x);
146.                 topLeft = new Vector3(-half, half - z, -half + x);
147.                 topRight = new Vector3(-half, half - z, -half + x1);
148.                 lowRight = new Vector3(-half, half - z1, -half + x1);
149.                                
150.                 //patchVertices[vertIndex] = lowLeft;
151.                 //patchVertices[vertIndex + 1] = topLeft;
152.                 //patchVertices[vertIndex + 2] = topRight;
153.                 //patchVertices[vertIndex + 3] = lowRight;
154.                 break;
155.  
156.             case CubeIndex.RIGHT:
157.                 lowLeft = new Vector3(half, half - x1, -half + x);
158.                 topLeft = new Vector3(half, half - z, -half + x);
159.                 topRight = new Vector3(half, half - z, -half + x1);
160.                 lowRight = new Vector3(half, half - z1, -half + x1);
161.                                
162.                 //patchVertices[vertIndex] = lowLeft;
163.                 //patchVertices[vertIndex + 1] = topLeft;
164.                 //patchVertices[vertIndex + 2] = topRight;
165.                 //patchVertices[vertIndex + 3] = lowRight;
166.                 break;
167.         }
168.  
169.         CreatePatchObject(patchID, lowLeft, topLeft, topRight, lowRight, index, sX, sZ);
170.         //Increment the patchID number after the sub-patch has been created.
171.         patchID++;
172.         //vertIndex += 4;
173.     }
174.  
175.     void CreatePatchObject(int id, Vector3 lowLeft, Vector3 topLeft, Vector3 topRight, Vector3 lowRight,  CubeIndex index, int sX, int sZ)
176.     {
177.         GameObject patchObject = new GameObject(id + " " + index + " PatchObject (" + sX + " , " + sZ + ")");
178.         patchObject.layer = gameObject.layer;
179.         patchObject.tag = gameObject.tag;
180.         patchObject.transform.parent = transform;
181.         patchObject.transform.position = transform.position;
182.         //Add a MeshRenderer to access Renderer functions
183.         patchObject.gameObject.AddComponent<MeshRenderer>();
184.         //patchObject.GetComponent<Renderer>().material = base.GetComponent<Renderer>().material;
185.         //Add a MeshCollider for Collision purposes
186.         patchObject.AddComponent<MeshCollider>();
187.  
188.         for (int i = 0; i < 6; i++)
189.         {
190.             textures[i] = new Texture2D(textureSize, textureSize);
191.  
192.             float y = 0.0f;
193.             while (y < textureSize)
194.             {
195.                 float x = 0.0f;
196.                 while (x < textureSize)
197.                 {
198.                     float xCoord = xOrg + x / textureSize * scale;
199.                     float yCoord = xOrg + y / textureSize * scale;
200.                     float sample = Mathf.PerlinNoise(xCoord, yCoord);
201.                     pixelColor[(int)y * textureSize + (int)x] = new Color(sample, sample, sample);
202.                     x++;
203.                 }
204.                 y++;
205.             }
206.             textures[i].SetPixels(pixelColor);
207.             textures[i].Apply();
208.         }
209.  
210.         switch (index)
211.         {
212.             case CubeIndex.TOP:
213.                 patchObject.gameObject.GetComponent<Renderer>().material.mainTexture = textures[0];
214.                 break;
215.  
216.             case CubeIndex.BOTTOM:
217.                 patchObject.gameObject.GetComponent<Renderer>().material.mainTexture = textures[1];
218.                 break;
219.  
220.             case CubeIndex.FRONT:
221.                 patchObject.gameObject.GetComponent<Renderer>().material.mainTexture = textures[2];
222.                 break;
223.  
224.             case CubeIndex.BACK:
225.                 patchObject.gameObject.GetComponent<Renderer>().material.mainTexture = textures[3];
226.                 break;
227.  
228.             case CubeIndex.LEFT:
229.                 patchObject.gameObject.GetComponent<Renderer>().material.mainTexture = textures[4];
230.                 break;
231.  
232.             case CubeIndex.RIGHT:
233.                 patchObject.gameObject.GetComponent<Renderer>().material.mainTexture = textures[5];
234.                 break;
235.         }
236.  
237.         SurfacePatch patch = patchObject.AddComponent<SurfacePatch>();
238.         //Initialize the patch generator with the coordinates generated in Start
239.         patch.InitPatchGenerator(lowLeft, topLeft, topRight, lowRight, this, index, null, sX, sZ);
240.         //Generate the coordinates for the patch based on the sub-division level and resolution
241.         patch.GeneratePatchCoordinates(patchSubdivisions, patchResolution);
242.         //patch.Add(patch);
243.         //After the Patch has been created, assign that patch to this objects MeshCollider
244.         patchObject.GetComponent<MeshCollider>().sharedMesh = patch.ReturnMesh();
245.     }
246.  
247.     /*private void OnDrawGizmos ()
248.     {
249.         if (patchVertices == null)
250.         {
251.             return;
252.         }
253.  
254.         for (int i = 0; i < patchVertices.Length; i++)
255.         {
256.             Gizmos.color = Color.black;
257.             Gizmos.DrawWireSphere(patchVertices[i], 0.0625f);
258.         }
259.         //Gizmos.color = Color.yellow;
260.         //Gizmos.DrawRay(vertices[i], normals[i]);
261.     }*/
262. }
263.  

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3.  
4. public class SurfacePatch : MonoBehaviour
5. {
6.     private Vector3 _lowLeft;
7.     private Vector3 _topLeft;
8.     private Vector3 _topRight;
9.     private Vector3 _lowRight;
10.  
11.     private Mesh patch;
12.  
13.     private ProceduralPlanet _planet;
14.     private SurfacePatch _parent;
15.     private ProceduralPlanet.CubeIndex _index;
16.     private int _sX, _sZ;
17.  
18.     private float patchWidth;
19.     private Vector3[] patchVertices;
20.  
21.     private int vertIndex = 0;
22.     private int[] vertBuffer;
23.     private Vector2[] patchUV;
24.     private Vector3[] patchNormals;
25.  
26.     private float uvResolution;
27.     private float uvXIncrement;
28.     private float uvZIncrement;
29.  
30.     int k = 0;
31.     int l = 0;
32.  
33.     public void InitPatchGenerator(Vector3 lowLeft, Vector3 topLeft, Vector3 topRight, Vector3 lowRight, ProceduralPlanet planet, ProceduralPlanet.CubeIndex index, SurfacePatch parent, int sX, int sZ)
34.     {
35.         _planet = planet;
36.         _index = index;
37.         _parent = parent;
38.         _sX = sX;
39.         _sZ = sZ;
40.  
41.         _lowLeft = lowLeft;
42.         _topLeft = topLeft;
43.         _topRight = topRight;
44.         _lowRight = lowRight;
45.  
46.         if (patch == null)
47.         {
48.             MeshFilter meshFilter = gameObject.AddComponent<MeshFilter>();
49.             patch = meshFilter.sharedMesh = new Mesh();
50.  
51.             GetComponent<Renderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
52.             GetComponent<Renderer>().receiveShadows = true;
53.             GetComponent<Renderer>().enabled = true;
54.         }
55.     }
56.  
57.     public void GeneratePatchCoordinates(int patchSubdivisions, int patchResolution)
58.     {
59.         patchVertices = new Vector3[patchResolution * patchResolution];
60.         vertBuffer = new int[(patchResolution - 1) * (patchResolution - 1) * 6];
61.         patchUV = new Vector2[patchVertices.Length];
62.         patchNormals = new Vector3[patchVertices.Length];
63.  
64.         if (_index == ProceduralPlanet.CubeIndex.FRONT || _index == ProceduralPlanet.CubeIndex.BACK || _index == ProceduralPlanet.CubeIndex.TOP || _index == ProceduralPlanet.CubeIndex.BOTTOM)
65.         {
66.             patchWidth = _topRight.x - _lowLeft.x;
67.         }
68.  
69.         if (_index == ProceduralPlanet.CubeIndex.LEFT || _index == ProceduralPlanet.CubeIndex.RIGHT)
70.         {
71.             patchWidth = _topRight.z - _lowLeft.z;
72.         }
73.  
74.         float increment = patchWidth / (patchResolution - 1);
75.         float patchHalfWidth = ((patchResolution - 1) / patchWidth) * increment;
76.  
77.         for (int z = 0; z < patchResolution; z++)
78.         {
79.             float _z = z * increment;
80.             float _z1 = (z + 1) * increment;
81.  
82.             for (int x = 0; x < patchResolution; x++)
83.             {
84.                 float _x = x * increment;
85.                 float _x1 = (x + 1) * increment;
86.  
87.                 CreatePatchMesh(patchHalfWidth, _x, _x1, _z, _z1, patchSubdivisions, patchResolution);
88.             }
89.         }
90.     }
91.  
92.     private void CreatePatchMesh(float half, float x, float x1, float z, float z1, int subDiv, int resolution)
93.     {
94.         float xIncrement = ((float)_sX / (float)subDiv) * 2;
95.         float zIncrement = ((float)_sZ / (float)subDiv) * 2;
96.  
97.         uvXIncrement = _sX * (1.0f / subDiv);
98.         uvZIncrement = _sZ * (1.0f / subDiv);
99.  
100.         int texXIncrement = _sX * ((_planet.textureSize / subDiv) / resolution);
101.         int texZIncrement = _sZ * ((_planet.textureSize / subDiv) / resolution);
102.         float noise = 0;
103.         float noiseBase = _planet.planetRadius;
104.  
105.         switch(_index)
106.         {
107.             case ProceduralPlanet.CubeIndex.TOP:
108.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, _lowLeft.y, z - half + zIncrement);
109.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
110.  
111.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvXIncrement , (z / 2f) + uvZIncrement);
112.                 //Draw the triangles
113.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
114.                 {
115.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
116.                     {
117.                         vertBuffer[ti] = vi;
118.                         vertBuffer[ti + 1] = vi + resolution;
119.                         vertBuffer[ti + 2] = vi + 1;
120.  
121.                         vertBuffer[ti + 3] = vi + resolution;
122.                         vertBuffer[ti + 4] = vi + resolution + 1;
123.                         vertBuffer[ti + 5] = vi + 1;
124.                     }
125.                 }
126.                 noise = _planet.textures[0].GetPixel(l * texXIncrement, k * texZIncrement).grayscale * 0.5f;
127.                 //noise = Mathf.Clamp(noise, (_planet.planetRadius + noise + 1.0f), _planet.planetRadius + noise + 1.0f);
128.  
129.                 patchVertices[vertIndex] *= _planet.planetRadius + noise;
130.  
131.                 patch.name = "TOP (" + _sX + "," + _sZ + ")";
132.                 break;
133.  
134.             case ProceduralPlanet.CubeIndex.BOTTOM:
135.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, _lowLeft.y, z - half + zIncrement);
136.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
137.              
138.                 //Assign UV coordinates
139.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvXIncrement, (z / 2f) + uvZIncrement);
140.                 //Draw the triangles
141.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
142.                 {
143.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
144.                     {
145.                         vertBuffer[ti] = vi + 1;
146.                         vertBuffer[ti + 1] = vi + resolution;
147.                         vertBuffer[ti + 2] = vi;
148.  
149.                         vertBuffer[ti + 3] = vi + 1;
150.                         vertBuffer[ti + 4] = vi + resolution + 1;
151.                         vertBuffer[ti + 5] = vi + resolution;
152.                     }
153.                 }
154.                 noise = _planet.textures[0].GetPixel(k * texXIncrement, l * texZIncrement).grayscale * 0.5f;
155.                 //noise = Mathf.Clamp(noise, _planet.planetWaterLevel * (_planet.planetRadius + noise + 1.0f), _planet.planetRadius + noise + 1.0f);
156.  
157.                 patchVertices[vertIndex] *= _planet.planetRadius + noise;
158.  
159.                 patch.name = "BOTTOM (" + _sX + "," + _sZ + ")";
160.                 break;
161.  
162.             case ProceduralPlanet.CubeIndex.FRONT:
163.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, z - half + zIncrement, _lowLeft.z);
164.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
165.  
166.                 //Assign UV coordinates
167.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvXIncrement, (z / 2f) + uvZIncrement);
168.                 //Draw the triangles
169.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
170.                 {
171.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
172.                     {
173.                         vertBuffer[ti] = vi + 1;
174.                         vertBuffer[ti + 1] = vi + resolution;
175.                         vertBuffer[ti + 2] = vi;
176.  
177.                         vertBuffer[ti + 3] = vi + 1;
178.                         vertBuffer[ti + 4] = vi + resolution + 1;
179.                         vertBuffer[ti + 5] = vi + resolution;
180.                     }
181.                 }
182.                 noise = _planet.textures[0].GetPixel(k * texXIncrement, l * texZIncrement).grayscale * 0.5f;
183.                 //noise = Mathf.Clamp(noise, _planet.planetWaterLevel * (_planet.planetRadius + noise + 1.0f), _planet.planetRadius + noise + 1.0f);
184.  
185.                 patchVertices[vertIndex] *= _planet.planetRadius + noise;
186.  
187.                 patch.name = "FRONT (" + _sX + "," + _sZ + ")";
188.                 break;
189.            
190.             case ProceduralPlanet.CubeIndex.BACK:
191.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, z - half + zIncrement, _lowLeft.z);
192.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
193.  
194.                 //Assign UV coordinates
195.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvXIncrement, (z / 2f) + uvZIncrement);
196.                 //Draw the triangles
197.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
198.                 {
199.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
200.                     {
201.                         vertBuffer[ti] = vi;
202.                         vertBuffer[ti + 1] = vi + resolution;
203.                         vertBuffer[ti + 2] = vi + 1;
204.  
205.                         vertBuffer[ti + 3] = vi + resolution;
206.                         vertBuffer[ti + 4] = vi + resolution + 1;
207.                         vertBuffer[ti + 5] = vi + 1;
208.                     }
209.                 }
210.                 noise = _planet.textures[0].GetPixel(k * texXIncrement, l * texZIncrement).grayscale;
211.                 //noise = Mathf.Clamp(noise, _planet.planetRadius + noise, _planet.planetRadius + noise + 1.0f);
212.    
213.                 patchVertices[vertIndex] *= _planet.planetRadius + noise;
214.  
215.                 patch.name = "BACK (" + _sX + "," + _sZ + ")";
216.                 break;
217.  
218.             case ProceduralPlanet.CubeIndex.LEFT:
219.                 patchVertices[vertIndex] = new Vector3(_lowLeft.x, x - half + zIncrement, -half + z + xIncrement);
220.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
221.  
222.                 //Assign UV coordinates
223.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvZIncrement, (z / 2f) + uvXIncrement);
224.                 //Draw the triangles
225.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
226.                 {
227.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
228.                     {
229.                         vertBuffer[ti] = vi;
230.                         vertBuffer[ti + 1] = vi + resolution;
231.                         vertBuffer[ti + 2] = vi + 1;
232.  
233.                         vertBuffer[ti + 3] = vi + resolution;
234.                         vertBuffer[ti + 4] = vi + resolution + 1;
235.                         vertBuffer[ti + 5] = vi + 1;
236.                     }
237.                 }
238.                 noise = _planet.textures[0].GetPixel(k * texXIncrement, l * texZIncrement).grayscale * 0.5f;
239.                 //noise = Mathf.Clamp(noise, _planet.planetWaterLevel * (_planet.planetRadius + noise + 1.0f), _planet.planetRadius + noise + 1.0f);
240.  
241.                 patchVertices[vertIndex] *= _planet.planetRadius + noise;
242.  
243.                 patch.name = "LEFT (" + _sX + "," + _sZ + ")";
244.                 break;
245.  
246.             case ProceduralPlanet.CubeIndex.RIGHT:
247.                 patchVertices[vertIndex] = new Vector3(_lowLeft.x, x - half + zIncrement, -half + z + xIncrement);
248.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
249.                
250.                 //Assign UV coordinates
251.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvZIncrement, (z / 2f) + uvXIncrement);
252.                 //Draw the triangles
253.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
254.                 {
255.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
256.                     {
257.                         vertBuffer[ti] = vi + 1;
258.                         vertBuffer[ti + 1] = vi + resolution;
259.                         vertBuffer[ti + 2] = vi;
260.  
261.                         vertBuffer[ti + 3] = vi + 1;
262.                         vertBuffer[ti + 4] = vi + resolution + 1;
263.                         vertBuffer[ti + 5] = vi + resolution;
264.                     }
265.                 }
266.                 noise = _planet.textures[0].GetPixel(k * texXIncrement, l * texZIncrement).grayscale * 2.5f;
267.                 //noise = Mathf.Clamp(noise, _planet.planetWaterLevel * (_planet.planetRadius + noise + 1.0f), _planet.planetRadius + noise + 1.0f);
268.  
269.                 patchVertices[vertIndex] *= _planet.planetRadius + noise;
270.  
271.                 patch.name = "RIGHT (" + _sX + "," + _sZ + ")";
272.                 break;
273.         }
274.  
275.         patch.vertices = patchVertices;
276.         patch.uv = patchUV;
277.         patch.triangles = vertBuffer;
278.         patch.RecalculateNormals();
279.  
280.         vertIndex++;
281.         k++;
282.         l++;
283.     }
284.  
285.     public void Add(SurfacePatch patch)
286.     {
287.  
288.     }
289.  
290.     public Mesh ReturnMesh()
291.     {
292.         return patch;
293.     }
294.  
295.     public static Vector3 MapToSphere(Vector3 point)
296.     {
297.         float dX2, dY2, dZ2;
298.         float dX2Half, dY2Half, dZ2Half;
299.  
300.         dX2 = point.x * point.x;
301.         dY2 = point.y * point.y;
302.         dZ2 = point.z * point.z;
303.  
304.         dX2Half = dX2 * 0.5f;
305.         dY2Half = dY2 * 0.5f;
306.         dZ2Half = dZ2 * 0.5f;
307.  
308.         point.x = point.x * Mathf.Sqrt(1f - dY2Half - dZ2Half + (dY2 * dZ2) * (1f / 3f));
309.         point.y = point.y * Mathf.Sqrt(1f - dZ2Half - dX2Half + (dZ2 * dX2) * (1f / 3f));
310.         point.z = point.z * Mathf.Sqrt(1f - dX2Half - dY2Half + (dX2 * dY2) * (1f / 3f));
311.  
312.         return point;
313.     }
314.  
315.     /*private void OnDrawGizmos()
316.     {
317.         if (patchVertices == null)
318.         {
319.             return;
320.         }
321.  
322.         for (int i = 0; i < patchVertices.Length; i++)
323.         {
324.             if (_index == ProceduralPlanet.CubeIndex.TOP)
325.             {
326.                 Gizmos.color = Color.red;
327.             }
328.  
329.             if (_index == ProceduralPlanet.CubeIndex.BOTTOM)
330.             {
331.                 Gizmos.color = Color.magenta;
332.             }
333.  
334.             if (_index == ProceduralPlanet.CubeIndex.FRONT)
335.             {
336.                 Gizmos.color = Color.green;
337.             }
338.  
339.             if (_index == ProceduralPlanet.CubeIndex.BACK)
340.             {
341.                 Gizmos.color = Color.blue;
342.             }
343.  
344.             Gizmos.DrawSphere(patchVertices[i], 0.0125f);
345.         }
346.         //Gizmos.color = Color.yellow;
347.         //Gizmos.DrawRay(vertices[i], normals[i]);
348.     }*/
349. }
350.  

 

Bump...

So this is what I've got implemented so far:

Code (CSharp):

1.         int texXIncrement = _sX * ((_planet.textureSize / subDiv) / resolution);
2.         int texZIncrement = _sZ * ((_planet.textureSize / subDiv) / resolution);
3.         float noise = 0;
4.         float noiseBase = _planet.planetRadius;

Code (CSharp):

1.  
2.                 noise = _planet.textures[0].GetPixel(l * texXIncrement, k * texZIncrement).grayscale * 0.5f;
3.                 //noise = Mathf.Clamp(noise, (_planet.planetRadius + noise + 1.0f), _planet.planetRadius + noise + 1.0f);
4.                 patchVertices[vertIndex] *= _planet.planetRadius + noise;

Code (CSharp):

1.         patch.vertices = patchVertices;
2.         patch.uv = patchUV;
3.         patch.triangles = vertBuffer;
4.         patch.RecalculateNormals();
5.         vertIndex++;
6.         k++;
7.         l++;

The idea is that the texture covers one full side of the cube that makes up the sphere. It's resolution is defined by the user. Since the texture is a fixed size, I figure out how many pixels each vertex needs to move and sample. So that takes into account first the number of subdivisions currently implemented and then the number of vertices per subdivision surface. This is then put into GetPixel. Each time through the switch it then increments the current vertex....But from looking at the results it's definitely not working as intended. Anyone see anything glaringly obvious in the code?

 

I made the following adjustments to my code and got the following:



So...i'm a little bit closer, now I just need to get the sides of each patch to line up...at least the depth corresponds to the height map now....here's the relevant lines of code updated...if anyone has any ideas what I'm still doing wrong, please chime in!

Code (CSharp):

1.     private void CreatePatchMesh(float half, float x, float x1, float z, float z1, int subDiv, int resolution)
2.     {
3.         float xIncrement = ((float)_sX / (float)subDiv) * 2;
4.         float zIncrement = ((float)_sZ / (float)subDiv) * 2;
5.  
6.         uvXIncrement = _sX * (1.0f / subDiv);
7.         uvZIncrement = _sZ * (1.0f / subDiv);
8.  
9.         //int texXIncrement = _sX * ((_planet.textureSize / subDiv) / resolution);
10.         //int texZIncrement = _sZ * ((_planet.textureSize / subDiv) / resolution);
11.         int texXIncrement = ((_planet.textureSize / subDiv) / resolution);
12.         int texZIncrement = ((_planet.textureSize / subDiv) / resolution);
13.         float[] noise = new float[patchVertices.Length];
14.         float noiseBase = _planet.planetRadius;
15.  
16.         switch(_index)
17.         {
18.             case ProceduralPlanet.CubeIndex.TOP:
19.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, _lowLeft.y, z - half + zIncrement);
20.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
21.                 //patchVertices[vertIndex].Normalize();
22.  
23.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvXIncrement , (z / 2f) + uvZIncrement);
24.                 //Draw the triangles
25.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
26.                 {
27.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
28.                     {
29.                         vertBuffer[ti] = vi;
30.                         vertBuffer[ti + 1] = vi + resolution;
31.                         vertBuffer[ti + 2] = vi + 1;
32.  
33.                         vertBuffer[ti + 3] = vi + resolution;
34.                         vertBuffer[ti + 4] = vi + resolution + 1;
35.                         vertBuffer[ti + 5] = vi + 1;
36.                     }
37.                 }
38.                 for (int a = 0, b = 0; a < resolution; a++)
39.                 {
40.                     for (int c = 0; c < resolution; c++, b++)
41.                     {
42.                         noise[b] = _planet.textures[0].GetPixel(c * texXIncrement, a * texZIncrement).grayscale;
43.                         //noise[b] = Mathf.Clamp(noise[b], _planet.planetRadius + noise[b] + 1.0f, _planet.planetRadius + noise[b] + 1.0f);
44.                     }
45.                 }
46.                
47.  
48.                 patchVertices[vertIndex] *= _planet.planetRadius + noise[vertIndex];
49.                 //patchVertices[vertIndex] *= _planet.planetRadius;
50.  
51.                 patch.name = "TOP (" + _sX + "," + _sZ + ")";
52.                 break;

 

So no one has any insight into why this isn't working as it's supposed to? I've double checked my math using excel to ensure everything is correct implementation wise...but I'm still getting disjointed patches. Here's the most up to date code:

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3.  
4. public class SurfacePatch : MonoBehaviour
5. {
6.     private Vector3 _lowLeft;
7.     private Vector3 _topLeft;
8.     private Vector3 _topRight;
9.     private Vector3 _lowRight;
10.  
11.     private Mesh patch;
12.  
13.     private ProceduralPlanet _planet;
14.     private SurfacePatch _parent;
15.     private ProceduralPlanet.CubeIndex _index;
16.     private int _sX, _sZ;
17.  
18.     private float patchWidth;
19.     private Vector3[] patchVertices;
20.  
21.     private int vertIndex = 0;
22.     private int[] vertBuffer;
23.     private Vector2[] patchUV;
24.     private Vector3[] patchNormals;
25.  
26.     private float uvResolution;
27.     private float uvXIncrement;
28.     private float uvZIncrement;
29.     public float[] noise;
30.  
31.  
32.     public void InitPatchGenerator(Vector3 lowLeft, Vector3 topLeft, Vector3 topRight, Vector3 lowRight, ProceduralPlanet planet, ProceduralPlanet.CubeIndex index, SurfacePatch parent, int sX, int sZ)
33.     {
34.         _planet = planet;
35.         _index = index;
36.         _parent = parent;
37.         _sX = sX;
38.         _sZ = sZ;
39.  
40.         _lowLeft = lowLeft;
41.         _topLeft = topLeft;
42.         _topRight = topRight;
43.         _lowRight = lowRight;
44.  
45.         if (patch == null)
46.         {
47.             MeshFilter meshFilter = gameObject.AddComponent<MeshFilter>();
48.             patch = meshFilter.sharedMesh = new Mesh();
49.  
50.             GetComponent<Renderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
51.             GetComponent<Renderer>().receiveShadows = true;
52.             GetComponent<Renderer>().enabled = true;
53.         }
54.     }
55.  
56.     public void GeneratePatchCoordinates(int patchSubdivisions, int patchResolution)
57.     {
58.         patchVertices = new Vector3[patchResolution * patchResolution];
59.         vertBuffer = new int[(patchResolution - 1) * (patchResolution - 1) * 6];
60.         patchUV = new Vector2[patchVertices.Length];
61.         patchNormals = new Vector3[patchVertices.Length];
62.         noise = new float[(patchResolution + 1) * (patchResolution + 1)];
63.  
64.         if (_index == ProceduralPlanet.CubeIndex.FRONT || _index == ProceduralPlanet.CubeIndex.BACK || _index == ProceduralPlanet.CubeIndex.TOP || _index == ProceduralPlanet.CubeIndex.BOTTOM)
65.         {
66.             patchWidth = _topRight.x - _lowLeft.x;
67.         }
68.  
69.         if (_index == ProceduralPlanet.CubeIndex.LEFT || _index == ProceduralPlanet.CubeIndex.RIGHT)
70.         {
71.             patchWidth = _topRight.z - _lowLeft.z;
72.         }
73.  
74.         float increment = patchWidth / (patchResolution - 1);
75.         float patchHalfWidth = ((patchResolution - 1) / patchWidth) * increment;
76.  
77.         for (int z = 0; z < patchResolution; z++)
78.         {
79.             float _z = z * increment;
80.             float _z1 = (z + 1) * increment;
81.  
82.             for (int x = 0; x < patchResolution; x++)
83.             {
84.                 float _x = x * increment;
85.                 float _x1 = (x + 1) * increment;
86.  
87.                 CreatePatchMesh(patchHalfWidth, _x, _x1, _z, _z1, patchSubdivisions, patchResolution);
88.             }
89.         }
90.     }
91.  
92.     private void CreatePatchMesh(float half, float x, float x1, float z, float z1, int subDiv, int resolution)
93.     {
94.         float xIncrement = ((float)_sX / (float)subDiv) * 2;
95.         float zIncrement = ((float)_sZ / (float)subDiv) * 2;
96.  
97.         uvXIncrement = _sX * (1.0f / subDiv);
98.         uvZIncrement = _sZ * (1.0f / subDiv);
99.  
100.         //int texXIncrement = _sX * ((_planet.textureSize / subDiv) / resolution);
101.         //int texZIncrement = _sZ * ((_planet.textureSize / subDiv) / resolution);
102.         int texXIncrement = ((_planet.textureSize / subDiv) / resolution);
103.         int texZIncrement = ((_planet.textureSize / subDiv) / resolution);
104.         float noiseBase = _planet.planetRadius;
105.  
106.         switch(_index)
107.         {
108.             case ProceduralPlanet.CubeIndex.TOP:
109.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, _lowLeft.y, z - half + zIncrement);
110.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
111.                 //patchVertices[vertIndex].Normalize();
112.  
113.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvXIncrement , (z / 2f) + uvZIncrement);
114.                 //Draw the triangles
115.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
116.                 {
117.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
118.                     {
119.                         vertBuffer[ti] = vi;
120.                         vertBuffer[ti + 1] = vi + resolution;
121.                         vertBuffer[ti + 2] = vi + 1;
122.  
123.                         vertBuffer[ti + 3] = vi + resolution;
124.                         vertBuffer[ti + 4] = vi + resolution + 1;
125.                         vertBuffer[ti + 5] = vi + 1;
126.                     }
127.                 }
128.  
129.                 for (int a = 0, b = 0; a <= resolution; a++)
130.                 {
131.                     for (int c = 0; c <= resolution; c++, b++)
132.                     {
133.                         noise[b] = _planet.textures[0].GetPixel(c * texXIncrement + ((_sX * resolution) * texXIncrement), a * texZIncrement + ((_sZ * resolution) * texZIncrement)).grayscale;
134.                         //noise[b] = Mathf.Clamp(noise[b], _planet.planetRadius + noise[b] + 1.0f, _planet.planetRadius + noise[b] + 1.0f);
135.                     }
136.                 }
137.                
138.  
139.                 patchVertices[vertIndex] *= _planet.planetRadius + noise[vertIndex];
140.                 //patchVertices[vertIndex] *= _planet.planetRadius;
141.  
142.                 patch.name = "TOP (" + _sX + "," + _sZ + ")";
143.                 break;
144.  
145.             case ProceduralPlanet.CubeIndex.BOTTOM:
146.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, _lowLeft.y, z - half + zIncrement);
147.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
148.              
149.                 //Assign UV coordinates
150.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvXIncrement, (z / 2f) + uvZIncrement);
151.                 //Draw the triangles
152.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
153.                 {
154.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
155.                     {
156.                         vertBuffer[ti] = vi + 1;
157.                         vertBuffer[ti + 1] = vi + resolution;
158.                         vertBuffer[ti + 2] = vi;
159.  
160.                         vertBuffer[ti + 3] = vi + 1;
161.                         vertBuffer[ti + 4] = vi + resolution + 1;
162.                         vertBuffer[ti + 5] = vi + resolution;
163.                     }
164.                 }
165.  
166.                 for (int a = 0, b = 0; a < resolution; a++)
167.                 {
168.                     for (int c = 0; c < resolution; c++, b++)
169.                     {
170.                         noise[b] = _planet.textures[0].GetPixel(c * texXIncrement, a * texZIncrement).grayscale;
171.                         //noise[b] = Mathf.Clamp(noise[b], _planet.planetRadius + noise[b] + 1.0f, _planet.planetRadius + noise[b] + 1.0f);
172.                     }
173.                 }
174.                
175.                 patchVertices[vertIndex] *= _planet.planetRadius + noise[vertIndex];
176.                 //patchVertices[vertIndex] *= _planet.planetRadius;
177.  
178.                 patch.name = "BOTTOM (" + _sX + "," + _sZ + ")";
179.                 break;
180.  
181.             case ProceduralPlanet.CubeIndex.FRONT:
182.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, z - half + zIncrement, _lowLeft.z);
183.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
184.  
185.                 //Assign UV coordinates
186.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvXIncrement, (z / 2f) + uvZIncrement);
187.                 //Draw the triangles
188.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
189.                 {
190.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
191.                     {
192.                         vertBuffer[ti] = vi + 1;
193.                         vertBuffer[ti + 1] = vi + resolution;
194.                         vertBuffer[ti + 2] = vi;
195.  
196.                         vertBuffer[ti + 3] = vi + 1;
197.                         vertBuffer[ti + 4] = vi + resolution + 1;
198.                         vertBuffer[ti + 5] = vi + resolution;
199.                     }
200.                 }
201.  
202.                 for (int a = 0, b = 0; a < resolution; a++)
203.                 {
204.                     for (int c = 0; c < resolution; c++, b++)
205.                     {
206.                         noise[b] = _planet.textures[0].GetPixel(c * texXIncrement, a * texZIncrement).grayscale;
207.                         //noise[b] = Mathf.Clamp(noise[b], _planet.planetRadius + noise[b] + 1.0f, _planet.planetRadius + noise[b] + 1.0f);
208.                     }
209.                 }
210.                
211.                 patchVertices[vertIndex] *= _planet.planetRadius + noise[vertIndex];
212.                 //patchVertices[vertIndex] *= _planet.planetRadius;
213.  
214.                 patch.name = "FRONT (" + _sX + "," + _sZ + ")";
215.                 break;
216.            
217.             case ProceduralPlanet.CubeIndex.BACK:
218.                 patchVertices[vertIndex] = new Vector3(x - half + xIncrement, z - half + zIncrement, _lowLeft.z);
219.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
220.  
221.                 //Assign UV coordinates
222.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvXIncrement, (z / 2f) + uvZIncrement);
223.                 //Draw the triangles
224.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
225.                 {
226.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
227.                     {
228.                         vertBuffer[ti] = vi;
229.                         vertBuffer[ti + 1] = vi + resolution;
230.                         vertBuffer[ti + 2] = vi + 1;
231.  
232.                         vertBuffer[ti + 3] = vi + resolution;
233.                         vertBuffer[ti + 4] = vi + resolution + 1;
234.                         vertBuffer[ti + 5] = vi + 1;
235.                     }
236.                 }
237.  
238.                 for (int a = 0, b = 0; a < resolution; a++)
239.                 {
240.                     for (int c = 0; c < resolution; c++, b++)
241.                     {
242.                         noise[b] = _planet.textures[0].GetPixel(c * texXIncrement, a * texZIncrement).grayscale;
243.                         //noise[b] = Mathf.Clamp(noise[b], _planet.planetRadius + noise[b] + 1.0f, _planet.planetRadius + noise[b] + 1.0f);
244.                     }
245.                 }
246.                
247.                 patchVertices[vertIndex] *= _planet.planetRadius + noise[vertIndex];
248.                 //patchVertices[vertIndex] *= _planet.planetRadius;
249.  
250.                 patch.name = "BACK (" + _sX + "," + _sZ + ")";
251.                 break;
252.  
253.             case ProceduralPlanet.CubeIndex.LEFT:
254.                 patchVertices[vertIndex] = new Vector3(_lowLeft.x, x - half + zIncrement, -half + z + xIncrement);
255.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
256.  
257.                 //Assign UV coordinates
258.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvZIncrement, (z / 2f) + uvXIncrement);
259.                 //Draw the triangles
260.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
261.                 {
262.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
263.                     {
264.                         vertBuffer[ti] = vi;
265.                         vertBuffer[ti + 1] = vi + resolution;
266.                         vertBuffer[ti + 2] = vi + 1;
267.  
268.                         vertBuffer[ti + 3] = vi + resolution;
269.                         vertBuffer[ti + 4] = vi + resolution + 1;
270.                         vertBuffer[ti + 5] = vi + 1;
271.                     }
272.                 }
273.  
274.                 for (int a = 0, b = 0; a < resolution; a++)
275.                 {
276.                     for (int c = 0; c < resolution; c++, b++)
277.                     {
278.                         noise[b] = _planet.textures[0].GetPixel(c * texXIncrement, a * texZIncrement).grayscale;
279.                         //noise[b] = Mathf.Clamp(noise[b], _planet.planetRadius + noise[b] + 1.0f, _planet.planetRadius + noise[b] + 1.0f);
280.                     }
281.                 }
282.                
283.                 patchVertices[vertIndex] *= _planet.planetRadius + noise[vertIndex];
284.                 //patchVertices[vertIndex] *= _planet.planetRadius;
285.  
286.                 patch.name = "LEFT (" + _sX + "," + _sZ + ")";
287.                 break;
288.  
289.             case ProceduralPlanet.CubeIndex.RIGHT:
290.                 patchVertices[vertIndex] = new Vector3(_lowLeft.x, x - half + zIncrement, -half + z + xIncrement);
291.                 patchVertices[vertIndex] = MapToSphere(patchVertices[vertIndex]);
292.                
293.                 //Assign UV coordinates
294.                 patchUV[vertIndex] = new Vector2((x / 2f) + uvZIncrement, (z / 2f) + uvXIncrement);
295.                 //Draw the triangles
296.                 for (int ti = 0, vi = 0, i = 0; i < (resolution - 1); i++, vi++)
297.                 {
298.                     for (int j = 0; j < (resolution - 1); j++, ti += 6, vi++)
299.                     {
300.                         vertBuffer[ti] = vi + 1;
301.                         vertBuffer[ti + 1] = vi + resolution;
302.                         vertBuffer[ti + 2] = vi;
303.  
304.                         vertBuffer[ti + 3] = vi + 1;
305.                         vertBuffer[ti + 4] = vi + resolution + 1;
306.                         vertBuffer[ti + 5] = vi + resolution;
307.                     }
308.                 }
309.  
310.                 for (int a = 0, b = 0; a < resolution; a++)
311.                 {
312.                     for (int c = 0; c < resolution; c++, b++)
313.                     {
314.                         noise[b] = _planet.textures[0].GetPixel(c * texXIncrement, a * texZIncrement).grayscale;
315.                         //noise[b] = Mathf.Clamp(noise[b], _planet.planetRadius + noise[b] + 1.0f, _planet.planetRadius + noise[b] + 1.0f);
316.                     }
317.                 }
318.                
319.                 patchVertices[vertIndex] *= _planet.planetRadius + noise[vertIndex];
320.                 //patchVertices[vertIndex] *= _planet.planetRadius;
321.  
322.                 patch.name = "RIGHT (" + _sX + "," + _sZ + ")";
323.                 break;
324.         }
325.  
326.         patch.vertices = patchVertices;
327.         patch.uv = patchUV;
328.         patch.triangles = vertBuffer;
329.         patch.RecalculateNormals();
330.  
331.         vertIndex++;
332.     }
333.  
334.     public void Add(SurfacePatch patch)
335.     {
336.  
337.     }
338.  
339.     public Mesh ReturnMesh()
340.     {
341.         return patch;
342.     }
343.  
344.     public static Vector3 MapToSphere(Vector3 point)
345.     {
346.         float dX2, dY2, dZ2;
347.         float dX2Half, dY2Half, dZ2Half;
348.  
349.         dX2 = point.x * point.x;
350.         dY2 = point.y * point.y;
351.         dZ2 = point.z * point.z;
352.  
353.         dX2Half = dX2 * 0.5f;
354.         dY2Half = dY2 * 0.5f;
355.         dZ2Half = dZ2 * 0.5f;
356.  
357.         point.x = point.x * Mathf.Sqrt(1f - dY2Half - dZ2Half + (dY2 * dZ2) * (1f / 3f));
358.         point.y = point.y * Mathf.Sqrt(1f - dZ2Half - dX2Half + (dZ2 * dX2) * (1f / 3f));
359.         point.z = point.z * Mathf.Sqrt(1f - dX2Half - dY2Half + (dX2 * dY2) * (1f / 3f));
360.  
361.         return point;
362.     }
363.  
364.     /*private void OnDrawGizmos()
365.     {
366.         if (patchVertices == null)
367.         {
368.             return;
369.         }
370.  
371.         for (int i = 0; i < patchVertices.Length; i++)
372.         {
373.             if (_index == ProceduralPlanet.CubeIndex.TOP)
374.             {
375.                 Gizmos.color = Color.red;
376.             }
377.  
378.             if (_index == ProceduralPlanet.CubeIndex.BOTTOM)
379.             {
380.                 Gizmos.color = Color.magenta;
381.             }
382.  
383.             if (_index == ProceduralPlanet.CubeIndex.FRONT)
384.             {
385.                 Gizmos.color = Color.green;
386.             }
387.  
388.             if (_index == ProceduralPlanet.CubeIndex.BACK)
389.             {
390.                 Gizmos.color = Color.blue;
391.             }
392.  
393.             Gizmos.DrawSphere(patchVertices[i], 0.0125f);
394.         }
395.         //Gizmos.color = Color.yellow;
396.         //Gizmos.DrawRay(vertices[i], normals[i]);
397.     }*/
398. }
399.  

Could the problem maybe lie in the way I'm mapping the points to the sphere? I'm pretty stuck at this point and out of ideas. Any help would be great, surely there's a person smarter than I that sees something I don't.