Сглаживание переходов на границах квадрантов с высотами

Часть 1

SpaceCraft.Unity/Assets/_Project/Scenes/Game.unity

@@ -942,7 +942,8 @@ MonoBehaviour:
   m_Name: 
   m_EditorClassIdentifier: '::'
   material: {fileID: 2100000, guid: bdf04b1dd42b18241a6b974938d5e840, type: 2}
-  noiseLevel: 0.1
+  noiseLevel: 1
+  noiseScale: 1
 --- !u!33 &1579309478
 MeshFilter:
   m_ObjectHideFlags: 0

SpaceCraft.Unity/Assets/_Project/Scripts/Game/PlaneGenerator.cs

@@ -6,9 +6,10 @@ public class PlaneGenerator : MonoBehaviour
     public Material material;
 
     public float noiseLevel = 0.1f;
+    public float noiseScale = 0.1f;
 
-    private const int pqsResolution = 16;
-    private const int sphereRadius = 10;
+    private const int pqsResolution = 8;
+    private const int sphereRadius = 2;
 
     private List<Quad> quads;
 
@@ -27,26 +28,85 @@ public class PlaneGenerator : MonoBehaviour
 
     private void BuildRootQuads()
     {
-        quads = new List<Quad>
-        {
-            BuildQuad("quadY", new Vector3(0, 0, 0)),
-            BuildQuad("quadY1", new Vector3(180, 0, 0)),
-            BuildQuad("quadZ", new Vector3(90, 0, 0)),
-            BuildQuad("quadZ1", new Vector3(-90, 0, 0)),
-            BuildQuad("quadX", new Vector3(0, 0, 90)),
-            BuildQuad("quadX1", new Vector3(0, 0, -90))
-        };
+        var quadY = new Quad();
+        var quadY1 = new Quad();
+        var quadZ = new Quad();
+        var quadZ1 = new Quad();
+        var quadX = new Quad();
+        var quadX1 = new Quad();
+
+        quadY = BuildRootQuad(
+            id: 1,
+            eulerAngles: new Vector3(0, 0, 0),
+            upperQuad: null, // quadX1,
+            rightQuad: null, // quadZ,
+            lowerQuad: null, // quadX,
+            leftQuad: null); // quadZ1);
+
+        quadZ = BuildRootQuad(
+            id: 3,
+            eulerAngles: new Vector3(-90, 0, 0),
+            upperQuad: null, // quadX,
+            rightQuad: null,
+            lowerQuad: null,
+            leftQuad: quadY);
+
+        quadZ1 = BuildRootQuad(
+            id: 4,
+            eulerAngles: new Vector3(90, 0, 0),
+            upperQuad: null, // quadX,
+            rightQuad: quadY,
+            lowerQuad: null,
+            leftQuad: null);
+
+        quadX = BuildRootQuad(
+            id: 5,
+            eulerAngles: new Vector3(0, 0, 90),
+            upperQuad: quadY,
+            rightQuad: null, // quadZ
+            lowerQuad: null,
+            leftQuad: null); //quadZ1
+
+        quadX1 = BuildRootQuad(
+            id: 6,
+            eulerAngles: new Vector3(0, 0, -90),
+            upperQuad: null,
+            rightQuad: null,
+            lowerQuad: quadY,
+            leftQuad: null);
+
+        ////quadY1 = BuildRootQuad(2, new Vector3(180, 0, 0));
+        ////quadZ = BuildRootQuad(3, new Vector3(-90, 0, 0));
+        ////quadZ1 = BuildRootQuad(4, new Vector3(90, 0, 0));
+        ////quadX = BuildRootQuad(5, new Vector3(0, 0, -90));
+        ////quadX1 = BuildRootQuad(6, new Vector3(0, 0, 90));
+
+        quads = new List<Quad> { quadY, quadY1, quadZ, quadZ1, quadX, quadX1 };
     }
 
-    private Quad BuildQuad(string name, Vector3 eulerAngles)
+    private Quad BuildRootQuad(
+        int id,
+        Vector3 eulerAngles,
+        Quad? upperQuad,
+        Quad? rightQuad,
+        Quad? lowerQuad,
+        Quad? leftQuad)
     {
         var (vertices, uv) = CreateVertices();
         Rotate(vertices, eulerAngles);
+
+        AddHeights(
+            vertices,
+            upperQuad,
+            rightQuad,
+            lowerQuad,
+            leftQuad);
+
         var triangles = CreateTriangles();
 
         return new Quad
         {
-            Name = name,
+            Id = id,
             Vertices = vertices,
             Triangles = triangles,
             Uv = uv
@@ -57,7 +117,7 @@ public class PlaneGenerator : MonoBehaviour
     {
         foreach (var quad in quads)
         {
-            CreateMesh(quad.Name, quad.Vertices, quad.Uv, quad.Triangles);
+            CreateMesh($"quad_{quad.Id}", quad.Vertices, quad.Uv, quad.Triangles);
         }
     }
 
@@ -67,11 +127,11 @@ public class PlaneGenerator : MonoBehaviour
         var vertices = new Vector3[(pqsResolution + 1) * (pqsResolution + 1)];
         Vector2[] uv = new Vector2[(pqsResolution + 1) * (pqsResolution + 1)];
 
-        for (int x = 0, vertex = 0; x < pqsResolution + 1; x++)
+        for (int x = 0, vertex = 0; x <= pqsResolution; x++)
         {
-            for (int z = 0; z < pqsResolution + 1; z++, vertex++)
+            for (int z = 0; z <= pqsResolution; z++, vertex++)
             {
-                vertices[vertex] = new Vector3(half - (float)x / pqsResolution * sphereRadius, half, half - (float)z / pqsResolution * sphereRadius);
+                vertices[vertex] = new Vector3((float)x / pqsResolution * sphereRadius - half, half, (float)z / pqsResolution * sphereRadius - half);
                 uv[vertex] = new Vector2((float)x / pqsResolution, (float)z / pqsResolution);
             }
         }
@@ -123,9 +183,9 @@ public class PlaneGenerator : MonoBehaviour
 
     private void Rotate(Vector3[] vertices, Vector3 eulerAngles)
     {
-        for (int x = 0, vertex = 0; x < pqsResolution + 1; x++)
+        for (int x = 0, vertex = 0; x <= pqsResolution; x++)
         {
-            for (int z = 0; z < pqsResolution + 1; z++, vertex++)
+            for (int z = 0; z <= pqsResolution; z++, vertex++)
             {
                 vertices[vertex] = Rotate(vertices[vertex], eulerAngles);
                 vertices[vertex] = Vector3.Normalize(vertices[vertex]);
@@ -181,20 +241,83 @@ public class PlaneGenerator : MonoBehaviour
 
     private float GetNoise(float x, float y)
     {
-        return 1 + Mathf.PerlinNoise(x, y) * noiseLevel;
+        return Mathf.PerlinNoise(x * noiseScale, y * noiseScale) * noiseLevel;
     }
 
-    private void AddHeights(Vector3[] vertices)
+    private void AddHeights(
+        Vector3[] vertices,
+        Quad? upperQuad,
+        Quad? rightQuad,
+        Quad? lowerQuad,
+        Quad? leftQuad)
     {
-        for (int x = 0, vertex = 0; x < pqsResolution + 1; x++)
+        for (int x = 0, vertex = 0; x <= pqsResolution; x++)
         {
-            for (int z = 0; z < pqsResolution + 1; z++, vertex++)
+            for (int z = 0; z <= pqsResolution; z++, vertex++)
             {
-                var noise = 1; // GetNoise(vertices[vertex].x, vertices[vertex].y);
-                vertices[vertex] = noise * sphereRadius * vertices[vertex];
+                if (x == 0 && lowerQuad?.Vertices != null)
+                {
+                    vertices[vertex] = lowerQuad.Value.Vertices[(pqsResolution + 1) * pqsResolution + z]; //+
+                }
+                else if (x == pqsResolution && upperQuad?.Vertices != null)
+                {
+                    vertices[vertex] = upperQuad.Value.Vertices[z];
+                }
+                else if (z == 0 && rightQuad?.Vertices != null)
+                {
+                    vertices[vertex] = rightQuad.Value.Vertices[(pqsResolution + 1) * (x + 1) - 1]; //+
+                }
+                else if (z == pqsResolution && leftQuad?.Vertices != null)
+                {
+                    vertices[vertex] = leftQuad.Value.Vertices[x * (pqsResolution + 1)]; //+
+                }
+                else
+                {
+                    var noise = 1 + GetNoise(Random.value, Random.value);
+                    vertices[vertex] = noise * sphereRadius * vertices[vertex];
+                }
             }
         }
+    }
 
-        vertices[pqsResolution + 3] *= 2f;
+    private void OnDrawGizmos()
+    {
+        var gizmoSize = 0.05f;
+        if (quads != null)
+        {
+            foreach (var quad in quads)
+            {
+                if (quad.Vertices == null)
+                    continue;
+
+                for (int x = 0, vertex = 0; x <= pqsResolution; x++)
+                {
+                    for (int z = 0; z <= pqsResolution; z++, vertex++)
+                    {
+                        if (x == 0)
+                        {
+                            Gizmos.DrawSphere(quad.Vertices[vertex], gizmoSize);
+                        }
+                        else if (x == pqsResolution)
+                        {
+                            Gizmos.DrawWireSphere(quad.Vertices[vertex], gizmoSize);
+                        }
+                        else if (z == 0)
+                        {
+                            Gizmos.DrawCube(quad.Vertices[vertex], new Vector3(gizmoSize, gizmoSize, gizmoSize));
+                        }
+                        else if (z == pqsResolution)
+                        {
+                            Gizmos.DrawWireCube(quad.Vertices[vertex], new Vector3(gizmoSize, gizmoSize, gizmoSize));
+                        }
+                        else
+                        {
+                            var noise = 1; // 1 + GetNoise(Random.value, Random.value);
+                                           //vertices[vertex] = noise * sphereRadius * vertices[vertex];
+                        }
+                    }
+                }
+            }
+        }
     }
 }

SpaceCraft.Unity/Assets/_Project/Scripts/Game/Quad.cs

@@ -4,14 +4,14 @@ public struct Quad
 {
     public int Id { get; set; }
 
-    public string Name { get; set; }
-
     public int ParentId { get; set; }
 
     public int Level { get; set; }
 
     public Vector3[] Vertices { get; set; }
 
+    public float[] Heights { get; set; }
+
     public int[] Triangles { get; set; }
 
     public Vector2[] Uv { get; set; }