Procedural Planet Terrain Engine

AlucardJay · Sep 3, 2016

I can see where the problem lies, just not sure how to fix it (and not sure I have the aptitude to explain it.... but here goes). It's all in QuadSurface GenerateSurfaceCoordinates() particularly how the Vertex Coordinates are calculated.

If we put some of the calculation in a separate variable, the problem starts to expose itself :

Code (csharp):

// vertex position and offset

float xPos = (float)j * increment - 0.5f + ((float)xIndex / Mathf.Pow(2, subDivisions));

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f + ((float)zIndex / Mathf.Pow(2, subDivisions));

// ((float)xIndex / Mathf.Pow(2, subDivisions)) <-- this is basically an offset, based on the position of the subDivision

float xOffset = ((float)xIndex / Mathf.Pow(2, subDivisions));

float zOffset = ((float)zIndex / Mathf.Pow(2, subDivisions));

float xPos = (float)j * increment - 0.5f + xOffset;

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f + zOffset;

The offset has to be relative to the previous subDivision : where the previous subDivision started is what this offset should equal. Clear as mud?!

Code (csharp):

// what previous surface is this surface a branch of ????

// previous subDivision :

// 0_______1_______2

// |_______|_______|

// this subDivision :

// ........0___1___2

// |_______|___|___|

// |_______|_______|

for this surface/subDivision offset, we need to know what the previous surface/subDivision offset was. I did some experimentation, but couldn't find the formula for now. Shall check back later to see if you worked it out!

BradMick · Sep 3, 2016

Yup, you're spot on! And I solved it through the....second layer of Subdivisions. Basically what I've worked out...everything has to increase by 1.

we start with indices of (0, 0) (that very first face...hereafter known as LOD 0)
when we subdivide, we gain: (0,0) (1,0) (0, 1) (1, 1)
if we subdivide say....(1,0), that becomes (2, 0) (2, 1) (3, 0) (3, 1)

So that was good to go...but now that I'm 3 layers deep, i'm 1 off again. So I don't know if I need to change the GenerateSurfaceCoordinates bit or the SubDivide bit...From the screen shot you can see that it's offset by 1 index wise.

I know what your saying and I hope you know that I'm saying...hah! It all makes sense, I just cant' puzzle out the formula yet. I feel that I'm close...right on the cusp.

I did find this: https://github.com/Tiggilyboo/UnityQuadTreePlanet

Which gave me a bit of insight into the LOD system, and some of the ideas I've adapted to my framework. But because of how he builds his geometry versus how I build mine I'm struggling to parse the two together for sure.

Anyway, here's the latest and greatest code!

Code (CSharp):

using UnityEngine;

using System.Collections;

public class GeneratePlanet : MonoBehaviour

{

[Header("Planet Info")]

[Range(3.0f, 7.0f)] public int LOD = 3;

[Range(0.0f, 1.0f)] public float WATERLEVEL = 0.5f;

public float PLANETRADIUS = 1; //m, will eventually be km

public float WORLDHEIGHT = 0.1f;

[Header("Texture and Noise Variables")]

public int TEXTURESIZE = 256;

public float NOISESCALE = 1.45f;

public float NOISEOFFSET = 1.56f;

public int OCTAVES = 8;

[Header("Planet Colors")]

public Gradient PLANETCOLORS;

[Header("Test")]

public bool USEVERTEXCOLORS = false;

public Material vertexColors;

//The planet!

private QuadSphere planet;

//Textures!

private TextureGenerator textureGenerator;

//Will eventually be made private...need to see what's going on for now...

[Header("Will eventually be private...")]

public Texture2D[] textures;

void Start()

{

//PLANETCOLORS = PlanetUtilities.CreateColourGradient(PLANETCOLORS);

//Generate textures!

textureGenerator = new TextureGenerator(TEXTURESIZE,NOISEOFFSET, OCTAVES, NOISESCALE, PLANETCOLORS);

//Assign the textures created above to the local textures to make passing them along easier...

textures = textureGenerator.surfaceTextures;

planet = new QuadSphere("Planet1", LOD, WATERLEVEL, PLANETRADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, textures);

}

void Update()

{

}

//This is meant for the Solar System Generator in the future...

/*public GeneratePlanet(string name, int lod, int radius)

{

planet = new QuadSphere(name, lod, radius);

}*/

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public class QuadSphere

{

GameObject planet;

QuadSurface[] surfaces;

public QuadSphere(string name, int lod, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures)

{

//Initialize the array

surfaces = new QuadSurface[6];

//Create a new new QuadSurface using the specified LOD.

for (int i = 0; i < 6; i++)

{

//LOD 0

surfaces[i] = new QuadSurface(lod, 0, 0, 0, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, (quadFace)i);

}

//Testing...

//LOD 1

surfaces[0].SubDivide();

//LOD 2

surfaces[0].tree[0].SubDivide();

surfaces[0].tree[2].SubDivide();

//LOD 3

surfaces[0].tree[2].tree[1].SubDivide();

planet = new GameObject(name);

for (int i = 0; i < surfaces.Length; i++)

surfaces[i].surface.transform.parent = planet.transform;

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public class QuadSurface

{

public QuadSurface root;

public QuadSurface[] tree;

public GameObject surface { get; private set; }

public MeshRenderer renderer { get; private set; }

public MeshCollider collider { get; private set; }

public MeshFilter filter { get; private set; }

private int LEVELOFDETAIL, SUBDIVISIONS, XINDEX, ZINDEX;

private float WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT;

private Texture2D[] TEXTURES;

private quadFace QUADFACE;

public bool[] neighbors;

public bool generated = false;

public bool finalized = false;

//Vertex Colors Testing

GameObject planetGenerator;

GeneratePlanet generator;

Material planetMaterial;

Color[] planetColors;

Gradient planetGradient;

public QuadSurface(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

InitializeSurfaceGenerator(root, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

public QuadSurface(int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

InitializeSurfaceGenerator(null, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

void InitializeSurfaceGenerator(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

LEVELOFDETAIL = lod;

SUBDIVISIONS = subDivisions;

XINDEX = xIndex;

ZINDEX = zIndex;

WATERLEVEL = waterLevel;

RADIUS = radius;

NOISEOFFSET = noiseOffset;

OCTAVES = octaves;

NOISESCALE = noiseScale;

WORLDHEIGHT = worldHeight;

TEXTURES = textures;

QUADFACE = face;

//Vertex Colors Testing

planetGenerator = GameObject.Find("PlanetGenerator");

generator = planetGenerator.GetComponent<GeneratePlanet>();

planetMaterial = generator.vertexColors;

planetGradient = generator.PLANETCOLORS;

GenerateSurfaceCoordinates(root, subDivisions, xIndex, zIndex, face);

}

void GenerateSurfaceCoordinates(QuadSurface root, int subDivisions, int xIndex, int zIndex, quadFace face)

{

//The base number of faces is 2, which means we need +1 vert to make that happen.

int vertsPerQuad = (int)Mathf.Pow(2, LEVELOFDETAIL) + 1;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[vertsPerQuad * vertsPerQuad];

//Appropriately size (and create) the Normal Array

Vector3[] normals = new Vector3[vertices.Length];

//Appropriately size (and create) the UV Array

Vector2[] uvs = new Vector2[vertices.Length];

//Vertex Colors Testing

Color[] colors = new Color[vertices.Length];

planetColors = colors;

//Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = ((1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, subDivisions));

float uvIncrement = (1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, subDivisions);

for (int i = 0, index = 0; i < vertsPerQuad; i++)

{

for (int j = 0; j < vertsPerQuad; j++, index++)

{

//Vertex Coordinates

float xPos = (float)j * increment - 0.5f + ((float)xIndex / Mathf.Pow(2, subDivisions));

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f + ((float)zIndex / Mathf.Pow(2, subDivisions));

//UV Coordinates

float xUV = (float)j * uvIncrement + ((float)xIndex / Mathf.Pow(2, subDivisions));

float zUV = (float)i * uvIncrement + ((float)zIndex / Mathf.Pow(2, subDivisions));

switch (face)

{

case quadFace.TOP:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case quadFace.BOTTOM:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case quadFace.LEFT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case quadFace.RIGHT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case quadFace.FRONT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case quadFace.BACK:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Assign UV Coordinates

uvs[index] = new Vector2(xUV, zUV);

//Spherify the vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

float noise = PlanetUtilities.GetNoise(vertices[index], NOISEOFFSET, OCTAVES, NOISESCALE);

//Vertex Colors Testing

colors[index] = planetGradient.Evaluate(noise);

//Keep the oceans flat! - thanks alucardj!

if (noise > WATERLEVEL)

noise = (noise - WATERLEVEL) * (1.0f / (1.0f - WATERLEVEL));

else

noise = 0.0f;

vertices[index] *= RADIUS + (noise * WORLDHEIGHT);

normals[index] = vertices[index].normalized;

}

}

//Create the Surface Object

CreateSurfaceObject(root, xIndex, zIndex, face, vertsPerQuad, vertices, normals, uvs);

}

void CreateSurfaceObject(QuadSurface root, int xIndex, int zIndex, quadFace face, int vertsPerQuad, Vector3[] vertexArray, Vector3[] normalArray, Vector2[] uvArray)

{

this.root = root;

//Create the game object to which we'll attach everything to

surface = new GameObject("LOD: " + SUBDIVISIONS + " Face: " + face + " (" + xIndex + ", " + zIndex + ")");

//Add the mesh Renderer

renderer = surface.AddComponent<MeshRenderer>();

//Add the MeshCollider

collider = surface.AddComponent<MeshCollider>();

//Add the MeshFilter

filter = surface.AddComponent<MeshFilter>();

//Initialize the renderer

renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;

renderer.receiveShadows = true;

renderer.enabled = true;

if (generator.USEVERTEXCOLORS == false)

//Assign the generated textures to the quadSphere

surface.GetComponent<Renderer>().material.mainTexture = TEXTURES[(int)face];

else

//Vertex Colors testing

surface.GetComponent<Renderer>().material = planetMaterial;

if (root != null)

surface.transform.parent = root.surface.transform;

CreateSurfaceMesh(face, vertsPerQuad, vertexArray, normalArray, uvArray);

}

void CreateSurfaceMesh(quadFace face, int vertsPerQuad, Vector3[] vertexArray, Vector3[] normalArray, Vector2[] uvArray)

{

//If this has already been generated, enable the renderer

if (generated)

{

renderer.enabled = true;

if (root != null)

root.collider.enabled = false;

collider.enabled = true;

return;

}

int vertBufferSize = vertsPerQuad - 1;

//Size the vertex buffer

int[] vertexBuffer = new int[(vertBufferSize * vertBufferSize) * 6];

//Create a new Mesh object

Mesh surfaceMesh;

//Create a new Mesh using the Objects MeshFilter

surfaceMesh = surface.GetComponent<MeshFilter>().sharedMesh = new Mesh();

surfaceMesh.name = surface.name;

//Step through the Vertex Buffer

for (int triIndex = 0, vertIndex = 0, i = 0; i < vertBufferSize; i++, vertIndex++)

{

for (int j = 0; j < vertBufferSize; j++, triIndex += 6, vertIndex++)

{

// 1

// | \

// | \

// | \

// 0----2

vertexBuffer[triIndex] = vertIndex;

vertexBuffer[triIndex + 1] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 2] = vertIndex + 1;

// 1----3

// \ |

// \ |

// \|

// 2

vertexBuffer[triIndex + 3] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 4] = vertIndex + vertsPerQuad + 1;

vertexBuffer[triIndex + 5] = vertIndex + 1;

}

}

//Assign the Vertex Array from Generate Surface Coordinates to the Mesh Vertex Array

surfaceMesh.vertices = vertexArray;

//Assign the UV Coordinates

surfaceMesh.uv = uvArray;

//Assign the Vertex Buffer

surfaceMesh.triangles = vertexBuffer;

//Vertex Colors Testing

surfaceMesh.colors = planetColors;

//Recalculate the Normals

//surfaceMesh.RecalculateNormals();

surfaceMesh.normals = normalArray; //Done manually...

//Recalculate Bounds

surfaceMesh.RecalculateBounds();

//After the Mesh has been created, pass it back to the MeshCollider

surface.GetComponent<MeshCollider>().sharedMesh = surfaceMesh;

//If root is ever null...Destroy!

if (root != null)

root.Destroy();

generated = true;

}

public void Destroy()

{

renderer.enabled = false;

generated = false;

}

//Merges our quadtrees!

public void MergeQuadTree()

{

if (tree == null)

return;

for (int i = 0; i < tree.Length; i++)

{

tree[i].MergeQuadTree();

tree[i].Destroy();

}

tree = null;

}

public void SubDivide()

{

SUBDIVISIONS++;

Debug.Log(SUBDIVISIONS);

tree = new QuadSurface[4];

tree[0] = new QuadSurface(this, LEVELOFDETAIL, SUBDIVISIONS, 0 + (XINDEX * SUBDIVISIONS), 0 + (ZINDEX * SUBDIVISIONS), WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, TEXTURES, QUADFACE);

tree[1] = new QuadSurface(this, LEVELOFDETAIL, SUBDIVISIONS, 0 + (XINDEX * SUBDIVISIONS), 1 + (ZINDEX * SUBDIVISIONS), WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, TEXTURES, QUADFACE);

tree[2] = new QuadSurface(this, LEVELOFDETAIL, SUBDIVISIONS, 1 + (XINDEX * SUBDIVISIONS), 0 + (ZINDEX * SUBDIVISIONS), WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, TEXTURES, QUADFACE);

tree[3] = new QuadSurface(this, LEVELOFDETAIL, SUBDIVISIONS, 1 + (XINDEX * SUBDIVISIONS), 1 + (ZINDEX * SUBDIVISIONS), WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, TEXTURES, QUADFACE);

Destroy();

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public enum quadFace { TOP, BOTTOM, LEFT, RIGHT, FRONT, BACK }

public static class PlanetUtilities

{

//From Catlike Coding!

public static Vector3 SmoothVertices(Vector3 vertex)

{

Vector3 v = vertex * 2f;

float x2 = v.x * v.x;

float y2 = v.y * v.y;

float z2 = v.z * v.z;

Vector3 s;

s.x = v.x * Mathf.Sqrt(1f - y2 / 2f - z2 / 2f + y2 * z2 / 3f);

s.y = v.y * Mathf.Sqrt(1f - x2 / 2f - z2 / 2f + x2 * z2 / 3f);

s.z = v.z * Mathf.Sqrt(1f - x2 / 2f - y2 / 2f + x2 * y2 / 3f);

return s;

}

// using a Simplex Noise library :

// http://cabbynode.net/2012/06/10/perlin-simplex-noise-for-c-and-xna/

public static float GetNoise(Vector3 vertex, float noiseOffset, float octaves, float noiseScale)

{

// add offset

vertex.x += noiseOffset;

vertex.y += noiseOffset;

vertex.z += noiseOffset;

// fractal noise

float amp = 1f;

float noise = 0f;

float gain = 1f;

float factor = 0f;

Vector3 calcVert;

for (int i = 0; i < octaves; i++)

{

factor += 1f / gain;

calcVert = vertex * noiseScale * gain;

noise += Noise.Noise.GetNoise(calcVert.x, calcVert.y, calcVert.z) * (amp / gain);

gain *= 2f;

}

// normalize noise by octave iteration factor

noise /= factor;

return noise;

}

public static Gradient CreateColourGradient(Gradient planetColors)

{

// using colour scale from LibNoise example : http://libnoise.sourceforge.net/tutorials/tutorial3.html

//renderer.AddGradientPoint (-1.0000, utils::Color ( 0, 0, 128, 255)); // deeps

//renderer.AddGradientPoint (-0.2500, utils::Color ( 0, 0, 255, 255)); // shallow

//renderer.AddGradientPoint ( 0.0000, utils::Color ( 0, 128, 255, 255)); // shore

//renderer.AddGradientPoint ( 0.0625, utils::Color (240, 240, 64, 255)); // sand

//renderer.AddGradientPoint ( 0.1250, utils::Color ( 32, 160, 0, 255)); // grass

//renderer.AddGradientPoint ( 0.3750, utils::Color (224, 224, 0, 255)); // dirt

//renderer.AddGradientPoint ( 0.7500, utils::Color (128, 128, 128, 255)); // rock

//renderer.AddGradientPoint ( 1.0000, utils::Color (255, 255, 255, 255)); // snow

planetColors = new Gradient();

GradientColorKey[] gck = new GradientColorKey[8];

gck[0].color = CalculateGradientColour(0, 0, 128);

gck[0].time = CalculateGradientTime(-1.0000);

gck[1].color = CalculateGradientColour(0, 0, 255);

gck[1].time = CalculateGradientTime(-0.2500);

gck[2].color = CalculateGradientColour(0, 128, 255);

gck[2].time = CalculateGradientTime(0.0000);

gck[3].color = CalculateGradientColour(240, 240, 64);

gck[3].time = CalculateGradientTime(0.0625);

gck[4].color = CalculateGradientColour(32, 160, 0);

gck[4].time = CalculateGradientTime(0.1250);

gck[5].color = CalculateGradientColour(224, 224, 0);

gck[5].time = CalculateGradientTime(0.3750);

gck[6].color = CalculateGradientColour(128, 128, 128);

gck[6].time = CalculateGradientTime(0.7500);

gck[7].color = CalculateGradientColour(255, 255, 255);

gck[7].time = CalculateGradientTime(1.0000);

GradientAlphaKey[] gak = new GradientAlphaKey[2];

gak[0].alpha = 1f;

gak[0].time = 0f;

gak[1].alpha = 1f;

gak[1].time = 1f;

planetColors.SetKeys(gck, gak);

return planetColors;

}

static Color CalculateGradientColour(int r, int g, int b)

{

return new Color((float)r / 255f, (float)g / 255f, (float)b / 255f);

}

static float CalculateGradientTime(double t)

{

return (float)((t + 1) * 0.5);

}

}

Code (CSharp):

//SOURCE: alucardj

//http://forum.unity3d.com/conversations/procedural-textures.465272/

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class TextureGenerator

{

public Texture2D[] surfaceTextures { get; private set; }

private int textureSize;

private float noiseOffset, octaves, noiseScale;

private Gradient planetColors;

public TextureGenerator(int size, float offset, float oct, float scale, Gradient colors)

{

textureSize = size;

noiseOffset = offset;

octaves = oct;

noiseScale = scale;

planetColors = colors;

surfaceTextures = new Texture2D[6];

for (int i = 0; i < 6; i++ )

GenerateSurfaceTextures((quadFace)i);

}

void GenerateSurfaceTextures(quadFace face)

{

Texture2D texture = new Texture2D(textureSize, textureSize);

//Create the Color List that will be applied to the texture

List<Color> colorList = new List<Color>();

Color color;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[textureSize * textureSize];

// Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = 1.0f / ((float)textureSize - 1);

for (int i = 0, index = 0; i < textureSize; i++)

{

for (int j = 0; j < textureSize; j++, index++)

{

// Vertex Coordinates

float xPos = (float)j * increment - 0.5f;

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f;

// Assign Vertex Coordinates

switch (face)

{

case quadFace.TOP:

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case quadFace.BOTTOM:

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case quadFace.LEFT:

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case quadFace.RIGHT:

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case quadFace.FRONT:

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case quadFace.BACK:

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Spherify the Vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

//Get noise!

float noise = PlanetUtilities.GetNoise(vertices[index], noiseOffset, octaves, noiseScale);

// get Colour

/*if (useGreyscale)

{

colour = new Color(noise, noise, noise, 1f);

}

else

{

colour = planetColours.Evaluate(noise);

}*/

color = planetColors.Evaluate(noise);

// Add Colour to Texture Colour Array

colorList.Add(color);

}

}

// Apply Texture Colour Array to the Texture

texture.SetPixels(colorList.ToArray());

texture.wrapMode = TextureWrapMode.Clamp;

texture.Apply();

surfaceTextures[(int)face] = texture;

}

}

Update:

Okay...so...in my Excel book that I use to sort out formulas this is what I've worked out...The X and Z indexes need to iterate by 2 each time through. So....easy way to explain...

If subD = 2, then indices are
(0, 0) (2, 0) (4, 0) (6, 0) for one row
(0, 2) (2, 2) (4, 2) (6, 2) for the next row
(0, 4) (2, 4) (4, 4) (6, 4) for the next row
(0, 6) (2, 6) (4, 6) (6, 6) for the last row

attached is the spreadsheet.

BradMick · Sep 4, 2016

Solved it!

So...it was simpler than I was making it. Basically I wasn't leveraging the tree the way it was meant to be leveraged. So, this is how it does it:

Code (CSharp):

for (int i = 0, index = 0; i < 2; i++)

{

for (int j = 0; j < 2; j++, index++)

{

//This is the line...makes perfect sense after I wrote it....

tree[index] = new QuadSurface(this, LEVELOFDETAIL, this.SUBDIVISIONS + 1, i + (this.XINDEX * 2), j + (this.ZINDEX * 2), WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, TEXTURES, QUADFACE);

}

}

Using the for loop, we iterate through the tree to create 4 new surfaces. We take into account the parents subdivision level and also the parents x and z indices, multiplying them by 2 (makes sense since everything is powers of 2) and then add 1. I've subdivided through 4 levels (changed the verbage...because for the purposes of this program LOD defines the number of verts you start with). That's it. It was that simple. Fun how a nights rest will make you realize you're dumb and the answer was right in front of you all along...go figure, hah!

New code!

Code (CSharp):

using UnityEngine;

using System.Collections;

public class GeneratePlanet : MonoBehaviour

{

[Header("Planet Info")]

[Range(3.0f, 7.0f)] public int LOD = 3;

[Range(0.0f, 1.0f)] public float WATERLEVEL = 0.5f;

public float PLANETRADIUS = 1; //m, will eventually be km

public float WORLDHEIGHT = 0.1f;

[Header("Texture and Noise Variables")]

public int TEXTURESIZE = 256;

public float NOISESCALE = 1.45f;

public float NOISEOFFSET = 1.56f;

public int OCTAVES = 8;

[Header("Planet Colors")]

public Gradient PLANETCOLORS;

[Header("Test")]

public bool USEVERTEXCOLORS = false;

public Material vertexColors;

//The planet!

private QuadSphere planet;

//Textures!

private TextureGenerator textureGenerator;

//Will eventually be made private...need to see what's going on for now...

[Header("Will eventually be private...")]

public Texture2D[] textures;

void Start()

{

//PLANETCOLORS = PlanetUtilities.CreateColourGradient(PLANETCOLORS);

//Generate textures!

textureGenerator = new TextureGenerator(TEXTURESIZE,NOISEOFFSET, OCTAVES, NOISESCALE, PLANETCOLORS);

//Assign the textures created above to the local textures to make passing them along easier...

textures = textureGenerator.surfaceTextures;

planet = new QuadSphere("Planet1", LOD, WATERLEVEL, PLANETRADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, textures);

}

void Update()

{

}

//This is meant for the Solar System Generator in the future...

/*public GeneratePlanet(string name, int lod, int radius)

{

planet = new QuadSphere(name, lod, radius);

}*/

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public class QuadSphere

{

GameObject planet;

QuadSurface[] surfaces;

public QuadSphere(string name, int lod, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures)

{

//Initialize the array

surfaces = new QuadSurface[6];

//Create a new new QuadSurface using the specified LOD.

for (int i = 0; i < 6; i++)

{

//SUB-D 0

surfaces[i] = new QuadSurface(lod, 0, 0, 0, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, (quadFace)i);

}

//Testing...

//SUB-D 1

surfaces[0].SubDivide();

//SUB-D 2

surfaces[0].tree[0].SubDivide();

surfaces[0].tree[2].SubDivide();

//SUB-D 3

surfaces[0].tree[2].tree[1].SubDivide();

//SUB-D 4

surfaces[0].tree[2].tree[1].tree[3].SubDivide();

planet = new GameObject(name);

for (int i = 0; i < surfaces.Length; i++)

surfaces[i].surface.transform.parent = planet.transform;

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public class QuadSurface

{

public QuadSurface root;

public QuadSurface[] tree;

public GameObject surface { get; private set; }

public MeshRenderer renderer { get; private set; }

public MeshCollider collider { get; private set; }

public MeshFilter filter { get; private set; }

private int LEVELOFDETAIL, SUBDIVISIONS, XINDEX, ZINDEX;

private float WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT;

private Texture2D[] TEXTURES;

private quadFace QUADFACE;

public bool[] neighbors;

public bool generated = false;

public bool finalized = false;

//Vertex Colors Testing

GameObject planetGenerator;

GeneratePlanet generator;

Material planetMaterial;

Color[] planetColors;

Gradient planetGradient;

public QuadSurface(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

InitializeSurfaceGenerator(root, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

public QuadSurface(int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

InitializeSurfaceGenerator(null, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

void InitializeSurfaceGenerator(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

LEVELOFDETAIL = lod;

SUBDIVISIONS = subDivisions;

XINDEX = xIndex;

ZINDEX = zIndex;

WATERLEVEL = waterLevel;

RADIUS = radius;

NOISEOFFSET = noiseOffset;

OCTAVES = octaves;

NOISESCALE = noiseScale;

WORLDHEIGHT = worldHeight;

TEXTURES = textures;

QUADFACE = face;

//Vertex Colors Testing

planetGenerator = GameObject.Find("PlanetGenerator");

generator = planetGenerator.GetComponent<GeneratePlanet>();

planetMaterial = generator.vertexColors;

planetGradient = generator.PLANETCOLORS;

GenerateSurfaceCoordinates(root, subDivisions, xIndex, zIndex, face);

}

void GenerateSurfaceCoordinates(QuadSurface root, int subDivisions, int xIndex, int zIndex, quadFace face)

{

//The base number of faces is 2, which means we need +1 vert to make that happen.

int vertsPerQuad = (int)Mathf.Pow(2, LEVELOFDETAIL) + 1;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[vertsPerQuad * vertsPerQuad];

//Appropriately size (and create) the Normal Array

Vector3[] normals = new Vector3[vertices.Length];

//Appropriately size (and create) the UV Array

Vector2[] uvs = new Vector2[vertices.Length];

//Vertex Colors Testing

Color[] colors = new Color[vertices.Length];

planetColors = colors;

//Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = ((1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, subDivisions));

float uvIncrement = (1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, subDivisions);

for (int i = 0, index = 0; i < vertsPerQuad; i++)

{

for (int j = 0; j < vertsPerQuad; j++, index++)

{

//Vertex Coordinates

float xPos = (float)j * increment - 0.5f + ((float)xIndex / Mathf.Pow(2, subDivisions));

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f + ((float)zIndex / Mathf.Pow(2, subDivisions));

//UV Coordinates

float xUV = (float)j * uvIncrement + ((float)xIndex / Mathf.Pow(2, subDivisions));

float zUV = (float)i * uvIncrement + ((float)zIndex / Mathf.Pow(2, subDivisions));

switch (face)

{

case quadFace.TOP:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case quadFace.BOTTOM:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case quadFace.LEFT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case quadFace.RIGHT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case quadFace.FRONT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case quadFace.BACK:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Assign UV Coordinates

uvs[index] = new Vector2(xUV, zUV);

//Spherify the vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

float noise = PlanetUtilities.GetNoise(vertices[index], NOISEOFFSET, OCTAVES, NOISESCALE);

//Vertex Colors Testing

colors[index] = planetGradient.Evaluate(noise);

//Keep the oceans flat! - thanks alucardj!

if (noise > WATERLEVEL)

noise = (noise - WATERLEVEL) * (1.0f / (1.0f - WATERLEVEL));

else

noise = 0.0f;

vertices[index] *= RADIUS + (noise * WORLDHEIGHT);

normals[index] = vertices[index].normalized;

}

}

//Create the Surface Object

CreateSurfaceObject(root, xIndex, zIndex, face, vertsPerQuad, vertices, normals, uvs);

}

void CreateSurfaceObject(QuadSurface root, int xIndex, int zIndex, quadFace face, int vertsPerQuad, Vector3[] vertexArray, Vector3[] normalArray, Vector2[] uvArray)

{

this.root = root;

//Create the game object to which we'll attach everything to

surface = new GameObject("SUB-D: " + SUBDIVISIONS + " Face: " + face + " (" + xIndex + ", " + zIndex + ")");

//Add the mesh Renderer

renderer = surface.AddComponent<MeshRenderer>();

//Add the MeshCollider

collider = surface.AddComponent<MeshCollider>();

//Add the MeshFilter

filter = surface.AddComponent<MeshFilter>();

//Initialize the renderer

renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;

renderer.receiveShadows = true;

renderer.enabled = true;

if (generator.USEVERTEXCOLORS == false)

//Assign the generated textures to the quadSphere

surface.GetComponent<Renderer>().material.mainTexture = TEXTURES[(int)face];

else

//Vertex Colors testing

surface.GetComponent<Renderer>().material = planetMaterial;

if (root != null)

surface.transform.parent = root.surface.transform;

CreateSurfaceMesh(face, vertsPerQuad, vertexArray, normalArray, uvArray);

}

void CreateSurfaceMesh(quadFace face, int vertsPerQuad, Vector3[] vertexArray, Vector3[] normalArray, Vector2[] uvArray)

{

//If this has already been generated, enable the renderer

if (generated)

{

renderer.enabled = true;

if (root != null)

root.collider.enabled = false;

collider.enabled = true;

return;

}

int vertBufferSize = vertsPerQuad - 1;

//Size the vertex buffer

int[] vertexBuffer = new int[(vertBufferSize * vertBufferSize) * 6];

//Create a new Mesh object

Mesh surfaceMesh;

//Create a new Mesh using the Objects MeshFilter

surfaceMesh = surface.GetComponent<MeshFilter>().sharedMesh = new Mesh();

surfaceMesh.name = surface.name;

//Step through the Vertex Buffer

for (int triIndex = 0, vertIndex = 0, i = 0; i < vertBufferSize; i++, vertIndex++)

{

for (int j = 0; j < vertBufferSize; j++, triIndex += 6, vertIndex++)

{

// 1

// | \

// | \

// | \

// 0----2

vertexBuffer[triIndex] = vertIndex;

vertexBuffer[triIndex + 1] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 2] = vertIndex + 1;

// 1----3

// \ |

// \ |

// \|

// 2

vertexBuffer[triIndex + 3] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 4] = vertIndex + vertsPerQuad + 1;

vertexBuffer[triIndex + 5] = vertIndex + 1;

}

}

//Assign the Vertex Array from Generate Surface Coordinates to the Mesh Vertex Array

surfaceMesh.vertices = vertexArray;

//Assign the UV Coordinates

surfaceMesh.uv = uvArray;

//Assign the Vertex Buffer

surfaceMesh.triangles = vertexBuffer;

//Vertex Colors Testing

surfaceMesh.colors = planetColors;

//Recalculate the Normals

//surfaceMesh.RecalculateNormals();

surfaceMesh.normals = normalArray; //Done manually...

//Recalculate Bounds

surfaceMesh.RecalculateBounds();

//After the Mesh has been created, pass it back to the MeshCollider

surface.GetComponent<MeshCollider>().sharedMesh = surfaceMesh;

//If root is ever null...Destroy!

if (root != null)

root.Destroy();

generated = true;

}

public void Destroy()

{

renderer.enabled = false;

generated = false;

}

//Merges our quadtrees!

public void MergeQuadTree()

{

if (tree == null)

return;

for (int i = 0; i < tree.Length; i++)

{

tree[i].MergeQuadTree();

tree[i].Destroy();

}

tree = null;

}

public void SubDivide()

{

tree = new QuadSurface[4];

for (int i = 0, index = 0; i < 2; i++)

{

for (int j = 0; j < 2; j++, index++)

{

//This is the line...makes perfect sense after I wrote it....

tree[index] = new QuadSurface(this, LEVELOFDETAIL, this.SUBDIVISIONS + 1, i + (this.XINDEX * 2), j + (this.ZINDEX * 2), WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, TEXTURES, QUADFACE);

}

}

Destroy();

}

}

Code (CSharp):

//SOURCE: alucardj

//http://forum.unity3d.com/conversations/procedural-textures.465272/

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class TextureGenerator

{

public Texture2D[] surfaceTextures { get; private set; }

private int textureSize;

private float noiseOffset, octaves, noiseScale;

private Gradient planetColors;

public TextureGenerator(int size, float offset, float oct, float scale, Gradient colors)

{

textureSize = size;

noiseOffset = offset;

octaves = oct;

noiseScale = scale;

planetColors = colors;

surfaceTextures = new Texture2D[6];

for (int i = 0; i < 6; i++ )

GenerateSurfaceTextures((quadFace)i);

}

void GenerateSurfaceTextures(quadFace face)

{

Texture2D texture = new Texture2D(textureSize, textureSize);

//Create the Color List that will be applied to the texture

List<Color> colorList = new List<Color>();

Color color;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[textureSize * textureSize];

// Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = 1.0f / ((float)textureSize - 1);

for (int i = 0, index = 0; i < textureSize; i++)

{

for (int j = 0; j < textureSize; j++, index++)

{

// Vertex Coordinates

float xPos = (float)j * increment - 0.5f;

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f;

// Assign Vertex Coordinates

switch (face)

{

case quadFace.TOP:

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case quadFace.BOTTOM:

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case quadFace.LEFT:

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case quadFace.RIGHT:

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case quadFace.FRONT:

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case quadFace.BACK:

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Spherify the Vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

//Get noise!

float noise = PlanetUtilities.GetNoise(vertices[index], noiseOffset, octaves, noiseScale);

// get Colour

/*if (useGreyscale)

{

colour = new Color(noise, noise, noise, 1f);

}

else

{

colour = planetColours.Evaluate(noise);

}*/

color = planetColors.Evaluate(noise);

// Add Colour to Texture Colour Array

colorList.Add(color);

}

}

// Apply Texture Colour Array to the Texture

texture.SetPixels(colorList.ToArray());

texture.wrapMode = TextureWrapMode.Clamp;

texture.Apply();

surfaceTextures[(int)face] = texture;

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public enum quadFace { TOP, BOTTOM, LEFT, RIGHT, FRONT, BACK }

public static class PlanetUtilities

{

//From Catlike Coding!

public static Vector3 SmoothVertices(Vector3 vertex)

{

Vector3 v = vertex * 2f;

float x2 = v.x * v.x;

float y2 = v.y * v.y;

float z2 = v.z * v.z;

Vector3 s;

s.x = v.x * Mathf.Sqrt(1f - y2 / 2f - z2 / 2f + y2 * z2 / 3f);

s.y = v.y * Mathf.Sqrt(1f - x2 / 2f - z2 / 2f + x2 * z2 / 3f);

s.z = v.z * Mathf.Sqrt(1f - x2 / 2f - y2 / 2f + x2 * y2 / 3f);

return s;

}

// using a Simplex Noise library :

// http://cabbynode.net/2012/06/10/perlin-simplex-noise-for-c-and-xna/

public static float GetNoise(Vector3 vertex, float noiseOffset, float octaves, float noiseScale)

{

// add offset

vertex.x += noiseOffset;

vertex.y += noiseOffset;

vertex.z += noiseOffset;

// fractal noise

float amp = 1f;

float noise = 0f;

float gain = 1f;

float factor = 0f;

Vector3 calcVert;

for (int i = 0; i < octaves; i++)

{

factor += 1f / gain;

calcVert = vertex * noiseScale * gain;

noise += Noise.Noise.GetNoise(calcVert.x, calcVert.y, calcVert.z) * (amp / gain);

gain *= 2f;

}

// normalize noise by octave iteration factor

noise /= factor;

return noise;

}

public static Gradient CreateColourGradient(Gradient planetColors)

{

// using colour scale from LibNoise example : http://libnoise.sourceforge.net/tutorials/tutorial3.html

//renderer.AddGradientPoint (-1.0000, utils::Color ( 0, 0, 128, 255)); // deeps

//renderer.AddGradientPoint (-0.2500, utils::Color ( 0, 0, 255, 255)); // shallow

//renderer.AddGradientPoint ( 0.0000, utils::Color ( 0, 128, 255, 255)); // shore

//renderer.AddGradientPoint ( 0.0625, utils::Color (240, 240, 64, 255)); // sand

//renderer.AddGradientPoint ( 0.1250, utils::Color ( 32, 160, 0, 255)); // grass

//renderer.AddGradientPoint ( 0.3750, utils::Color (224, 224, 0, 255)); // dirt

//renderer.AddGradientPoint ( 0.7500, utils::Color (128, 128, 128, 255)); // rock

//renderer.AddGradientPoint ( 1.0000, utils::Color (255, 255, 255, 255)); // snow

planetColors = new Gradient();

GradientColorKey[] gck = new GradientColorKey[8];

gck[0].color = CalculateGradientColour(0, 0, 128);

gck[0].time = CalculateGradientTime(-1.0000);

gck[1].color = CalculateGradientColour(0, 0, 255);

gck[1].time = CalculateGradientTime(-0.2500);

gck[2].color = CalculateGradientColour(0, 128, 255);

gck[2].time = CalculateGradientTime(0.0000);

gck[3].color = CalculateGradientColour(240, 240, 64);

gck[3].time = CalculateGradientTime(0.0625);

gck[4].color = CalculateGradientColour(32, 160, 0);

gck[4].time = CalculateGradientTime(0.1250);

gck[5].color = CalculateGradientColour(224, 224, 0);

gck[5].time = CalculateGradientTime(0.3750);

gck[6].color = CalculateGradientColour(128, 128, 128);

gck[6].time = CalculateGradientTime(0.7500);

gck[7].color = CalculateGradientColour(255, 255, 255);

gck[7].time = CalculateGradientTime(1.0000);

GradientAlphaKey[] gak = new GradientAlphaKey[2];

gak[0].alpha = 1f;

gak[0].time = 0f;

gak[1].alpha = 1f;

gak[1].time = 1f;

planetColors.SetKeys(gck, gak);

return planetColors;

}

static Color CalculateGradientColour(int r, int g, int b)

{

return new Color((float)r / 255f, (float)g / 255f, (float)b / 255f);

}

static float CalculateGradientTime(double t)

{

return (float)((t + 1) * 0.5);

}

}

BradMick · Sep 4, 2016

Quickie update...Water shell testing.

Basically the radius of the shell is equal to:

World Radius + ( ( (World Height * Noise Scale) - 1 ) * (Water Level / 0.5) )

I've scaled the planet up all kinds of ways and that little equation has worked perfectly. So now there's undersea ares too!

Edited because I was missing the water level bit.

BradMick · Sep 4, 2016

WARNING: THIS CODE WILL CAUSE UNITY TO LOCK UP

So now that that's out of the way, here is the first pass of getting the dynamic LOD system working. Right now I'm just focused on getting it to work when you move closer to and farther away from the planet.

Here's what works...when you move closer to the planet, it subdivides...the problem is that it does it infinitely and things kind of freak out and lock up unity....BE VERY CAREFUL MOVING THE PLAYER TAGGED OBJECT CLOSER TO THE PLANET!

I need an extra set of eyes to see what I'm missing or what I've done wrong. Here's the most up to date version!

Code (CSharp):

using UnityEngine;

using System.Collections;

public class GeneratePlanet : MonoBehaviour

{

[Header("Planet Info")]

[Range(3.0f, 7.0f)] public int LOD = 3;

[Range(0.0f, 1.0f)] public float WATERLEVEL = 0.5f;

public float PLANETRADIUS = 1; //m, will eventually be km

public float WORLDHEIGHT = 0.1f;

[Header("Texture and Noise Variables")]

public int TEXTURESIZE = 256;

public float NOISESCALE = 1.45f;

public float NOISEOFFSET = 1.56f;

public int OCTAVES = 8;

[Header("Planet Colors")]

public Gradient PLANETCOLORS;

[Header("Test")]

public bool USEVERTEXCOLORS = false;

public Material vertexColors;

//The planet!

private QuadSphere planet;

//Textures!

private TextureGenerator textureGenerator;

private Texture2D[] textures;

void Start()

{

//Generate textures!

textureGenerator = new TextureGenerator(TEXTURESIZE,NOISEOFFSET, OCTAVES, NOISESCALE, PLANETCOLORS);

//Assign the textures created above to the local textures to make passing them along easier...

textures = textureGenerator.surfaceTextures;

planet = new QuadSphere("Planet1", LOD, WATERLEVEL, PLANETRADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, textures);

}

void Update()

{

for (int i = 0; i < 6; i++)

StartCoroutine(planet.Update(i));

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class QuadSphere

{

GameObject planet;

GeneratePlanet generator;

QuadSurface[] surfaces;

private int VERTSPERQUAD;

private float RADIUS;

public QuadSphere(string name, int lod, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures)

{

this.VERTSPERQUAD = (int)Mathf.Pow(2, lod) + 1;

this.RADIUS = radius;

//Initialize the array

surfaces = new QuadSurface[6];

//Create a new new QuadSurface using the specified LOD.

for (int i = 0; i < 6; i++)

{

//Sub Divisions 0, Indices = 0

surfaces[i] = new QuadSurface(lod, 0, 0, 0, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, (quadFace)i);

}

planet = new GameObject(name);

generator = planet.GetComponent<GeneratePlanet>();

for (int i = 0; i < surfaces.Length; i++)

surfaces[i].surface.transform.parent = planet.transform;

}

private void FindActiveQuadTreeSurfaces(QuadSurface surface, ref List<QuadSurface> activeSurfaces)

{

if (surface.tree == null)

activeSurfaces.Add(surface);

else

for (int i = 0; i < surface.tree.Length; i++)

FindActiveQuadTreeSurfaces(surface.tree[i], ref activeSurfaces);

}

public IEnumerator Update(int surface)

{

GameObject player = GameObject.FindGameObjectWithTag("Player");

if (player == null)

yield break;

List<QuadSurface> activeTree = new List<QuadSurface>();

FindActiveQuadTreeSurfaces(surfaces[surface], ref activeTree);

for (int i = 0; i < activeTree.Count; i++)

{

float dist = Vector3.Distance(player.transform.position, activeTree[i].surfaceMesh.bounds.ClosestPoint(player.transform.position));

if (dist > activeTree[i].RADIUS)

{

//Debug.Log("The player is: " + dist + " from the Planet.");

if (dist <= activeTree[i].RADIUS * 1000.0f || activeTree[i].ROOT == null)

{

activeTree[i].MergeQuadTree();

activeTree[i].GenerateSurfaceCoordinates();

}

else

{

activeTree[i].MergeQuadTree();

activeTree[i].ROOT.MergeQuadTree();

activeTree[i].ROOT.GenerateSurfaceCoordinates();

}

}

else if(activeTree[i].RADIUS > VERTSPERQUAD)

{

if (activeTree[i].SUBDIVISIONS <= 6)

activeTree[i].SubDivide();

else

activeTree[i].SUBDIVISIONS = 6;

}

else

{

if (activeTree[i].surface.tag != "planet")

activeTree[i].surface.tag = "Planet";

}

}

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public class QuadSurface

{

public QuadSurface ROOT;

public QuadSurface[] tree;

public GameObject surface { get; private set; }

public MeshRenderer renderer { get; private set; }

public MeshCollider collider { get; private set; }

public MeshFilter filter { get; private set; }

public Mesh surfaceMesh { get; private set; }

public int LEVELOFDETAIL, SUBDIVISIONS, XINDEX, ZINDEX;

public float WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT;

private Texture2D[] TEXTURES;

private quadFace QUADFACE;

public bool[] neighbors;

public bool generated = false;

public bool finalized = false;

//Vertex Colors Testing

GameObject planetGenerator;

GeneratePlanet generator;

Material planetMaterial;

Color[] planetColors;

Gradient planetGradient;

public QuadSurface(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

InitializeSurfaceGenerator(root, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

public QuadSurface(int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

InitializeSurfaceGenerator(null, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

void InitializeSurfaceGenerator(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

this.ROOT = root;

this.LEVELOFDETAIL = lod;

this.SUBDIVISIONS = subDivisions;

this.XINDEX = xIndex;

this.ZINDEX = zIndex;

this.WATERLEVEL = waterLevel;

this.RADIUS = radius;

this.NOISEOFFSET = noiseOffset;

this.OCTAVES = octaves;

this.NOISESCALE = noiseScale;

this.WORLDHEIGHT = worldHeight;

this.TEXTURES = textures;

this.QUADFACE = face;

//Vertex Colors Testing

planetGenerator = GameObject.Find("PlanetGenerator");

generator = planetGenerator.GetComponent<GeneratePlanet>();

planetMaterial = generator.vertexColors;

planetGradient = generator.PLANETCOLORS;

//Create the game object to which we'll attach everything to

surface = new GameObject("SUB-D: " + SUBDIVISIONS + " Face: " + QUADFACE + " (" + XINDEX + ", " + ZINDEX + ")");

//Add the mesh Renderer

renderer = surface.AddComponent<MeshRenderer>();

//Add the MeshCollider

collider = surface.AddComponent<MeshCollider>();

//Add the MeshFilter

filter = surface.AddComponent<MeshFilter>();

//Initialize the renderer

renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;

renderer.receiveShadows = true;

renderer.enabled = true;

if (generator.USEVERTEXCOLORS == false)

//Assign the generated textures to the quadSphere

surface.GetComponent<Renderer>().material.mainTexture = TEXTURES[(int)QUADFACE];

else

//Vertex Colors testing

surface.GetComponent<Renderer>().material = planetMaterial;

if (ROOT != null)

surface.transform.parent = ROOT.surface.transform;

GenerateSurfaceCoordinates();

}

public void GenerateSurfaceCoordinates()

{

//The base number of faces is 2, which means we need +1 vert to make that happen.

int vertsPerQuad = (int)Mathf.Pow(2, LEVELOFDETAIL) + 1;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[vertsPerQuad * vertsPerQuad];

//Appropriately size (and create) the Normal Array

Vector3[] normals = new Vector3[vertices.Length];

//Appropriately size (and create) the UV Array

Vector2[] uvs = new Vector2[vertices.Length];

//Vertex Colors Testing

Color[] colors = new Color[vertices.Length];

planetColors = colors;

//Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = ((1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, SUBDIVISIONS));

float uvIncrement = (1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, SUBDIVISIONS);

for (int i = 0, index = 0; i < vertsPerQuad; i++)

{

for (int j = 0; j < vertsPerQuad; j++, index++)

{

//Vertex Coordinates

float xPos = (float)j * increment - 0.5f + ((float)XINDEX / Mathf.Pow(2, SUBDIVISIONS));

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f + ((float)ZINDEX / Mathf.Pow(2, SUBDIVISIONS));

//UV Coordinates

float xUV = (float)j * uvIncrement + ((float)XINDEX / Mathf.Pow(2, SUBDIVISIONS));

float zUV = (float)i * uvIncrement + ((float)ZINDEX / Mathf.Pow(2, SUBDIVISIONS));

switch (QUADFACE)

{

case quadFace.TOP:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case quadFace.BOTTOM:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case quadFace.LEFT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case quadFace.RIGHT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case quadFace.FRONT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case quadFace.BACK:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Assign UV Coordinates

uvs[index] = new Vector2(xUV, zUV);

//Spherify the vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

float noise = PlanetUtilities.GetNoise(vertices[index], NOISEOFFSET, OCTAVES, NOISESCALE);

//Vertex Colors Testing

colors[index] = planetGradient.Evaluate(noise);

//Keep the oceans flat! - thanks alucardj!

if (noise > WATERLEVEL)

noise = (noise - WATERLEVEL) * (1.0f / (1.0f - WATERLEVEL));

else

noise = 0.0f;

vertices[index] *= RADIUS + (noise * WORLDHEIGHT);

normals[index] = vertices[index].normalized;

}

}

//Create the Surface Object

CreateSurfaceMesh(vertsPerQuad, vertices, normals, uvs);

}

void CreateSurfaceMesh(int vertsPerQuad, Vector3[] vertexArray, Vector3[] normalArray, Vector2[] uvArray)

{

//If this has already been generated, enable the renderer

if (generated)

{

renderer.enabled = true;

if (ROOT != null)

ROOT.collider.enabled = false;

collider.enabled = true;

return;

}

int vertBufferSize = vertsPerQuad - 1;

//Size the vertex buffer

int[] vertexBuffer = new int[(vertBufferSize * vertBufferSize) * 6];

//Create a new Mesh using the Objects MeshFilter

surfaceMesh = surface.GetComponent<MeshFilter>().sharedMesh = new Mesh();

surfaceMesh.name = surface.name;

//Step through the Vertex Buffer

for (int triIndex = 0, vertIndex = 0, i = 0; i < vertBufferSize; i++, vertIndex++)

{

for (int j = 0; j < vertBufferSize; j++, triIndex += 6, vertIndex++)

{

// 1

// | \

// | \

// | \

// 0----2

vertexBuffer[triIndex] = vertIndex;

vertexBuffer[triIndex + 1] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 2] = vertIndex + 1;

// 1----3

// \ |

// \ |

// \|

// 2

vertexBuffer[triIndex + 3] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 4] = vertIndex + vertsPerQuad + 1;

vertexBuffer[triIndex + 5] = vertIndex + 1;

}

}

//Assign the Vertex Array from Generate Surface Coordinates to the Mesh Vertex Array

surfaceMesh.vertices = vertexArray;

//Assign the UV Coordinates

surfaceMesh.uv = uvArray;

//Assign the Vertex Buffer

surfaceMesh.triangles = vertexBuffer;

//Vertex Colors Testing

surfaceMesh.colors = planetColors;

//Recalculate the Normals

//surfaceMesh.RecalculateNormals();

surfaceMesh.normals = normalArray; //Done manually...

//Recalculate Bounds

surfaceMesh.RecalculateBounds();

//After the Mesh has been created, pass it back to the MeshCollider

surface.GetComponent<MeshCollider>().sharedMesh = surfaceMesh;

//If root is ever null...Destroy!

if (ROOT != null)

ROOT.Destroy();

generated = true;

}

public void Destroy()

{

renderer.enabled = false;

generated = false;

}

//Merges our quadtrees!

public void MergeQuadTree()

{

if (tree == null)

return;

for (int i = 0; i < tree.Length; i++)

{

tree[i].MergeQuadTree();

tree[i].Destroy();

}

tree = null;

}

public void SubDivide()

{

tree = new QuadSurface[4];

for (int i = 0, index = 0; i < 2; i++)

{

for (int j = 0; j < 2; j++, index++)

{

//This is the line...makes perfect sense after I wrote it....

tree[index] = new QuadSurface(this, LEVELOFDETAIL, this.SUBDIVISIONS + 1, i + (this.XINDEX * 2), j + (this.ZINDEX * 2), WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, TEXTURES, QUADFACE);

}

}

Destroy();

}

}

Code (CSharp):

//SOURCE: alucardj

//http://forum.unity3d.com/conversations/procedural-textures.465272/

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class TextureGenerator

{

public Texture2D[] surfaceTextures { get; private set; }

private int textureSize;

private float noiseOffset, octaves, noiseScale;

private Gradient planetColors;

public TextureGenerator(int size, float offset, float oct, float scale, Gradient colors)

{

textureSize = size;

noiseOffset = offset;

octaves = oct;

noiseScale = scale;

planetColors = colors;

surfaceTextures = new Texture2D[6];

for (int i = 0; i < 6; i++ )

GenerateSurfaceTextures((quadFace)i);

}

void GenerateSurfaceTextures(quadFace face)

{

Texture2D texture = new Texture2D(textureSize, textureSize);

//Create the Color List that will be applied to the texture

List<Color> colorList = new List<Color>();

Color color;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[textureSize * textureSize];

// Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = 1.0f / ((float)textureSize - 1);

for (int i = 0, index = 0; i < textureSize; i++)

{

for (int j = 0; j < textureSize; j++, index++)

{

// Vertex Coordinates

float xPos = (float)j * increment - 0.5f;

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f;

// Assign Vertex Coordinates

switch (face)

{

case quadFace.TOP:

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case quadFace.BOTTOM:

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case quadFace.LEFT:

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case quadFace.RIGHT:

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case quadFace.FRONT:

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case quadFace.BACK:

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Spherify the Vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

//Get noise!

float noise = PlanetUtilities.GetNoise(vertices[index], noiseOffset, octaves, noiseScale);

// get Colour

/*if (useGreyscale)

{

colour = new Color(noise, noise, noise, 1f);

}

else

{

colour = planetColours.Evaluate(noise);

}*/

color = planetColors.Evaluate(noise);

// Add Colour to Texture Colour Array

colorList.Add(color);

}

}

// Apply Texture Colour Array to the Texture

texture.SetPixels(colorList.ToArray());

texture.wrapMode = TextureWrapMode.Clamp;

texture.Apply();

surfaceTextures[(int)face] = texture;

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public enum quadFace { TOP, BOTTOM, LEFT, RIGHT, FRONT, BACK }

public static class PlanetUtilities

{

//From Catlike Coding!

public static Vector3 SmoothVertices(Vector3 vertex)

{

Vector3 v = vertex * 2f;

float x2 = v.x * v.x;

float y2 = v.y * v.y;

float z2 = v.z * v.z;

Vector3 s;

s.x = v.x * Mathf.Sqrt(1f - y2 / 2f - z2 / 2f + y2 * z2 / 3f);

s.y = v.y * Mathf.Sqrt(1f - x2 / 2f - z2 / 2f + x2 * z2 / 3f);

s.z = v.z * Mathf.Sqrt(1f - x2 / 2f - y2 / 2f + x2 * y2 / 3f);

return s;

}

// using a Simplex Noise library :

// http://cabbynode.net/2012/06/10/perlin-simplex-noise-for-c-and-xna/

public static float GetNoise(Vector3 vertex, float noiseOffset, float octaves, float noiseScale)

{

// add offset

vertex.x += noiseOffset;

vertex.y += noiseOffset;

vertex.z += noiseOffset;

// fractal noise

float amp = 1f;

float noise = 0f;

float gain = 1f;

float factor = 0f;

Vector3 calcVert;

for (int i = 0; i < octaves; i++)

{

factor += 1f / gain;

calcVert = vertex * noiseScale * gain;

noise += Noise.Noise.GetNoise(calcVert.x, calcVert.y, calcVert.z) * (amp / gain);

gain *= 2f;

}

// normalize noise by octave iteration factor

noise /= factor;

return noise;

}

public static Gradient CreateColourGradient(Gradient planetColors)

{

// using colour scale from LibNoise example : http://libnoise.sourceforge.net/tutorials/tutorial3.html

//renderer.AddGradientPoint (-1.0000, utils::Color ( 0, 0, 128, 255)); // deeps

//renderer.AddGradientPoint (-0.2500, utils::Color ( 0, 0, 255, 255)); // shallow

//renderer.AddGradientPoint ( 0.0000, utils::Color ( 0, 128, 255, 255)); // shore

//renderer.AddGradientPoint ( 0.0625, utils::Color (240, 240, 64, 255)); // sand

//renderer.AddGradientPoint ( 0.1250, utils::Color ( 32, 160, 0, 255)); // grass

//renderer.AddGradientPoint ( 0.3750, utils::Color (224, 224, 0, 255)); // dirt

//renderer.AddGradientPoint ( 0.7500, utils::Color (128, 128, 128, 255)); // rock

//renderer.AddGradientPoint ( 1.0000, utils::Color (255, 255, 255, 255)); // snow

planetColors = new Gradient();

GradientColorKey[] gck = new GradientColorKey[8];

gck[0].color = CalculateGradientColour(0, 0, 128);

gck[0].time = CalculateGradientTime(-1.0000);

gck[1].color = CalculateGradientColour(0, 0, 255);

gck[1].time = CalculateGradientTime(-0.2500);

gck[2].color = CalculateGradientColour(0, 128, 255);

gck[2].time = CalculateGradientTime(0.0000);

gck[3].color = CalculateGradientColour(240, 240, 64);

gck[3].time = CalculateGradientTime(0.0625);

gck[4].color = CalculateGradientColour(32, 160, 0);

gck[4].time = CalculateGradientTime(0.1250);

gck[5].color = CalculateGradientColour(224, 224, 0);

gck[5].time = CalculateGradientTime(0.3750);

gck[6].color = CalculateGradientColour(128, 128, 128);

gck[6].time = CalculateGradientTime(0.7500);

gck[7].color = CalculateGradientColour(255, 255, 255);

gck[7].time = CalculateGradientTime(1.0000);

GradientAlphaKey[] gak = new GradientAlphaKey[2];

gak[0].alpha = 1f;

gak[0].time = 0f;

gak[1].alpha = 1f;

gak[1].time = 1f;

planetColors.SetKeys(gck, gak);

return planetColors;

}

static Color CalculateGradientColour(int r, int g, int b)

{

return new Color((float)r / 255f, (float)g / 255f, (float)b / 255f);

}

static float CalculateGradientTime(double t)

{

return (float)((t + 1) * 0.5);

}

}

BradMick · Sep 5, 2016

So...the above warning no longer applies...well, it kind of does until I get it to start collapsing again. But, I solved the Sub-D issue I was having, mainly because I was using the wrong values before...I'm an idiot. Oh well...

Anyway, other than the fact that the sub divisions don't go away but remain, things are working pretty well. Texture coordinates and vertex coloring are still working like they should. So now to figure out how to collapse the sub divisions as you move around the world.

If anyone has any insights into how to make the collapse system work, please weigh in...I think it may be as simple as subtracting 1 from the tree with distance...but...yeah. Not sure.

New code!

Code (CSharp):

using UnityEngine;

using System.Collections;

public class GeneratePlanet : MonoBehaviour

{

[Header("Planet Info")]

[Range(3.0f, 7.0f)] public int LOD = 3;

[Range(0.0f, 10.0f)] public int MAXSUBDLEVEL = 3;

[Range(0.0f, 1.0f)] public float WATERLEVEL = 0.5f;

public float PLANETRADIUS = 1; //m, will eventually be km

public float WORLDHEIGHT = 0.1f;

[Header("Texture and Noise Variables")]

public int TEXTURESIZE = 256;

public float NOISESCALE = 1.45f;

public float NOISEOFFSET = 1.56f;

public int OCTAVES = 8;

[Header("Planet Colors")]

public Gradient PLANETCOLORS;

[Header("Test")]

public bool USEVERTEXCOLORS = false;

public Material vertexColors;

//The planet!

private QuadSphere planet;

//Textures!

private TextureGenerator textureGenerator;

private Texture2D[] textures;

void Start()

{

//Generate textures!

textureGenerator = new TextureGenerator(TEXTURESIZE,NOISEOFFSET, OCTAVES, NOISESCALE, PLANETCOLORS);

//Assign the textures created above to the local textures to make passing them along easier...

textures = textureGenerator.surfaceTextures;

planet = new QuadSphere("Planet1", LOD, WATERLEVEL, PLANETRADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, textures);

}

void Update()

{

for (int i = 0; i < 6; i++)

StartCoroutine(planet.Update(i));

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class QuadSphere

{

GameObject planet;

GameObject planetGenerator;

GeneratePlanet generator;

QuadSurface[] surfaces;

public QuadSphere(string name, int lod, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures)

{

//Initialize the array

surfaces = new QuadSurface[6];

//Create a new new QuadSurface using the specified LOD.

for (int i = 0; i < 6; i++)

{

//Sub Divisions 0, Indices = 0...this is the default!

surfaces[i] = new QuadSurface(lod, 0, 0, 0, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, (quadFace)i);

}

planet = new GameObject(name);

planetGenerator = GameObject.Find("PlanetGenerator");

generator = planetGenerator.GetComponent<GeneratePlanet>();

for (int i = 0; i < surfaces.Length; i++)

surfaces[i].surface.transform.parent = planet.transform;

}

private void FindActiveQuadTreeSurfaces(QuadSurface surface, ref List<QuadSurface> activeSurfaces)

{

if (surface.tree == null)

activeSurfaces.Add(surface);

else

for (int i = 0; i < surface.tree.Length; i++)

FindActiveQuadTreeSurfaces(surface.tree[i], ref activeSurfaces);

}

public IEnumerator Update(int surface)

{

GameObject player = GameObject.FindGameObjectWithTag("Player");

if (player == null)

yield break;

List<QuadSurface> activeTree = new List<QuadSurface>();

FindActiveQuadTreeSurfaces(surfaces[surface], ref activeTree);

for (int i = 0; i < activeTree.Count; i++)

{

float dist = Vector3.Distance(player.transform.position, activeTree[i].surfaceMesh.bounds.ClosestPoint(player.transform.position));

if (dist > activeTree[i].RADIUS)

{

//Debug.Log("The player is: " + dist + " from the Planet.");

if (dist <= activeTree[i].RADIUS * 1000.0f || activeTree[i].ROOT == null)

{

activeTree[i].MergeQuadTree();

activeTree[i].GenerateSurfaceCoordinates();

}

else

{

activeTree[i].MergeQuadTree();

activeTree[i].ROOT.MergeQuadTree();

activeTree[i].ROOT.GenerateSurfaceCoordinates();

}

}

else if(activeTree[i].SUBDIVISIONS < generator.MAXSUBDLEVEL)

{

Debug.Log("Sub-D: " + activeTree[i].SUBDIVISIONS + " < " + generator.MAXSUBDLEVEL);

activeTree[i].SubDivide();

}

else

{

if (activeTree[i].surface.tag != "planet")

activeTree[i].surface.tag = "planet";

}

}

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public class QuadSurface

{

public QuadSurface ROOT;

public QuadSurface[] tree;

public GameObject surface { get; private set; }

public MeshRenderer renderer { get; private set; }

public MeshCollider collider { get; private set; }

public MeshFilter filter { get; private set; }

public Mesh surfaceMesh { get; private set; }

public int SUBDIVISIONS { get; private set; }

public float RADIUS { get; private set; }

private int LEVELOFDETAIL, XINDEX, ZINDEX;

private float WATERLEVEL, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT;

private Texture2D[] TEXTURES;

private quadFace QUADFACE;

public bool[] neighbors;

public bool generated = false;

public bool finalized = false;

//Vertex Colors Testing

GameObject planetGenerator;

GeneratePlanet generator;

Material planetMaterial;

Color[] planetColors;

Gradient planetGradient;

public QuadSurface(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

InitializeSurfaceGenerator(root, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

public QuadSurface(int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

InitializeSurfaceGenerator(null, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

void InitializeSurfaceGenerator(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, quadFace face)

{

this.ROOT = root;

this.LEVELOFDETAIL = lod;

this.SUBDIVISIONS = subDivisions;

this.XINDEX = xIndex;

this.ZINDEX = zIndex;

this.WATERLEVEL = waterLevel;

this.RADIUS = radius;

this.NOISEOFFSET = noiseOffset;

this.OCTAVES = octaves;

this.NOISESCALE = noiseScale;

this.WORLDHEIGHT = worldHeight;

this.TEXTURES = textures;

this.QUADFACE = face;

//Vertex Colors Testing

planetGenerator = GameObject.Find("PlanetGenerator");

generator = planetGenerator.GetComponent<GeneratePlanet>();

planetMaterial = generator.vertexColors;

planetGradient = generator.PLANETCOLORS;

//Create the game object to which we'll attach everything to

surface = new GameObject("SUB-D: " + SUBDIVISIONS + " Face: " + QUADFACE + " (" + XINDEX + ", " + ZINDEX + ")");

//Add the mesh Renderer

renderer = surface.AddComponent<MeshRenderer>();

//Add the MeshCollider

collider = surface.AddComponent<MeshCollider>();

//Add the MeshFilter

filter = surface.AddComponent<MeshFilter>();

//Initialize the renderer

renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;

renderer.receiveShadows = true;

renderer.enabled = true;

if (generator.USEVERTEXCOLORS == false)

//Assign the generated textures to the quadSphere

surface.GetComponent<Renderer>().material.mainTexture = TEXTURES[(int)QUADFACE];

else

//Vertex Colors testing

surface.GetComponent<Renderer>().material = planetMaterial;

if (ROOT != null)

surface.transform.parent = ROOT.surface.transform;

GenerateSurfaceCoordinates();

}

public void GenerateSurfaceCoordinates()

{

//The base number of faces is 2, which means we need +1 vert to make that happen.

int vertsPerQuad = (int)Mathf.Pow(2, LEVELOFDETAIL) + 1;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[vertsPerQuad * vertsPerQuad];

//Appropriately size (and create) the Normal Array

Vector3[] normals = new Vector3[vertices.Length];

//Appropriately size (and create) the UV Array

Vector2[] uvs = new Vector2[vertices.Length];

//Vertex Colors Testing

Color[] colors = new Color[vertices.Length];

planetColors = colors;

//Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = ((1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, SUBDIVISIONS));

float uvIncrement = (1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, SUBDIVISIONS);

for (int i = 0, index = 0; i < vertsPerQuad; i++)

{

for (int j = 0; j < vertsPerQuad; j++, index++)

{

//Vertex Coordinates

float xPos = (float)j * increment - 0.5f + ((float)XINDEX / Mathf.Pow(2, SUBDIVISIONS));

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f + ((float)ZINDEX / Mathf.Pow(2, SUBDIVISIONS));

//UV Coordinates

float xUV = (float)j * uvIncrement + ((float)XINDEX / Mathf.Pow(2, SUBDIVISIONS));

float zUV = (float)i * uvIncrement + ((float)ZINDEX / Mathf.Pow(2, SUBDIVISIONS));

switch (QUADFACE)

{

case quadFace.TOP:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case quadFace.BOTTOM:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case quadFace.LEFT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case quadFace.RIGHT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case quadFace.FRONT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case quadFace.BACK:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Assign UV Coordinates

uvs[index] = new Vector2(xUV, zUV);

//Spherify the vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

float noise = PlanetUtilities.GetNoise(vertices[index], NOISEOFFSET, OCTAVES, NOISESCALE);

//Vertex Colors Testing

colors[index] = planetGradient.Evaluate(noise);

//Keep the oceans flat! - thanks alucardj!

if (noise > WATERLEVEL)

noise = (noise - WATERLEVEL) * (1.0f / (1.0f - WATERLEVEL));

else

noise = 0.0f;

vertices[index] *= RADIUS + (noise * WORLDHEIGHT);

normals[index] = vertices[index].normalized;

}

}

//Create the Surface Object

CreateSurfaceMesh(vertsPerQuad, vertices, normals, uvs);

}

void CreateSurfaceMesh(int vertsPerQuad, Vector3[] vertexArray, Vector3[] normalArray, Vector2[] uvArray)

{

//If this has already been generated, enable the renderer

if (generated)

{

renderer.enabled = true;

if (ROOT != null)

ROOT.collider.enabled = false;

collider.enabled = true;

return;

}

int vertBufferSize = vertsPerQuad - 1;

//Size the vertex buffer

int[] vertexBuffer = new int[(vertBufferSize * vertBufferSize) * 6];

//Create a new Mesh using the Objects MeshFilter

surfaceMesh = surface.GetComponent<MeshFilter>().sharedMesh = new Mesh();

surfaceMesh.name = surface.name;

//Step through the Vertex Buffer

for (int triIndex = 0, vertIndex = 0, i = 0; i < vertBufferSize; i++, vertIndex++)

{

for (int j = 0; j < vertBufferSize; j++, triIndex += 6, vertIndex++)

{

// 1

// | \

// | \

// | \

// 0----2

vertexBuffer[triIndex] = vertIndex;

vertexBuffer[triIndex + 1] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 2] = vertIndex + 1;

// 1----3

// \ |

// \ |

// \|

// 2

vertexBuffer[triIndex + 3] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 4] = vertIndex + vertsPerQuad + 1;

vertexBuffer[triIndex + 5] = vertIndex + 1;

}

}

//Assign the Vertex Array from Generate Surface Coordinates to the Mesh Vertex Array

surfaceMesh.vertices = vertexArray;

//Assign the UV Coordinates

surfaceMesh.uv = uvArray;

//Assign the Vertex Buffer

surfaceMesh.triangles = vertexBuffer;

//Vertex Colors Testing

surfaceMesh.colors = planetColors;

//Recalculate the Normals

//surfaceMesh.RecalculateNormals();

surfaceMesh.normals = normalArray; //Done manually...

//Recalculate Bounds

surfaceMesh.RecalculateBounds();

//After the Mesh has been created, pass it back to the MeshCollider

surface.GetComponent<MeshCollider>().sharedMesh = surfaceMesh;

//If root is ever null...Destroy!

if (ROOT != null)

ROOT.Destroy();

generated = true;

}

public void Destroy()

{

renderer.enabled = false;

generated = false;

}

//Merges our quadtrees!

public void MergeQuadTree()

{

if (tree == null)

return;

for (int i = 0; i < tree.Length; i++)

{

tree[i].MergeQuadTree();

tree[i].Destroy();

}

tree = null;

}

public void SubDivide()

{

tree = new QuadSurface[4];

for (int i = 0, index = 0; i < 2; i++)

{

for (int j = 0; j < 2; j++, index++)

{

//This is the line...makes perfect sense after I wrote it....

tree[index] = new QuadSurface(this, LEVELOFDETAIL, this.SUBDIVISIONS + 1, i + (this.XINDEX * 2), j + (this.ZINDEX * 2), WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, TEXTURES, QUADFACE);

}

}

Destroy();

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public enum quadFace { TOP, BOTTOM, LEFT, RIGHT, FRONT, BACK }

public static class PlanetUtilities

{

//From Catlike Coding!

public static Vector3 SmoothVertices(Vector3 vertex)

{

Vector3 v = vertex * 2f;

float x2 = v.x * v.x;

float y2 = v.y * v.y;

float z2 = v.z * v.z;

Vector3 s;

s.x = v.x * Mathf.Sqrt(1f - y2 / 2f - z2 / 2f + y2 * z2 / 3f);

s.y = v.y * Mathf.Sqrt(1f - x2 / 2f - z2 / 2f + x2 * z2 / 3f);

s.z = v.z * Mathf.Sqrt(1f - x2 / 2f - y2 / 2f + x2 * y2 / 3f);

return s;

}

// using a Simplex Noise library :

// http://cabbynode.net/2012/06/10/perlin-simplex-noise-for-c-and-xna/

public static float GetNoise(Vector3 vertex, float noiseOffset, float octaves, float noiseScale)

{

// add offset

vertex.x += noiseOffset;

vertex.y += noiseOffset;

vertex.z += noiseOffset;

// fractal noise

float amp = 1f;

float noise = 0f;

float gain = 1f;

float factor = 0f;

Vector3 calcVert;

for (int i = 0; i < octaves; i++)

{

factor += 1f / gain;

calcVert = vertex * noiseScale * gain;

noise += Noise.Noise.GetNoise(calcVert.x, calcVert.y, calcVert.z) * (amp / gain);

gain *= 2f;

}

// normalize noise by octave iteration factor

noise /= factor;

return noise;

}

public static Gradient CreateColourGradient(Gradient planetColors)

{

// using colour scale from LibNoise example : http://libnoise.sourceforge.net/tutorials/tutorial3.html

//renderer.AddGradientPoint (-1.0000, utils::Color ( 0, 0, 128, 255)); // deeps

//renderer.AddGradientPoint (-0.2500, utils::Color ( 0, 0, 255, 255)); // shallow

//renderer.AddGradientPoint ( 0.0000, utils::Color ( 0, 128, 255, 255)); // shore

//renderer.AddGradientPoint ( 0.0625, utils::Color (240, 240, 64, 255)); // sand

//renderer.AddGradientPoint ( 0.1250, utils::Color ( 32, 160, 0, 255)); // grass

//renderer.AddGradientPoint ( 0.3750, utils::Color (224, 224, 0, 255)); // dirt

//renderer.AddGradientPoint ( 0.7500, utils::Color (128, 128, 128, 255)); // rock

//renderer.AddGradientPoint ( 1.0000, utils::Color (255, 255, 255, 255)); // snow

planetColors = new Gradient();

GradientColorKey[] gck = new GradientColorKey[8];

gck[0].color = CalculateGradientColour(0, 0, 128);

gck[0].time = CalculateGradientTime(-1.0000);

gck[1].color = CalculateGradientColour(0, 0, 255);

gck[1].time = CalculateGradientTime(-0.2500);

gck[2].color = CalculateGradientColour(0, 128, 255);

gck[2].time = CalculateGradientTime(0.0000);

gck[3].color = CalculateGradientColour(240, 240, 64);

gck[3].time = CalculateGradientTime(0.0625);

gck[4].color = CalculateGradientColour(32, 160, 0);

gck[4].time = CalculateGradientTime(0.1250);

gck[5].color = CalculateGradientColour(224, 224, 0);

gck[5].time = CalculateGradientTime(0.3750);

gck[6].color = CalculateGradientColour(128, 128, 128);

gck[6].time = CalculateGradientTime(0.7500);

gck[7].color = CalculateGradientColour(255, 255, 255);

gck[7].time = CalculateGradientTime(1.0000);

GradientAlphaKey[] gak = new GradientAlphaKey[2];

gak[0].alpha = 1f;

gak[0].time = 0f;

gak[1].alpha = 1f;

gak[1].time = 1f;

planetColors.SetKeys(gck, gak);

return planetColors;

}

static Color CalculateGradientColour(int r, int g, int b)

{

return new Color((float)r / 255f, (float)g / 255f, (float)b / 255f);

}

static float CalculateGradientTime(double t)

{

return (float)((t + 1) * 0.5);

}

}

Code (CSharp):

//SOURCE: alucardj

//http://forum.unity3d.com/conversations/procedural-textures.465272/

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class TextureGenerator

{

public Texture2D[] surfaceTextures { get; private set; }

private int textureSize;

private float noiseOffset, octaves, noiseScale;

private Gradient planetColors;

public TextureGenerator(int size, float offset, float oct, float scale, Gradient colors)

{

textureSize = size;

noiseOffset = offset;

octaves = oct;

noiseScale = scale;

planetColors = colors;

surfaceTextures = new Texture2D[6];

for (int i = 0; i < 6; i++ )

GenerateSurfaceTextures((quadFace)i);

}

void GenerateSurfaceTextures(quadFace face)

{

Texture2D texture = new Texture2D(textureSize, textureSize);

//Create the Color List that will be applied to the texture

List<Color> colorList = new List<Color>();

Color color;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[textureSize * textureSize];

// Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = 1.0f / ((float)textureSize - 1);

for (int i = 0, index = 0; i < textureSize; i++)

{

for (int j = 0; j < textureSize; j++, index++)

{

// Vertex Coordinates

float xPos = (float)j * increment - 0.5f;

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f;

// Assign Vertex Coordinates

switch (face)

{

case quadFace.TOP:

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case quadFace.BOTTOM:

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case quadFace.LEFT:

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case quadFace.RIGHT:

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case quadFace.FRONT:

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case quadFace.BACK:

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Spherify the Vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

//Get noise!

float noise = PlanetUtilities.GetNoise(vertices[index], noiseOffset, octaves, noiseScale);

// get Colour

/*if (useGreyscale)

{

colour = new Color(noise, noise, noise, 1f);

}

else

{

colour = planetColours.Evaluate(noise);

}*/

color = planetColors.Evaluate(noise);

// Add Colour to Texture Colour Array

colorList.Add(color);

}

}

// Apply Texture Colour Array to the Texture

texture.SetPixels(colorList.ToArray());

texture.wrapMode = TextureWrapMode.Clamp;

texture.Apply();

surfaceTextures[(int)face] = texture;

}

}

BradMick · Sep 6, 2016

Okay, well...currently I'm stuck and I'm tired, so that means it's quittin' time!

Issues and what not:

1. Currently the planet sub-divides the way it's supposed to...sort of. The planet subdivides as you get closer and then collapses as you move farther away...the only issue is that it doesn't always work correctly on the collapse...Need help here. (turns out it's been doing this all along....just wasn't moving the player far enough away)

2. The subdivisions process doesn't respect the 'neighbors can only ever be one level higher than the level before it (which is gonna be super critical for avoiding tears)...need help here too.

I started a 'merge neighbors' function which is supposed to be used to poll the surrounding surfaces and control the sub division process a little bit...it's definitely not working as intended. This merge neighbors function will be the main function to handle avoiding tears, or at least the first step in that chain of events.

So...yeah, need some help here for sure.

Updated code!

Code (CSharp):

using UnityEngine;

using System.Collections;

public class GeneratePlanet : MonoBehaviour

{

[Header("Planet Info")]

[Range(3.0f, 7.0f)] public int LOD = 3;

[Range(0.0f, 10.0f)] public int MAXSUBDLEVEL = 3;

[Range(0.0f, 1.0f)] public float WATERLEVEL = 0.5f;

public float PLANETRADIUS = 1; //m, will eventually be km

public float WORLDHEIGHT = 0.1f;

[Header("Texture and Noise Variables")]

public int TEXTURESIZE = 256;

public float NOISESCALE = 1.45f;

public float NOISEOFFSET = 1.56f;

public int OCTAVES = 8;

[Header("Planet Colors")]

public Gradient PLANETCOLORS;

[Header("Test")]

public bool USEVERTEXCOLORS = false;

public Material vertexColors;

//The planet!

private QuadSphere planet;

//Textures!

private TextureGenerator textureGenerator;

private Texture2D[] textures;

void Start()

{

//Generate textures!

textureGenerator = new TextureGenerator(TEXTURESIZE,NOISEOFFSET, OCTAVES, NOISESCALE, PLANETCOLORS);

//Assign the textures created above to the local textures to make passing them along easier...

textures = textureGenerator.surfaceTextures;

planet = new QuadSphere("Planet1", LOD, WATERLEVEL, PLANETRADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, textures);

}

void Update()

{

for (int i = 0; i < 6; i++)

StartCoroutine(planet.Update(i));

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class QuadSphere

{

GameObject planet;

GameObject planetGenerator;

GeneratePlanet generator;

QuadSurface[] surfaces;

public QuadSphere(string name, int lod, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures)

{

//Initialize the array

surfaces = new QuadSurface[6];

//Create a new new QuadSurface using the specified LOD.

for (int i = 0; i < 6; i++)

{

//Sub Divisions 0, Indices = 0...this is the default!

surfaces[i] = new QuadSurface(lod, 0, 0, 0, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, (QuadFace)i);

}

planet = new GameObject(name);

planetGenerator = GameObject.Find("PlanetGenerator");

generator = planetGenerator.GetComponent<GeneratePlanet>();

//Combine the planes under a single parent

for (int i = 0; i < surfaces.Length; i++)

surfaces[i].surface.transform.parent = planet.transform;

}

private void MergeNeighbors(QuadSurface surface, Mesh neighbor, Direction neigborDirection)

{

int xIndex = surface.XINDEX, zIndex = surface.ZINDEX;

Vector3[] vertices = surface.surfaceMesh.vertices;

Vector3[] normals = surface.surfaceMesh.normals;

if (normals.Length == 0)

{

surface.surfaceMesh.RecalculateNormals();

normals = surface.surfaceMesh.normals;

}

Vector3[] neighborVertices = neighbor.vertices;

Vector3[] neighborNormals = neighbor.normals;

if (neighborNormals.Length == 0)

{

neighbor.RecalculateNormals();

neighborNormals = neighbor.normals;

}

switch(neigborDirection)

{

case Direction.NORTH:

zIndex += 1;

break;

case Direction.EAST:

xIndex += 1;

break;

case Direction.SOUTH:

zIndex -= 1;

break;

case Direction.WEST:

xIndex -= 1;

break;

}

//Missing some other stuff until I can figure this out....

surface.surfaceMesh.vertices = vertices;

surface.surfaceMesh.normals = normals;

}

private void FindActiveQuadTreeSurfaces(QuadSurface surface, ref List<QuadSurface> activeSurfaces)

{

if (surface.tree == null)

activeSurfaces.Add(surface);

else

for (int i = 0; i < surface.tree.Length; i++)

FindActiveQuadTreeSurfaces(surface.tree[i], ref activeSurfaces);

}

public IEnumerator Update(int surface)

{

GameObject player = GameObject.FindGameObjectWithTag("Player");

if (player == null)

yield break;

List<QuadSurface> activeTree = new List<QuadSurface>();

FindActiveQuadTreeSurfaces(surfaces[surface], ref activeTree);

for (int i = 0; i < activeTree.Count; i++)

{

float dist = Vector3.Distance(player.transform.position, activeTree[i].surfaceMesh.bounds.ClosestPoint(player.transform.position));

if (dist > activeTree[i].RADIUS)

{

if (dist <= activeTree[i].RADIUS * 3.0f || activeTree[i].ROOT == null)

{

activeTree[i].MergeQuadTree();

activeTree[i].GenerateSurfaceCoordinates();

}

else

{

activeTree[i].MergeQuadTree();

activeTree[i].ROOT.MergeQuadTree();

activeTree[i].ROOT.GenerateSurfaceCoordinates();

}

}

else if(activeTree[i].SUBDIVISIONS < generator.MAXSUBDLEVEL)

{

activeTree[i].SubDivide();

}

else

{

if (activeTree[i].surface.tag != "planet")

activeTree[i].surface.tag = "planet";

}

}

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

public class QuadSurface

{

public QuadSurface ROOT;

public QuadSurface[] tree;

public GameObject surface { get; private set; }

public MeshRenderer renderer { get; private set; }

public MeshCollider collider { get; private set; }

public MeshFilter filter { get; private set; }

public Mesh surfaceMesh { get; private set; }

public int SUBDIVISIONS { get; private set; }

public int XINDEX { get; private set; }

public int ZINDEX { get; private set; }

public float RADIUS { get; private set; }

private int LEVELOFDETAIL;

private float WATERLEVEL, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT;

private Texture2D[] TEXTURES;

private QuadFace QUADFACE;

public bool[] neighbors;

public bool generated = false;

public bool finalized = false;

//Vertex Colors Testing

GameObject planetGenerator;

GeneratePlanet generator;

Material planetMaterial;

Color[] planetColors;

Gradient planetGradient;

public QuadSurface(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, QuadFace face)

{

InitializeSurfaceGenerator(root, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

public QuadSurface(int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, QuadFace face)

{

InitializeSurfaceGenerator(null, lod, subDivisions, xIndex, zIndex, waterLevel, radius, noiseOffset, octaves, noiseScale, worldHeight, textures, face);

}

void InitializeSurfaceGenerator(QuadSurface root, int lod, int subDivisions, int xIndex, int zIndex, float waterLevel, float radius, float noiseOffset, float octaves, float noiseScale, float worldHeight, Texture2D[] textures, QuadFace face)

{

this.ROOT = root;

this.LEVELOFDETAIL = lod;

this.SUBDIVISIONS = subDivisions;

this.XINDEX = xIndex;

this.ZINDEX = zIndex;

this.WATERLEVEL = waterLevel;

this.RADIUS = radius;

this.NOISEOFFSET = noiseOffset;

this.OCTAVES = octaves;

this.NOISESCALE = noiseScale;

this.WORLDHEIGHT = worldHeight;

this.TEXTURES = textures;

this.QUADFACE = face;

//Vertex Colors Testing

planetGenerator = GameObject.Find("PlanetGenerator");

generator = planetGenerator.GetComponent<GeneratePlanet>();

planetMaterial = generator.vertexColors;

planetGradient = generator.PLANETCOLORS;

//Create the game object to which we'll attach everything to

surface = new GameObject("SUB-D: " + SUBDIVISIONS + " Face: " + QUADFACE + " (" + XINDEX + ", " + ZINDEX + ")");

surface.isStatic = true;

surface.layer = 8;

//Add the mesh Renderer

renderer = surface.AddComponent<MeshRenderer>();

//Add the MeshCollider

collider = surface.AddComponent<MeshCollider>();

//Add the MeshFilter

filter = surface.AddComponent<MeshFilter>();

//Initialize the renderer

renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;

renderer.receiveShadows = true;

renderer.enabled = true;

if (generator.USEVERTEXCOLORS == false)

//Assign the generated textures to the quadSphere

surface.GetComponent<Renderer>().material.mainTexture = TEXTURES[(int)QUADFACE];

else

//Vertex Colors testing

surface.GetComponent<Renderer>().material = planetMaterial;

if (ROOT != null)

surface.transform.parent = ROOT.surface.transform;

GenerateSurfaceCoordinates();

}

public void GenerateSurfaceCoordinates()

{

//The base number of faces is 2, which means we need +1 vert to make that happen.

int vertsPerQuad = (int)Mathf.Pow(2, LEVELOFDETAIL) + 1;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[vertsPerQuad * vertsPerQuad];

//Appropriately size (and create) the Normal Array

Vector3[] normals = new Vector3[vertices.Length];

//Appropriately size (and create) the UV Array

Vector2[] uvs = new Vector2[vertices.Length];

//Vertex Colors Testing

Color[] colors = new Color[vertices.Length];

planetColors = colors;

//Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = ((1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, SUBDIVISIONS));

float uvIncrement = (1.0f / Mathf.Pow(2, LEVELOFDETAIL)) / Mathf.Pow(2, SUBDIVISIONS);

for (int i = 0, index = 0; i < vertsPerQuad; i++)

{

for (int j = 0; j < vertsPerQuad; j++, index++)

{

//Vertex Coordinates

float xPos = (float)j * increment - 0.5f + ((float)XINDEX / Mathf.Pow(2, SUBDIVISIONS));

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f + ((float)ZINDEX / Mathf.Pow(2, SUBDIVISIONS));

//UV Coordinates

float xUV = (float)j * uvIncrement + ((float)XINDEX / Mathf.Pow(2, SUBDIVISIONS));

float zUV = (float)i * uvIncrement + ((float)ZINDEX / Mathf.Pow(2, SUBDIVISIONS));

switch (QUADFACE)

{

case QuadFace.TOP:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case QuadFace.BOTTOM:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case QuadFace.LEFT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case QuadFace.RIGHT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case QuadFace.FRONT:

//Assign Vertex Coordinates

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case QuadFace.BACK:

//Assign Vertex Coordinates

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Assign UV Coordinates

uvs[index] = new Vector2(xUV, zUV);

//Spherify the vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

float noise = PlanetUtilities.GetNoise(vertices[index], NOISEOFFSET, OCTAVES, NOISESCALE);

//Vertex Colors Testing

colors[index] = planetGradient.Evaluate(noise);

//Keep the oceans flat! - thanks alucardj!

if (noise > WATERLEVEL)

noise = (noise - WATERLEVEL) * (1.0f / (1.0f - WATERLEVEL));

else

noise = 0.0f;

vertices[index] *= RADIUS + (noise * WORLDHEIGHT);

//Manually compute Normals

normals[index] = vertices[index].normalized;

}

}

//Create the Surface Object

CreateSurfaceMesh(vertsPerQuad, vertices, normals, uvs);

}

void CreateSurfaceMesh(int vertsPerQuad, Vector3[] vertexArray, Vector3[] normalArray, Vector2[] uvArray)

{

//If this has already been generated, enable the renderer

if (generated)

{

renderer.enabled = true;

if (ROOT != null)

ROOT.collider.enabled = false;

collider.enabled = true;

return;

}

int vertBufferSize = vertsPerQuad - 1;

//Size the vertex buffer

int[] vertexBuffer = new int[(vertBufferSize * vertBufferSize) * 6];

//Create a new Mesh using the Objects MeshFilter

surfaceMesh = surface.GetComponent<MeshFilter>().sharedMesh = new Mesh();

surfaceMesh.name = surface.name;

//Step through the Vertex Buffer

for (int triIndex = 0, vertIndex = 0, i = 0; i < vertBufferSize; i++, vertIndex++)

{

for (int j = 0; j < vertBufferSize; j++, triIndex += 6, vertIndex++)

{

// 1

// | \

// | \

// | \

// 0----2

vertexBuffer[triIndex] = vertIndex;

vertexBuffer[triIndex + 1] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 2] = vertIndex + 1;

// 1----3

// \ |

// \ |

// \|

// 2

vertexBuffer[triIndex + 3] = vertIndex + vertsPerQuad;

vertexBuffer[triIndex + 4] = vertIndex + vertsPerQuad + 1;

vertexBuffer[triIndex + 5] = vertIndex + 1;

}

}

//Assign the Vertex Array from Generate Surface Coordinates to the Mesh Vertex Array

surfaceMesh.vertices = vertexArray;

//Assign the UV Coordinates

surfaceMesh.uv = uvArray;

//Assign the Vertex Buffer

surfaceMesh.triangles = vertexBuffer;

//Vertex Colors Testing

surfaceMesh.colors = planetColors;

//Recalculate the Normals

//surfaceMesh.RecalculateNormals();

surfaceMesh.normals = normalArray; //Done manually...

//Recalculate Bounds

surfaceMesh.RecalculateBounds();

//After the Mesh has been created, pass it back to the MeshCollider

surface.GetComponent<MeshCollider>().sharedMesh = surfaceMesh;

//If root is ever null...Destroy!

if (ROOT != null)

ROOT.Destroy();

generated = true;

}

public void Destroy()

{

renderer.enabled = false;

generated = false;

}

//Merges our quadtrees!

public void MergeQuadTree()

{

if (tree == null)

return;

for (int i = 0; i < tree.Length; i++)

{

tree[i].MergeQuadTree();

tree[i].Destroy();

}

tree = null;

}

public void SubDivide()

{

tree = new QuadSurface[4];

for (int i = 0, index = 0; i < 2; i++)

{

for (int j = 0; j < 2; j++, index++)

{

//This is the line...makes perfect sense after I wrote it....

tree[index] = new QuadSurface(this, LEVELOFDETAIL, this.SUBDIVISIONS + 1, i + (this.XINDEX * 2), j + (this.ZINDEX * 2), WATERLEVEL, RADIUS, NOISEOFFSET, OCTAVES, NOISESCALE, WORLDHEIGHT, TEXTURES, QUADFACE);

}

}

Destroy();

}

}

Code (CSharp):

using UnityEngine;

using System.Collections;

//public enum NeighborDirections { NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, NORTHWEST }

public enum Direction { NORTH, EAST, SOUTH, WEST }

public enum QuadFace { TOP, BOTTOM, LEFT, RIGHT, FRONT, BACK }

public static class PlanetUtilities

{

//From Catlike Coding!

public static Vector3 SmoothVertices(Vector3 vertex)

{

Vector3 v = vertex * 2f;

float x2 = v.x * v.x;

float y2 = v.y * v.y;

float z2 = v.z * v.z;

Vector3 s;

s.x = v.x * Mathf.Sqrt(1f - y2 / 2f - z2 / 2f + y2 * z2 / 3f);

s.y = v.y * Mathf.Sqrt(1f - x2 / 2f - z2 / 2f + x2 * z2 / 3f);

s.z = v.z * Mathf.Sqrt(1f - x2 / 2f - y2 / 2f + x2 * y2 / 3f);

return s;

}

// using a Simplex Noise library :

// http://cabbynode.net/2012/06/10/perlin-simplex-noise-for-c-and-xna/

public static float GetNoise(Vector3 vertex, float noiseOffset, float octaves, float noiseScale)

{

// add offset

vertex.x += noiseOffset;

vertex.y += noiseOffset;

vertex.z += noiseOffset;

// fractal noise

float amp = 1f;

float noise = 0f;

float gain = 1f;

float factor = 0f;

Vector3 calcVert;

for (int i = 0; i < octaves; i++)

{

factor += 1f / gain;

calcVert = vertex * noiseScale * gain;

noise += Noise.Noise.GetNoise(calcVert.x, calcVert.y, calcVert.z) * (amp / gain);

gain *= 2f;

}

// normalize noise by octave iteration factor

noise /= factor;

return noise;

}

public static Gradient CreateColourGradient(Gradient planetColors)

{

// using colour scale from LibNoise example : http://libnoise.sourceforge.net/tutorials/tutorial3.html

//renderer.AddGradientPoint (-1.0000, utils::Color ( 0, 0, 128, 255)); // deeps

//renderer.AddGradientPoint (-0.2500, utils::Color ( 0, 0, 255, 255)); // shallow

//renderer.AddGradientPoint ( 0.0000, utils::Color ( 0, 128, 255, 255)); // shore

//renderer.AddGradientPoint ( 0.0625, utils::Color (240, 240, 64, 255)); // sand

//renderer.AddGradientPoint ( 0.1250, utils::Color ( 32, 160, 0, 255)); // grass

//renderer.AddGradientPoint ( 0.3750, utils::Color (224, 224, 0, 255)); // dirt

//renderer.AddGradientPoint ( 0.7500, utils::Color (128, 128, 128, 255)); // rock

//renderer.AddGradientPoint ( 1.0000, utils::Color (255, 255, 255, 255)); // snow

planetColors = new Gradient();

GradientColorKey[] gck = new GradientColorKey[8];

gck[0].color = CalculateGradientColour(0, 0, 128);

gck[0].time = CalculateGradientTime(-1.0000);

gck[1].color = CalculateGradientColour(0, 0, 255);

gck[1].time = CalculateGradientTime(-0.2500);

gck[2].color = CalculateGradientColour(0, 128, 255);

gck[2].time = CalculateGradientTime(0.0000);

gck[3].color = CalculateGradientColour(240, 240, 64);

gck[3].time = CalculateGradientTime(0.0625);

gck[4].color = CalculateGradientColour(32, 160, 0);

gck[4].time = CalculateGradientTime(0.1250);

gck[5].color = CalculateGradientColour(224, 224, 0);

gck[5].time = CalculateGradientTime(0.3750);

gck[6].color = CalculateGradientColour(128, 128, 128);

gck[6].time = CalculateGradientTime(0.7500);

gck[7].color = CalculateGradientColour(255, 255, 255);

gck[7].time = CalculateGradientTime(1.0000);

GradientAlphaKey[] gak = new GradientAlphaKey[2];

gak[0].alpha = 1f;

gak[0].time = 0f;

gak[1].alpha = 1f;

gak[1].time = 1f;

planetColors.SetKeys(gck, gak);

return planetColors;

}

static Color CalculateGradientColour(int r, int g, int b)

{

return new Color((float)r / 255f, (float)g / 255f, (float)b / 255f);

}

static float CalculateGradientTime(double t)

{

return (float)((t + 1) * 0.5);

}

}

Code (CSharp):

//SOURCE: alucardj

//http://forum.unity3d.com/conversations/procedural-textures.465272/

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class TextureGenerator

{

public Texture2D[] surfaceTextures { get; private set; }

private int textureSize;

private float noiseOffset, octaves, noiseScale;

private Gradient planetColors;

public TextureGenerator(int size, float offset, float oct, float scale, Gradient colors)

{

textureSize = size;

noiseOffset = offset;

octaves = oct;

noiseScale = scale;

planetColors = colors;

surfaceTextures = new Texture2D[6];

for (int i = 0; i < 6; i++ )

GenerateSurfaceTextures((QuadFace)i);

}

void GenerateSurfaceTextures(QuadFace face)

{

Texture2D texture = new Texture2D(textureSize, textureSize);

//Create the Color List that will be applied to the texture

List<Color> colorList = new List<Color>();

Color color;

//Appropriately size (and create) the Vertex Array

Vector3[] vertices = new Vector3[textureSize * textureSize];

// Calculate the increment to keep the vertices constrained to a 1x1 cube.

float increment = 1.0f / ((float)textureSize - 1);

for (int i = 0, index = 0; i < textureSize; i++)

{

for (int j = 0; j < textureSize; j++, index++)

{

// Vertex Coordinates

float xPos = (float)j * increment - 0.5f;

float yPos = 0.5f;

float zPos = (float)i * increment - 0.5f;

// Assign Vertex Coordinates

switch (face)

{

case QuadFace.TOP:

vertices[index] = new Vector3(xPos, yPos, zPos);

break;

case QuadFace.BOTTOM:

vertices[index] = new Vector3(xPos, -yPos, -zPos);

break;

case QuadFace.LEFT:

vertices[index] = new Vector3(-yPos, zPos, -xPos);

break;

case QuadFace.RIGHT:

vertices[index] = new Vector3(yPos, zPos, xPos);

break;

case QuadFace.FRONT:

vertices[index] = new Vector3(-xPos, zPos, yPos);

break;

case QuadFace.BACK:

vertices[index] = new Vector3(xPos, zPos, -yPos);

break;

}

//Spherify the Vertices!

vertices[index] = PlanetUtilities.SmoothVertices(vertices[index]);

//Get noise!

float noise = PlanetUtilities.GetNoise(vertices[index], noiseOffset, octaves, noiseScale);

// get Colour

/*if (useGreyscale)

{

colour = new Color(noise, noise, noise, 1f);

}

else

{

colour = planetColours.Evaluate(noise);

}*/

color = planetColors.Evaluate(noise);

// Add Colour to Texture Colour Array

colorList.Add(color);

}

}

// Apply Texture Colour Array to the Texture

texture.SetPixels(colorList.ToArray());

texture.wrapMode = TextureWrapMode.Clamp;

texture.Apply();

surfaceTextures[(int)face] = texture;

}

}

BradMick · Sep 6, 2016

Anyone have any ideas on how to go about the above?

BradMick · Sep 7, 2016

Beuller?

AlucardJay · Sep 7, 2016

Hey, been busy. Had a quick look trying to find out what happens in QuadSurface MergeQuadTree() ;
adding this as the first line in that function :

Code (csharp):

Debug.Log( "tree.Length: " + ( tree == null ? "NULL" : tree.Length.ToString() ) );

only ever prints out NULL

Maybe investigate why QuadSurface[] tree is not populated? If I have time I'll dig deeper too.

MachoBrizzin · Nov 1, 2016

Any updates on this stuff?

BradMick · Nov 14, 2016

Sorry for the complete lack of updates. In the process of transitioning from my current job to a new one. Bought a house, moved and have been going flat out since. The last time I touched the code I was still having the issue of neighbors ignoring their neighbors subdivision level and not uniformly subdividing. Was also having issues with the trees not cleanly collapsing as you got farther away from the planet surface. The code up above is still the most current state of development as of it's date of publish. If anyone has any bright ideas on how to clean up the rough edges, please let me know! I hope to get back to work at some point in the near future, probably after the first of the year after everything kind of settles down for me.

V/R

Brad

kolbosa · Apr 13, 2017

Hello BradMick, how are your doing? We still need your updates!) Keep it up, really good work.

BradMick · Apr 17, 2017

I'm actually about done with getting the Solar System Generator up and running...once that's done I'll be re-attacking this project as well. No real ETA...I kinda code a bit, write/record music, draw, play with the kids and dog, spend time with the wife and work. I was hoping that someday someone smarter than me would be like 'oh by the way, you're a super noob and this is how it should really be done...but alas, no such help has materialized....

But yeah, once the framework for more or less realistically generating a solar system is complete, it'll be time to get into making the planets look good and also allow the player to flow from the surface to space and back again. Hooray for hobby game programmers!

BradMick · Apr 22, 2017

To prove I'm not completely dead, here's a screen shot showing the progress I've made on the Solar System Generator. This is 10 runs using Sigma Draconis as the test Star. This is a C# adaptation of source code from:

http://www.eldacur.com/~brons/NerdCorner/StarGen/StarGen.html

Once it's done I'll make it freely available (obviously) for any and everyone. This uses Accrete theory to generate 'earth like' solar systems around stars within certain parameters. I've got a lot of editor type work to do and the actual Atmosphere and planetary environment stuff to implement...I also need to put in place methods for ensuring habitable systems are generated (essentially it'll continue generating until that happens and tell you the seed that made it happen so you can then make that seed the base seed for the system). The StarGen source is able to give you only habitable, earth like and systems with twin habitable worlds. So the capability is there, I just have to implement it.

Anyway, screenshot! Slow but steady progress...makes me happy!

AnyOtherProgrammer · Jun 1, 2017

Can you please upload your assets folder?

BradMick · Jul 24, 2017

Hopefully I did this right...https://github.com/BradMick/StellarForge

There's a GitHub link with the existing scripts I've created. I provide this code as is and with the understanding that it's nowhere near complete nor is it entirely functional. It's a hodge-podge of reverse engineering, tinkering and tutorials.

References:

TiggilyBoo's Quad Tree Planet - https://github.com/Tiggilyboo/UnityQuadTreePlanet
Planetary Terrains v2
Star Gen - http://www.eldacur.com/~brons/NerdCorner/StarGen/StarGen.html
Cat Like Coding - http://catlikecoding.com/unity/tutorials/

Hopefully this helps some folks. Also, if anyone figures out how to make the subDivision code on the planet generator work before I do and get it posted, please share. It subdivides just fine, but it doesn't un-subdivide. My goal is also to have it use specialty index buffers to create seamless terrains by polling the indices of the surrounding faces.

This is actually a bit of step back because the texture stuff hasn't been rewritten (dont' even have UV's coded at the moment, so it really is bare bones) it's very much a work in progress but I figure i'd get it out to the wild rather than just keep sitting on it. Hopefully someone way smarter than me will be able to help out and get this thing lookin' and workin' nice!

V/R

Brad

MachoBrizzin · Aug 9, 2017

BradMick said: ↑

Hopefully I did this right...https://github.com/BradMick/StellarForge

There's a GitHub link with the existing scripts I've created. I provide this code as is and with the understanding that it's nowhere near complete nor is it entirely functional. It's a hodge-podge of reverse engineering, tinkering and tutorials.

References:

TiggilyBoo's Quad Tree Planet - https://github.com/Tiggilyboo/UnityQuadTreePlanet
Planetary Terrains v2
Star Gen - http://www.eldacur.com/~brons/NerdCorner/StarGen/StarGen.html
Cat Like Coding - http://catlikecoding.com/unity/tutorials/

Hopefully this helps some folks. Also, if anyone figures out how to make the subDivision code on the planet generator work before I do and get it posted, please share. It subdivides just fine, but it doesn't un-subdivide. My goal is also to have it use specialty index buffers to create seamless terrains by polling the indices of the surrounding faces.

This is actually a bit of step back because the texture stuff hasn't been rewritten (dont' even have UV's coded at the moment, so it really is bare bones) it's very much a work in progress but I figure i'd get it out to the wild rather than just keep sitting on it. Hopefully someone way smarter than me will be able to help out and get this thing lookin' and workin' nice!

V/R

Brad
Click to expand...

This is some great stuff! Thanks for sharing.

EricL2 · Sep 12, 2017

@BradMick don't know if you're still here, but is there a way to move the planet to the position of the planet generator? Unity doesn't allow modifying the planet's transform directly.

HansenDJ · Dec 10, 2017

@BradMick I only have 7 months experience with Unity and with C# and practically programming in general, just the basics, so it's hard for me to follow along with this post. I really want to be able to randomly generate planets that you can walk on and this is just what I was looking for, except I wanted it to look more realistic than this but this good enough. I was just wondering if you could post how to apply all of this stuff to a new project to make it function properly using the final scripts you have provided, like what objects to create and attach these scripts too, etc. It would be very much appreciated, and good job on all your work with this.

HansenDJ · Dec 10, 2017

@alucardj If you know how to apply all of these scripts to a new project to make this system function properly I would really appreciate it. I need someone to help me out so I can implement this into a game I would like to make. Thanks for your input on this subject, I'm just really new and it's hard for me to understand what you guys are talking about.

Hanowde · Feb 6, 2018

Hi, @alucardj, @BradMick and others

Thank your for sharing und showing your project code & ideas, it helped me to understand more about how to generate surfaces by using vertices in the practical work!

I have another question now...

Would your like to give me idea about how to create its ocean / water for the generated planet procedurally (spherical water or ocean object within the planet)? Maybe i could use the same idea like creating the planet oder have your any better idea?

Thank your very much!

Carvin

BradMick · Mar 18, 2018

Semi sorta back from the dead. It's about that time for me to be tinkering with this again. The focus this time around is on creating the 9 separate 'draw patterns' involved in allowing for seamless terrains.

Attached is an image showing one of the draw patterns in action with manual sub-division for testing. (the whole thing is one giant test actually). But it shows how the terrains will be connected. Once I've finished up all of the patterns, I plan on creating a 'seamStitcher' which will...well, make things seamless.

Once I've got that done, I've got to then figure out how to automate the LOD process, which is still the bane of my existence at this point. But, this is where this round of iteration is at! Someday I'll finish I think...but not today, lol, because it clearly never ends!

Code!

Code (CSharp):

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class NewTestTerrain : MonoBehaviour

{

public int testSurfLOD = 2; //Maximum surface LOD is 7 due to Unity limitations!

public int testSubDLvl = 1;

public bool central,

north,

northEast,

east,

southEast,

south,

southWest,

west,

northWest;

private int surfLOD,

subDLvl,

rowIndex,

colIndex,

vertsPerSurf,

vertBufferSize;

private Vector3[] vertexArray;

private GameObject surfaceObject;

private Mesh surfaceMesh;

private MeshCollider surfaceMeshCollider;

private MeshRenderer surfaceMeshRenderer;

private MeshFilter surfaceMeshFilter;

void Start()

{

Surface(testSurfLOD, testSubDLvl, 0, 0);

}

//Initialize the surface

void Surface(int _surfLOD, int _subDLvl, int _rowIndex, int _colIndex)

{

surfLOD = _surfLOD;

subDLvl = _subDLvl;

rowIndex = _rowIndex;

colIndex = _colIndex;

//Verts per surface will always be a power of 2 + 1...due to Unity limits, the highest

vertsPerSurf = (int)Mathf.Pow(2, surfLOD) + 1;

vertBufferSize = (int)Mathf.Pow(2, surfLOD);

surfaceObject = new GameObject("Surface Level: " + subDLvl);

surfaceMeshFilter = surfaceObject.AddComponent<MeshFilter>();

surfaceMeshCollider = surfaceObject.AddComponent<MeshCollider>();

surfaceMeshRenderer = surfaceObject.AddComponent<MeshRenderer>();

//Let's create some coordinates!

GenerateSuraceCoordinates();

}

private void GenerateSuraceCoordinates()

{

//Create the vertex array, which will hold vertex position data

vertexArray = new Vector3[vertsPerSurf * vertsPerSurf];

//Coordinates are constrained to a 1x1 plane...

float increment = (1.0f / (vertsPerSurf - 1)) / Mathf.Pow(2, subDLvl);

for (int row = 0, index = 0; row < vertsPerSurf; row++)

{

for (int col = 0; col < vertsPerSurf; col++, index++)

{

float xPos = (float)col * increment - 0.5f + (colIndex / Mathf.Pow(2, subDLvl));

float yPos = 0.0f;

float zPos = (float)row * increment - 0.5f + (rowIndex / Mathf.Pow(2, subDLvl));

vertexArray[index] = new Vector3(xPos, yPos, zPos);

}

}

//Create the surface!

GenerateSurface();

}

private void GenerateSurface()

{

int[] vertexBuffer = new int[(vertBufferSize * vertBufferSize) * 6];

surfaceMesh = surfaceMeshFilter.sharedMesh = new Mesh();

surfaceMesh.name = surfaceObject.name;

//This is the default pattern...

if (central == true)

{

for (int triIndex = 0, vertIndex = 0, row = 0; row < vertBufferSize; row++, vertIndex++)

{

for (int col = 0; col < vertBufferSize; col++, triIndex += 6, vertIndex++)

{

// +---+---+

// | \ | \ |

// 1---+---+

// | \ | \ |

// 0---2---+

vertexBuffer[triIndex] = vertIndex;

vertexBuffer[triIndex + 1] = vertIndex + vertsPerSurf;

vertexBuffer[triIndex + 2] = vertIndex + 1;

// +---+---+

// | \ | \ |

// 3---4---+

// | \ | \ |

// +---5---+

vertexBuffer[triIndex + 3] = vertIndex + vertsPerSurf;

vertexBuffer[triIndex + 4] = vertIndex + vertsPerSurf + 1;

vertexBuffer[triIndex + 5] = vertIndex + 1;

}

}

}

//Eventually we need to test if this tile is north of the central tile. We do that by checking

//the row and col indices. So, if the central tile is row 3, col 3 and north is row 4, col 3,

//then north would be rowDif = 4 - 3 = 1, colDif = 3 - 3 = 0. South would be row 2, col 3, or

//rowDif = 2 - 3 = -1, colDif = 3 - 3 = 0. But, that is the gist of the concept. Once that's

//worked out, then the SeamStitcher can be created. SeamStitcher will take find the average of

//two tiles heights and set BOTH tiles heights to this value.

if (north == true)

{

int triIndex, vertIndex, row, col;

for (triIndex = 0, vertIndex = 0, row = 0; row < vertBufferSize - 1; row++, vertIndex++)

{

for (col = 0; col < vertBufferSize; col++, triIndex += 6, vertIndex++)

{

// +---+---+

// | \ | \ |

// 1---+---+

// | \ | \ |

// 0---2---+

vertexBuffer[triIndex] = vertIndex;

vertexBuffer[triIndex + 1] = vertIndex + vertsPerSurf;

vertexBuffer[triIndex + 2] = vertIndex + 1;

// +---+---+

// | \ | \ |

// 3---4---+

// | \ | \ |

// +---5---+

vertexBuffer[triIndex + 3] = vertIndex + vertsPerSurf;

vertexBuffer[triIndex + 4] = vertIndex + vertsPerSurf + 1;

vertexBuffer[triIndex + 5] = vertIndex + 1;

//Debug.Log("----break----");

}

//Debug.Log("---break 2---");

}

//Debug.Log("vertIndex: " + vertIndex + ", triIndex: " + triIndex);

for (row = vertBufferSize - 1; row < vertBufferSize; row++, vertIndex += 2)

{

for (col = 0; col < vertBufferSize; col += 2, triIndex += 9, vertIndex += 2)

{

// 1---+---+

// | \ / |

// 0---2---+

// | \ | \ |

// +---+---+

vertexBuffer[triIndex] = vertIndex;

//Debug.Log(vertexBuffer[triIndex]);

vertexBuffer[triIndex + 1] = vertIndex + vertsPerSurf;

//Debug.Log(vertexBuffer[triIndex + 1]);

vertexBuffer[triIndex + 2] = vertIndex + 1;

//Debug.Log(vertexBuffer[triIndex + 2]);

// 3---+---4

// | \ / |

// +---5---+

// | \ | \ |

// +---+---+

vertexBuffer[triIndex + 3] = vertIndex + vertsPerSurf;

//Debug.Log(vertexBuffer[triIndex + 3]);

vertexBuffer[triIndex + 4] = vertIndex + vertsPerSurf + 2;

//Debug.Log(vertexBuffer[triIndex + 4]);

vertexBuffer[triIndex + 5] = vertIndex + 1;

//Debug.Log(vertexBuffer[triIndex + 5]);

// +---+---7

// | \ / |

// +---6---8

// | \ | \ |

// +---+---+

vertexBuffer[triIndex + 6] = vertIndex + 1;

//Debug.Log(vertexBuffer[triIndex + 6]);

vertexBuffer[triIndex + 7] = vertIndex + vertsPerSurf + 2;

//Debug.Log(vertexBuffer[triIndex + 7]);

vertexBuffer[triIndex + 8] = vertIndex + 2;

//Debug.Log(vertexBuffer[triIndex + 8]);

//Debug.Log("---break 3---");

}

//Debug.Log("---break 4---");

}

//Debug.Log("vertIndex: " + vertIndex + ", triIndex: " + triIndex);

}

if (south == true)

{

int triIndex,

vertIndex,

row, col;

//Rather than use vertBufferSize for the row check, we know we ONLY want to run the

//following on the first row. So we can hard code 1...

for (triIndex = 0, vertIndex = 0, row = 0; row < 1; row++, vertIndex += 1)

{

for (col = 0; col < vertBufferSize; col += 2, triIndex += 9, vertIndex += 2)

{

// +---+---+

// | \ | \ |

// 1---2---+

// | / \ |

// 0---+---+

vertexBuffer[triIndex] = vertIndex;

//Debug.Log(vertexBuffer[triIndex]);

vertexBuffer[triIndex + 1] = vertIndex + vertsPerSurf;

//Debug.Log(vertexBuffer[triIndex + 1]);

vertexBuffer[triIndex + 2] = vertIndex + vertsPerSurf + 1;

//Debug.Log(vertexBuffer[triIndex + 2]);

// +---+---+

// | \ | \ |

// +---4---+

// | / \ |

// 3---+---5

vertexBuffer[triIndex + 3] = vertIndex;

vertexBuffer[triIndex + 4] = vertIndex + vertsPerSurf + 1;

vertexBuffer[triIndex + 5] = vertIndex + 2;

// +---+---+

// | \ | \ |

// +---6---7

// | / \ |

// +---+---8

vertexBuffer[triIndex + 6] = vertIndex + vertsPerSurf + 1;

vertexBuffer[triIndex + 7] = vertIndex + vertsPerSurf + 2;

vertexBuffer[triIndex + 8] = vertIndex + 2;

Debug.Log("----break----");

}

Debug.Log("---break 2---");

}

Debug.Log("vertBufferSize: " + vertBufferSize + ", vertIndex: " + vertIndex + ", triIndex: " + triIndex);

//Same idea as above, if we stopped at 1, then we can start at 1.

for (row = 1; row < vertBufferSize; row++, vertIndex++)

{

for (col = 0; col < vertBufferSize; col++, triIndex += 6, vertIndex++)

{

// 1---+---+

// | \ | \ |

// 0---2---+

// | / \ |

// +---+---+

vertexBuffer[triIndex] = vertIndex;

//Debug.Log(vertexBuffer[triIndex]);

vertexBuffer[triIndex + 1] = vertIndex + vertsPerSurf;

//Debug.Log(vertexBuffer[triIndex + 1]);

vertexBuffer[triIndex + 2] = vertIndex + 1;

//Debug.Log(vertexBuffer[triIndex + 2]);

// 3---4---+

// | \ | \ |

// +---5---+

// | / \ |

// +---+---+

vertexBuffer[triIndex + 3] = vertIndex + vertsPerSurf;

//Debug.Log(vertexBuffer[triIndex + 3]);

vertexBuffer[triIndex + 4] = vertIndex + vertsPerSurf + 1;

//Debug.Log(vertexBuffer[triIndex + 4]);

vertexBuffer[triIndex + 5] = vertIndex + 1;

//Debug.Log(vertexBuffer[triIndex + 5]);

//Debug.Log("---break 3---");

}

//Debug.Log("---break 4---");

}

//Debug.Log("vertIndex: " + vertIndex + ", triIndex: " + triIndex);

}

//Assign the Vertex Array from the surface to the mesh vertex array

surfaceMesh.vertices = vertexArray;

//Assign the Vertex Buffer

surfaceMesh.triangles = vertexBuffer;

//Recalculate the Normals

//terrainMesh.normals = RecalculateNormals(vertexArray);

surfaceMesh.RecalculateNormals();

//Recalculate bounds

surfaceMesh.RecalculateBounds();

//After the Mesh has been created, pass it back to the MeshCollider

//surfaceMeshCollider.sharedMesh = surfaceMesh;

}

}

bicarbon8 · Oct 18, 2018

this is quite amazing work! I've been trying to find a somewhat working (in Unity) example to start from for QuadSphere with LoD so thanks so much for posting all your code. All the examples I could find online were incomplete, ancient and in C or for XNA and with the maths of Quad trees already wrecking my head it was really crushing to try to convert them to C# and get them working. This gives me a much more achievable starting point. I've forked your GitHub repo and if I manage to get things working I'll issue a Pull Request back to you. Thanks again!

bicarbon8 · Oct 20, 2018

ok, so in the spirit of giving (and because this thread was such a HUGE help for me in getting this far with QuadTrees), I'm sharing the following implementation that I've developed. To use it, add an empty to your scene, add the QuadTree.cs script to the empty and set your starting size, distance for first subdivision (all subsequent subdivisions are at half the previous distance) and add the GameObject you'd like to use to measure distance (I used the Main Camera)

QuadTree.cs

Code (CSharp):

using System;

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

public class QuadTree : MonoBehaviour

{

public float Size;

public GameObject Player;

public float SubdivisionDistance;

private MeshFilter _meshFilter;

private MeshCollider _meshCollider;

private MeshRenderer _meshRenderer;

private Quad _quad;

private Dictionary<string, QuadVert> _vertStore;

private void Start()

{

_meshFilter = gameObject.AddComponent<MeshFilter>();

_meshCollider = gameObject.AddComponent<MeshCollider>();

_meshRenderer = gameObject.AddComponent<MeshRenderer>();

_vertStore = new Dictionary<string, QuadVert>();

_quad = new Quad(null, QuadType.Root, 0, Size, Player, SubdivisionDistance, ref _vertStore);

Render();

}

private void Update()

{

if (_quad != null && _quad.Update())

{

Render();

}

}

private void Render()

{

List<Vector3> vertices = new List<Vector3>();

_quad.GetVertices(ref vertices);

int[] triangles = _quad.GetTriangles();

_meshFilter.mesh.Clear();

_meshFilter.mesh.vertices = vertices.ToArray();

_meshFilter.mesh.triangles = triangles;

_meshFilter.mesh.RecalculateNormals();

_meshFilter.mesh.RecalculateBounds();

}

}

Quad.cs

Code (CSharp):

using System;

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

public class Quad

{

// our immediate parent node

public Quad Parent;

// Level 0 is top level node, Level 1 is a child of the top level node

public int Level;

// Size of one edge of quad in game units

public float Size;

// Type indicates quadrant this Quad represents: TopLeft, TopRight, BottomRight, BottomLeft

public QuadType Type;

public Quad[] Children; // max of 4

public Quad[] Neighbors; // max of 4

public QuadVert[] Vertices;

public GameObject Player;

public float SubdivisionDist;

// Are we subdivided

public bool HasChildren { get { return Children != null && Children.Any(c => c != null); } }

private Dictionary<string, QuadVert> _vertLookupTable;

public Quad(Quad parent, QuadType type, int level, float size, GameObject player, float subdivisionDistance, ref Dictionary<string, QuadVert> vertLookupTable)

{

Parent = parent;

Type = type;

Level = level;

Size = size;

Player = player;

SubdivisionDist = subdivisionDistance;

_vertLookupTable = vertLookupTable;

Children = new Quad[4];

Neighbors = new Quad[4];

AddVertices();

AddNeighbors();

}

public bool Update()

{

bool updated = false;

if (Vertices.Any(v => v != null && Vector3.Distance(v.Point, Player.transform.position) <= SubdivisionDist))

{

if (!HasChildren)

{

Subdivide();

updated = true;

}

}

else

{

if (HasChildren)

{

Unify();

updated = true;

}

}

if (HasChildren)

{

foreach(Quad child in Children)

{

if (child != null)

{

updated = updated || child.Update();

}

}

}

return updated;

}

public void GetVertices(ref List<Vector3> verts)

{

if (HasChildren)

{

for (var i=0; i<Children.Length; i++)

{

var child = Children[i];

if (child != null)

{

child.GetVertices(ref verts);

}

}

}

else

{

foreach (QuadVert qp in Vertices)

{

if (qp != null)

{

verts.Add(qp.Point);

qp.Index = verts.Count - 1;

}

}

}

}

public int[] GetTriangles()

{

List<int> tris = new List<int>();

if (HasChildren)

{

for (var i=0; i<Children.Length; i++)

{

var child = Children[i];

if (child != null)

{

tris.AddRange(child.GetTriangles());

}

}

}

else

{

if (Vertices[(int)VertPos.Centre].Active)

{

// fan triangles from centre

// 6-7-8 6-7-8 6-7-8 6-7-8 6-7-8

// |\ /| |\ /| |\ /| |\ /| |\|/|

// 3 4 5 3-4 5 3 4 5 3 4-5 3 4 5

// |/ \| |/ \| |/|\| |/ \| |/ \|

// 0-1-2 or 0-1-2 or 0-1-2 or 0-1-2 or 0-1-2 or combination of...

// start with Bottom or BottomLeft Triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.BottomLeft].Index);

if (Vertices[(int)VertPos.Bottom].Active)

{

tris.Add(Vertices[(int)VertPos.Bottom].Index);

// next triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.Bottom].Index);

}

tris.Add(Vertices[(int)VertPos.BottomRight].Index);

// next do Right or RightBottom Triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.BottomRight].Index);

if (Vertices[(int)VertPos.Right].Active)

{

tris.Add(Vertices[(int)VertPos.Right].Index);

// next triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.Right].Index);

}

tris.Add(Vertices[(int)VertPos.TopRight].Index);

// next do Top or TopRight Triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.TopRight].Index);

if (Vertices[(int)VertPos.Top].Active)

{

tris.Add(Vertices[(int)VertPos.Top].Index);

// next triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.Top].Index);

}

tris.Add(Vertices[(int)VertPos.TopLeft].Index);

// finally do Left or LeftTop Triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.TopLeft].Index);

if (Vertices[(int)VertPos.Left].Active)

{

tris.Add(Vertices[(int)VertPos.Left].Index);

// next triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.Left].Index);

}

tris.Add(Vertices[(int)VertPos.BottomLeft].Index);

}

else

{

// draw diagonal triangles from corners

// 6 7 8 6-7-8

// |\ \ |

// 3 4 5 3 4 5

// | \ \|

// 0-1-2 and 0 1 2

// start with BottomLeft Triangle

tris.Add(Vertices[(int)VertPos.BottomLeft].Index);

tris.Add(Vertices[(int)VertPos.BottomRight].Index);

tris.Add(Vertices[(int)VertPos.TopLeft].Index);

// then add TopRight Triangle

tris.Add(Vertices[(int)VertPos.BottomRight].Index);

tris.Add(Vertices[(int)VertPos.TopRight].Index);

tris.Add(Vertices[(int)VertPos.TopLeft].Index);

}

}

return tris.ToArray();

}

/// <summary>

/// called when adding LoD to mesh

/// </summary>

public void Subdivide()

{

if (!HasChildren)

{

AddChildren();

ActivateVerts();

}

}

/// <summary>

/// called when removing LoD from mesh

/// </summary>

public void Unify()

{

if (HasChildren)

{

RemoveChildren();

}

}

private void AddVertices()

{

Vertices = new QuadVert[9];

switch (Type)

{

case QuadType.TopLeft:

Vertices[(int)VertPos.TopLeft] = Parent.Vertices[(int)VertPos.TopLeft];

Vertices[(int)VertPos.TopRight] = Parent.Vertices[(int)VertPos.Top];

Vertices[(int)VertPos.BottomLeft] = Parent.Vertices[(int)VertPos.Left];

Vertices[(int)VertPos.BottomRight] = Parent.Vertices[(int)VertPos.Centre];

break;

case QuadType.TopRight:

Vertices[(int)VertPos.TopLeft] = Parent.Vertices[(int)VertPos.Top];

Vertices[(int)VertPos.TopRight] = Parent.Vertices[(int)VertPos.TopRight];

Vertices[(int)VertPos.BottomLeft] = Parent.Vertices[(int)VertPos.Centre];

Vertices[(int)VertPos.BottomRight] = Parent.Vertices[(int)VertPos.Right];

break;

case QuadType.BottomLeft:

Vertices[(int)VertPos.TopLeft] = Parent.Vertices[(int)VertPos.Left];

Vertices[(int)VertPos.TopRight] = Parent.Vertices[(int)VertPos.Centre];

Vertices[(int)VertPos.BottomLeft] = Parent.Vertices[(int)VertPos.BottomLeft];

Vertices[(int)VertPos.BottomRight] = Parent.Vertices[(int)VertPos.Bottom];

break;

case QuadType.BottomRight:

Vertices[(int)VertPos.TopLeft] = Parent.Vertices[(int)VertPos.Centre];

Vertices[(int)VertPos.TopRight] = Parent.Vertices[(int)VertPos.Right];

Vertices[(int)VertPos.BottomLeft] = Parent.Vertices[(int)VertPos.Bottom];

Vertices[(int)VertPos.BottomRight] = Parent.Vertices[(int)VertPos.BottomRight];

break;

default:

// add BottomLeft QuadVert

var bottomLeft = new Vector3(-Size / 2, -Size / 2, 0);

var bottomLeftKey = JsonUtility.ToJson(bottomLeft);

if (_vertLookupTable.ContainsKey(bottomLeftKey))

{

Vertices[(int)VertPos.BottomLeft] = _vertLookupTable[bottomLeftKey];

}

else

{

Vertices[(int)VertPos.BottomLeft] = new QuadVert

{

Active = true,

Point = bottomLeft

};

_vertLookupTable.Add(bottomLeftKey, Vertices[(int)VertPos.BottomLeft]);

}

Vertices[(int)VertPos.BottomLeft].Increment(); // tracks usage for cleanup

// add BottomRight QuadVert

var bottomRight = new Vector3(Size / 2, -Size / 2, 0);

var bottomRightKey = JsonUtility.ToJson(bottomRight);

if (_vertLookupTable.ContainsKey(bottomRightKey))

{

Vertices[(int)VertPos.BottomRight] = _vertLookupTable[bottomRightKey];

}

else

{

Vertices[(int)VertPos.BottomRight] = new QuadVert

{

Active = true,

Point = bottomRight

};

_vertLookupTable.Add(bottomRightKey, Vertices[(int)VertPos.BottomRight]);

}

Vertices[(int)VertPos.BottomRight].Increment(); // tracks usage for cleanup

// add TopLeft QuadVert

var topLeft = new Vector3(-Size / 2, Size / 2, 0);

var topLeftKey = JsonUtility.ToJson(topLeft);

if (_vertLookupTable.ContainsKey(topLeftKey))

{

Vertices[(int)VertPos.TopLeft] = _vertLookupTable[topLeftKey];

}

else

{

Vertices[(int)VertPos.TopLeft] = new QuadVert

{

Active = true,

Point = topLeft

};

_vertLookupTable.Add(topLeftKey, Vertices[(int)VertPos.TopLeft]);

}

Vertices[(int)VertPos.TopLeft].Increment(); // tracks usage for cleanup

// add TopRight QuadVert

var topRight = new Vector3(Size / 2, Size / 2, 0);

var topRightKey = JsonUtility.ToJson(topRight);

if (_vertLookupTable.ContainsKey(topRightKey))

{

Vertices[(int)VertPos.TopRight] = _vertLookupTable[topRightKey];

}

else

{

Vertices[(int)VertPos.TopRight] = new QuadVert

{

Active = true,

Point = topRight

};

_vertLookupTable.Add(topRightKey, Vertices[(int)VertPos.TopRight]);

}

Vertices[(int)VertPos.TopRight].Increment(); // tracks usage for cleanup

break;

}

// add Top QuadVert

var top = new Vector3((Vertices[(int)VertPos.TopLeft].Point.x + Vertices[(int)VertPos.TopRight].Point.x) / 2, // average gives midpoint on x

Vertices[(int)VertPos.TopLeft].Point.y,

0F);

var topKey = JsonUtility.ToJson(top);

if (_vertLookupTable.ContainsKey(topKey))

{

Vertices[(int)VertPos.Top] = _vertLookupTable[topKey];

}

else

{

Vertices[(int)VertPos.Top] = new QuadVert

{

Active = false,

Point = top

};

_vertLookupTable.Add(topKey, Vertices[(int)VertPos.Top]);

}

Vertices[(int)VertPos.Top].Increment(); // tracks usage for cleanup

// add Left QuadVert

var left = new Vector3(Vertices[(int)VertPos.TopLeft].Point.x,

(Vertices[(int)VertPos.TopLeft].Point.y + Vertices[(int)VertPos.BottomLeft].Point.y) / 2, // average gives midpoint on y

0F);

var leftKey = JsonUtility.ToJson(left);

if (_vertLookupTable.ContainsKey(leftKey))

{

Vertices[(int)VertPos.Left] = _vertLookupTable[leftKey];

}

else

{

Vertices[(int)VertPos.Left] = new QuadVert

{

Active = false,

Point = left

};

_vertLookupTable.Add(leftKey, Vertices[(int)VertPos.Left]);

}

Vertices[(int)VertPos.Left].Increment(); // tracks usage for cleanup

// add Centre QuadVert

var centre = new Vector3((Vertices[(int)VertPos.TopLeft].Point.x + Vertices[(int)VertPos.TopRight].Point.x) / 2, // average gives midpoint on x

(Vertices[(int)VertPos.TopLeft].Point.y + Vertices[(int)VertPos.BottomLeft].Point.y) / 2, // average gives midpoint on y

0F);

var centreKey = JsonUtility.ToJson(centre);

if (_vertLookupTable.ContainsKey(centreKey))

{

Vertices[(int)VertPos.Centre] = _vertLookupTable[centreKey];

}

else

{

Vertices[(int)VertPos.Centre] = new QuadVert

{

Active = true,

Point = centre

};

_vertLookupTable.Add(centreKey, Vertices[(int)VertPos.Centre]);

}

Vertices[(int)VertPos.Centre].Increment(); // tracks usage for cleanup

// add Right QuadVert

var right = new Vector3(Vertices[(int)VertPos.TopRight].Point.x,

(Vertices[(int)VertPos.TopRight].Point.y + Vertices[(int)VertPos.BottomRight].Point.y) / 2, // average gives midpoint on y

0F);

var rightKey = JsonUtility.ToJson(right);

if (_vertLookupTable.ContainsKey(rightKey))

{

Vertices[(int)VertPos.Right] = _vertLookupTable[rightKey];

}

else

{

Vertices[(int)VertPos.Right] = new QuadVert

{

Active = false,

Point = right

};

_vertLookupTable.Add(rightKey, Vertices[(int)VertPos.Right]);

}

Vertices[(int)VertPos.Right].Increment(); // tracks usage for cleanup

// add Bottom QuadVert

var bottom = new Vector3((Vertices[(int)VertPos.BottomLeft].Point.x + Vertices[(int)VertPos.BottomRight].Point.x) / 2,

Vertices[(int)VertPos.BottomLeft].Point.y,

0F);

var bottomKey = JsonUtility.ToJson(bottom);

if (_vertLookupTable.ContainsKey(bottomKey))

{

Vertices[(int)VertPos.Bottom] = _vertLookupTable[bottomKey];

}

else

{

Vertices[(int)VertPos.Bottom] = new QuadVert

{

Active = false,

Point = bottom

};

_vertLookupTable.Add(bottomKey, Vertices[(int)VertPos.Bottom]);

}

Vertices[(int)VertPos.Bottom].Increment(); // tracks usage for cleanup

}

private void AddNeighbors()

{

if (Level > 0)

{

if (Parent != null)

{

switch (Type)

{

case QuadType.TopLeft: //Top Left Corner

// Right Neighbor (sibling)

Neighbors[(int)NeighborType.Right] = Parent.Children[(int)QuadType.TopRight];

// Bottom Neighbor (sibling)

Neighbors[(int)NeighborType.Bottom] = Parent.Children[(int)QuadType.BottomLeft];

break;

case QuadType.TopRight: //Top Right Corner

// Bottom neighbor (sibling)

Neighbors[(int)NeighborType.Bottom] = Parent.Children[(int)QuadType.BottomRight];

// Left neighbor (sibling)

Neighbors[(int)NeighborType.Left] = Parent.Children[(int)QuadType.TopLeft];

break;

case QuadType.BottomLeft: //Bottom Left Corner

// Top neighbor (sibling)

Neighbors[(int)NeighborType.Top] = Parent.Children[(int)QuadType.TopLeft];

// Right neighbor (sibling)

Neighbors[(int)NeighborType.Right] = Parent.Children[(int)QuadType.BottomRight];

break;

case QuadType.BottomRight: //Bottom Right Corner

// Top neighbor (sibling)

Neighbors[(int)NeighborType.Top] = Parent.Children[(int)QuadType.TopRight];

// Left neighbor (sibling)

Neighbors[(int)NeighborType.Left] = Parent.Children[(int)QuadType.BottomLeft];

break;

}

}

}

}

private void AddChildren()

{

if (Level < 7)

{

//Add bottom right (southeast) child

Children[(int)QuadType.BottomRight] = new Quad(this, QuadType.BottomRight, Level + 1, (Size / 2), Player, SubdivisionDist / 2, ref _vertLookupTable);

//Add bottom left (southwest) child

Children[(int)QuadType.BottomLeft] = new Quad(this, QuadType.BottomLeft, Level + 1, (Size / 2), Player, SubdivisionDist / 2, ref _vertLookupTable);

//Add top left (northwest) child

Children[(int)QuadType.TopLeft] = new Quad(this, QuadType.TopLeft, Level + 1, (Size / 2), Player, SubdivisionDist / 2, ref _vertLookupTable);

//Add top right (northeast) child

Children[(int)QuadType.TopRight] = new Quad(this, QuadType.TopRight, Level + 1, (Size / 2), Player, SubdivisionDist / 2, ref _vertLookupTable);

}

}

private void RemoveChildren()

{

foreach (Quad child in Children)

{

foreach (QuadVert vertex in child.Vertices)

{

vertex.Decrement();

}

}

Children = new Quad[4];

// clean up unused QuadVerts from lookup table

List<string> toBeRemovedFromTable = new List<string>();

foreach (string key in _vertLookupTable.Keys)

{

if (!_vertLookupTable[key].InUse)

{

toBeRemovedFromTable.Add(key);

}

}

foreach (string key in toBeRemovedFromTable)

{

_vertLookupTable.Remove(key);

}

}

private void ActivateVerts()

{

// on Subdivision, all edge Vertices are always enabled

Vertices[(int)VertPos.Left].Active = true;

Vertices[(int)VertPos.Top].Active = true;

Vertices[(int)VertPos.Right].Active = true;

Vertices[(int)VertPos.Bottom].Active = true;

}

private void DeactivateVerts()

{

// on Unification, all edge Vertices are always disabled

Vertices[(int)VertPos.Left].Active = false;

Vertices[(int)VertPos.Top].Active = false;

Vertices[(int)VertPos.Right].Active = false;

Vertices[(int)VertPos.Bottom].Active = false;

}

}

public class QuadVert

{

private int _usedBy;

public bool Active {get; set;}

public int Index {get; set;}

public Vector3 Point { get; set; }

public bool InUse { get { return _usedBy > 0; } }

public int Usages { get { return _usedBy; } }

public void Increment()

{

_usedBy++;

}

public void Decrement()

{

_usedBy--;

}

}

public enum QuadType

{

Root = -1, // no neighbors

BottomLeft = 0,

BottomRight = 1,

TopRight = 2,

TopLeft = 3

}

public enum NeighborType

{

Top,

Right,

Bottom,

Left

}

public enum VertPos

{

BottomLeft = 0,

Bottom = 1,

BottomRight = 2,

Left = 3,

Centre = 4,

Right = 5,

TopLeft = 6,

Top = 7,

TopRight = 8

}

bicarbon8 · Oct 20, 2018

updated for anyone following along. Hopefully this will be of use to someone in the future:
QuadTree.cs

Code (CSharp):

using System;

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

public class QuadTree : MonoBehaviour

{

public float Size;

public GameObject Player;

public float SubdivisionDistance;

public Material SurfaceMat;

public Texture2D SurfaceTex;

private MeshFilter _meshFilter;

private MeshCollider _meshCollider;

private MeshRenderer _meshRenderer;

private Quad _quad;

private Dictionary<string, QuadVert> _vertStore;

private void Start()

{

_meshFilter = gameObject.AddComponent<MeshFilter>();

_meshCollider = gameObject.AddComponent<MeshCollider>();

_meshRenderer = gameObject.AddComponent<MeshRenderer>();

_meshRenderer.material = new Material(SurfaceMat);

_vertStore = new Dictionary<string, QuadVert>();

_quad = new Quad(null, QuadType.Root, 0, Size, Player, SubdivisionDistance, ref _vertStore);

Render();

}

private void Update()

{

if (_quad != null && _quad.Update())

{

Render();

}

}

private void Render()

{

List<Vector3> vertices = new List<Vector3>();

_quad.GetVertices(ref vertices);

int[] triangles = _quad.GetTriangles();

_meshFilter.mesh.Clear();

_meshFilter.mesh.vertices = vertices.ToArray();

_meshFilter.mesh.triangles = triangles;

ApplyElevation(_meshFilter.mesh);

_meshFilter.mesh.RecalculateNormals();

_meshFilter.mesh.RecalculateBounds();

}

public void ApplyElevation(Mesh mesh)

{

// Iterate over the vertex positions and UVs of the mesh.

var vertices = mesh.vertices;

Debug.Log(string.Join(", ", SurfaceMat.GetTexturePropertyNames()));

//SurfaceMat.GetTexture(Shader.PropertyToID("_BumpMap")) as Texture2D;

for (int i = 0; i < vertices.Length; i++)

{

var heightMap = SurfaceTex;

int x = Mathf.FloorToInt(((vertices[i].x + (Size / 2)) / Size) * heightMap.width);

int y = Mathf.FloorToInt(((vertices[i].y + (Size / 2)) / Size) * heightMap.height);

Color color = heightMap.GetPixel(x, y);

// Convert the resulting color value to an elevation in meters.

float elevation = ColorToElevation(color);

vertices[i].z = elevation;

}

// Assign the new vertex positions to the mesh.

mesh.vertices = vertices;

}

public static float ColorToElevation(Color color)

{

// Convert from color channel values in 0.0-1.0 range to elevation in meters:

// https://mapzen.com/documentation/terrain-tiles/formats/#terrarium

// return (color.r * 256.0f * 256.0f + color.g * 256.0f + color.b) - 32768.0f;

return ((color.r * color.g * color.b) / 3) * 100;

}

}

Quad.cs

Code (CSharp):

using System;

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

public class Quad

{

// our immediate parent node

public Quad Parent;

// Level 0 is top level node, Level 1 is a child of the top level node

public int Level;

// Size of one edge of quad in game units

public float Size;

// Type indicates quadrant this Quad represents: TopLeft, TopRight, BottomRight, BottomLeft

public QuadType Type;

public Quad[] Children; // max of 4

public Quad[] Neighbors; // max of 4

public QuadVert[] Vertices;

public GameObject Player;

public float SubdivisionDist;

// Are we subdivided

public bool HasChildren { get { return Children != null && Children.Any(c => c != null); } }

private Dictionary<string, QuadVert> _vertLookupTable;

public Quad(Quad parent, QuadType type, int level, float size, GameObject player, float subdivisionDistance, ref Dictionary<string, QuadVert> vertLookupTable)

{

Parent = parent;

Type = type;

Level = level;

Size = size;

Player = player;

SubdivisionDist = subdivisionDistance;

_vertLookupTable = vertLookupTable;

Children = new Quad[4];

Neighbors = new Quad[4];

AddVertices();

}

public bool Update()

{

bool updated = false;

if (Vertices.Any(v => v != null && Vector3.Distance(v.Point, Player.transform.position) <= SubdivisionDist))

{

if (!HasChildren)

{

Subdivide();

updated = true;

}

}

else

{

if (HasChildren)

{

Unify();

updated = true;

}

}

if (HasChildren)

{

foreach(Quad child in Children)

{

if (child != null)

{

updated = updated || child.Update();

}

}

}

return updated;

}

public void GetVertices(ref List<Vector3> verts)

{

if (HasChildren)

{

for (var i=0; i<Children.Length; i++)

{

var child = Children[i];

if (child != null)

{

child.GetVertices(ref verts);

}

}

}

else

{

foreach (QuadVert qp in Vertices)

{

if (qp != null)

{

verts.Add(qp.Point);

qp.Index = verts.Count - 1;

}

}

}

}

public int[] GetTriangles()

{

List<int> tris = new List<int>();

if (HasChildren)

{

for (var i=0; i<Children.Length; i++)

{

var child = Children[i];

if (child != null)

{

tris.AddRange(child.GetTriangles());

}

}

}

else

{

if (Vertices[(int)VertPos.Centre].Active)

{

// fan triangles from centre

// 6-7-8 6-7-8 6-7-8 6-7-8 6-7-8

// |\ /| |\ /| |\ /| |\ /| |\|/|

// 3 4 5 3-4 5 3 4 5 3 4-5 3 4 5

// |/ \| |/ \| |/|\| |/ \| |/ \|

// 0-1-2 or 0-1-2 or 0-1-2 or 0-1-2 or 0-1-2 or combination of...

// start with Bottom or BottomLeft Triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.BottomLeft].Index);

if (Vertices[(int)VertPos.Bottom].Active)

{

tris.Add(Vertices[(int)VertPos.Bottom].Index);

// next triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.Bottom].Index);

}

tris.Add(Vertices[(int)VertPos.BottomRight].Index);

// next do Right or RightBottom Triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.BottomRight].Index);

if (Vertices[(int)VertPos.Right].Active)

{

tris.Add(Vertices[(int)VertPos.Right].Index);

// next triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.Right].Index);

}

tris.Add(Vertices[(int)VertPos.TopRight].Index);

// next do Top or TopRight Triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.TopRight].Index);

if (Vertices[(int)VertPos.Top].Active)

{

tris.Add(Vertices[(int)VertPos.Top].Index);

// next triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.Top].Index);

}

tris.Add(Vertices[(int)VertPos.TopLeft].Index);

// finally do Left or LeftTop Triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.TopLeft].Index);

if (Vertices[(int)VertPos.Left].Active)

{

tris.Add(Vertices[(int)VertPos.Left].Index);

// next triangle

tris.Add(Vertices[(int)VertPos.Centre].Index);

tris.Add(Vertices[(int)VertPos.Left].Index);

}

tris.Add(Vertices[(int)VertPos.BottomLeft].Index);

}

else

{

// draw diagonal triangles from corners

// 6 7 8 6-7-8

// |\ \ |

// 3 4 5 3 4 5

// | \ \|

// 0-1-2 and 0 1 2

// start with BottomLeft Triangle

tris.Add(Vertices[(int)VertPos.BottomLeft].Index);

tris.Add(Vertices[(int)VertPos.BottomRight].Index);

tris.Add(Vertices[(int)VertPos.TopLeft].Index);

// then add TopRight Triangle

tris.Add(Vertices[(int)VertPos.BottomRight].Index);

tris.Add(Vertices[(int)VertPos.TopRight].Index);

tris.Add(Vertices[(int)VertPos.TopLeft].Index);

}

}

return tris.ToArray();

}

/// <summary>

/// called when adding LoD to mesh

/// </summary>

public void Subdivide()

{

if (!HasChildren)

{

ActivateVerts();

AddChildren();

}

}

/// <summary>

/// called when removing LoD from mesh

/// </summary>

public void Unify()

{

if (HasChildren)

{

RemoveChildren();

DeactivateVerts();

}

}

private void AddVertices()

{

Vertices = new QuadVert[9];

switch (Type)

{

case QuadType.TopLeft:

Vertices[(int)VertPos.TopLeft] = Parent.Vertices[(int)VertPos.TopLeft];

Vertices[(int)VertPos.TopRight] = Parent.Vertices[(int)VertPos.Top];

Vertices[(int)VertPos.BottomLeft] = Parent.Vertices[(int)VertPos.Left];

Vertices[(int)VertPos.BottomRight] = Parent.Vertices[(int)VertPos.Centre];

break;

case QuadType.TopRight:

Vertices[(int)VertPos.TopLeft] = Parent.Vertices[(int)VertPos.Top];

Vertices[(int)VertPos.TopRight] = Parent.Vertices[(int)VertPos.TopRight];

Vertices[(int)VertPos.BottomLeft] = Parent.Vertices[(int)VertPos.Centre];

Vertices[(int)VertPos.BottomRight] = Parent.Vertices[(int)VertPos.Right];

break;

case QuadType.BottomLeft:

Vertices[(int)VertPos.TopLeft] = Parent.Vertices[(int)VertPos.Left];

Vertices[(int)VertPos.TopRight] = Parent.Vertices[(int)VertPos.Centre];

Vertices[(int)VertPos.BottomLeft] = Parent.Vertices[(int)VertPos.BottomLeft];

Vertices[(int)VertPos.BottomRight] = Parent.Vertices[(int)VertPos.Bottom];

break;

case QuadType.BottomRight:

Vertices[(int)VertPos.TopLeft] = Parent.Vertices[(int)VertPos.Centre];

Vertices[(int)VertPos.TopRight] = Parent.Vertices[(int)VertPos.Right];

Vertices[(int)VertPos.BottomLeft] = Parent.Vertices[(int)VertPos.Bottom];

Vertices[(int)VertPos.BottomRight] = Parent.Vertices[(int)VertPos.BottomRight];

break;

default:

// add BottomLeft QuadVert

var bottomLeft = new Vector3(-Size / 2, -Size / 2, 0);

var bottomLeftKey = JsonUtility.ToJson(bottomLeft);

if (_vertLookupTable.ContainsKey(bottomLeftKey))

{

Vertices[(int)VertPos.BottomLeft] = _vertLookupTable[bottomLeftKey];

}

else

{

Vertices[(int)VertPos.BottomLeft] = new QuadVert

{

Active = true,

Point = bottomLeft

};

_vertLookupTable.Add(bottomLeftKey, Vertices[(int)VertPos.BottomLeft]);

}

// add BottomRight QuadVert

var bottomRight = new Vector3(Size / 2, -Size / 2, 0);

var bottomRightKey = JsonUtility.ToJson(bottomRight);

if (_vertLookupTable.ContainsKey(bottomRightKey))

{

Vertices[(int)VertPos.BottomRight] = _vertLookupTable[bottomRightKey];

}

else

{

Vertices[(int)VertPos.BottomRight] = new QuadVert

{

Active = true,

Point = bottomRight

};

_vertLookupTable.Add(bottomRightKey, Vertices[(int)VertPos.BottomRight]);

}

// add TopLeft QuadVert

var topLeft = new Vector3(-Size / 2, Size / 2, 0);

var topLeftKey = JsonUtility.ToJson(topLeft);

if (_vertLookupTable.ContainsKey(topLeftKey))

{

Vertices[(int)VertPos.TopLeft] = _vertLookupTable[topLeftKey];

}

else

{

Vertices[(int)VertPos.TopLeft] = new QuadVert

{

Active = true,

Point = topLeft

};

_vertLookupTable.Add(topLeftKey, Vertices[(int)VertPos.TopLeft]);

}

// add TopRight QuadVert

var topRight = new Vector3(Size / 2, Size / 2, 0);

var topRightKey = JsonUtility.ToJson(topRight);

if (_vertLookupTable.ContainsKey(topRightKey))

{

Vertices[(int)VertPos.TopRight] = _vertLookupTable[topRightKey];

}

else

{

Vertices[(int)VertPos.TopRight] = new QuadVert

{

Active = true,

Point = topRight

};

_vertLookupTable.Add(topRightKey, Vertices[(int)VertPos.TopRight]);

}

break;

}

// add Top QuadVert

var top = new Vector3((Vertices[(int)VertPos.TopLeft].Point.x + Vertices[(int)VertPos.TopRight].Point.x) / 2, // average gives midpoint on x

Vertices[(int)VertPos.TopLeft].Point.y,

0F);

var topKey = JsonUtility.ToJson(top);

if (_vertLookupTable.ContainsKey(topKey))

{

Vertices[(int)VertPos.Top] = _vertLookupTable[topKey];

}

else

{

Vertices[(int)VertPos.Top] = new QuadVert

{

Active = false,

Point = top

};

_vertLookupTable.Add(topKey, Vertices[(int)VertPos.Top]);

}

// add Left QuadVert

var left = new Vector3(Vertices[(int)VertPos.TopLeft].Point.x,

(Vertices[(int)VertPos.TopLeft].Point.y + Vertices[(int)VertPos.BottomLeft].Point.y) / 2, // average gives midpoint on y

0F);

var leftKey = JsonUtility.ToJson(left);

if (_vertLookupTable.ContainsKey(leftKey))

{

Vertices[(int)VertPos.Left] = _vertLookupTable[leftKey];

}

else

{

Vertices[(int)VertPos.Left] = new QuadVert

{

Active = false,

Point = left

};

_vertLookupTable.Add(leftKey, Vertices[(int)VertPos.Left]);

}

// add Centre QuadVert

var centre = new Vector3((Vertices[(int)VertPos.TopLeft].Point.x + Vertices[(int)VertPos.TopRight].Point.x) / 2, // average gives midpoint on x

(Vertices[(int)VertPos.TopLeft].Point.y + Vertices[(int)VertPos.BottomLeft].Point.y) / 2, // average gives midpoint on y

0F);

var centreKey = JsonUtility.ToJson(centre);

if (_vertLookupTable.ContainsKey(centreKey))

{

Vertices[(int)VertPos.Centre] = _vertLookupTable[centreKey];

}

else

{

Vertices[(int)VertPos.Centre] = new QuadVert

{

Active = true,

Point = centre

};

_vertLookupTable.Add(centreKey, Vertices[(int)VertPos.Centre]);

}

// add Right QuadVert

var right = new Vector3(Vertices[(int)VertPos.TopRight].Point.x,

(Vertices[(int)VertPos.TopRight].Point.y + Vertices[(int)VertPos.BottomRight].Point.y) / 2, // average gives midpoint on y

0F);

var rightKey = JsonUtility.ToJson(right);

if (_vertLookupTable.ContainsKey(rightKey))

{

Vertices[(int)VertPos.Right] = _vertLookupTable[rightKey];

}

else

{

Vertices[(int)VertPos.Right] = new QuadVert

{

Active = false,

Point = right

};

_vertLookupTable.Add(rightKey, Vertices[(int)VertPos.Right]);

}

// add Bottom QuadVert

var bottom = new Vector3((Vertices[(int)VertPos.BottomLeft].Point.x + Vertices[(int)VertPos.BottomRight].Point.x) / 2,

Vertices[(int)VertPos.BottomLeft].Point.y,

0F);

var bottomKey = JsonUtility.ToJson(bottom);

if (_vertLookupTable.ContainsKey(bottomKey))

{

Vertices[(int)VertPos.Bottom] = _vertLookupTable[bottomKey];

}

else

{

Vertices[(int)VertPos.Bottom] = new QuadVert

{

Active = false,

Point = bottom

};

_vertLookupTable.Add(bottomKey, Vertices[(int)VertPos.Bottom]);

}

// increment usages of QuadVerts so we know when we can deactivate

Vertices[(int)VertPos.BottomLeft].Increment();

Vertices[(int)VertPos.BottomRight].Increment();

Vertices[(int)VertPos.TopLeft].Increment();

Vertices[(int)VertPos.TopRight].Increment();

Vertices[(int)VertPos.Top].Increment();

Vertices[(int)VertPos.Left].Increment();

Vertices[(int)VertPos.Centre].Increment();

Vertices[(int)VertPos.Right].Increment();

Vertices[(int)VertPos.Bottom].Increment();

}

private void AddChildren()

{

if (Level < 7)

{

//Add bottom right (southeast) child

Children[(int)QuadType.BottomRight] = new Quad(this, QuadType.BottomRight, Level + 1, (Size / 2), Player, SubdivisionDist / 2, ref _vertLookupTable);

//Add bottom left (southwest) child

Children[(int)QuadType.BottomLeft] = new Quad(this, QuadType.BottomLeft, Level + 1, (Size / 2), Player, SubdivisionDist / 2, ref _vertLookupTable);

//Add top left (northwest) child

Children[(int)QuadType.TopLeft] = new Quad(this, QuadType.TopLeft, Level + 1, (Size / 2), Player, SubdivisionDist / 2, ref _vertLookupTable);

//Add top right (northeast) child

Children[(int)QuadType.TopRight] = new Quad(this, QuadType.TopRight, Level + 1, (Size / 2), Player, SubdivisionDist / 2, ref _vertLookupTable);

}

}

private void RemoveChildren()

{

foreach (Quad child in Children)

{

foreach (QuadVert vertex in child.Vertices)

{

vertex.Decrement();

}

}

Children = new Quad[4];

// clean up unused QuadVerts from lookup table

List<string> toBeRemovedFromTable = new List<string>();

foreach (string key in _vertLookupTable.Keys)

{

if (!_vertLookupTable[key].InUse)

{

toBeRemovedFromTable.Add(key);

}

}

foreach (string key in toBeRemovedFromTable)

{

_vertLookupTable.Remove(key);

}

}

private void ActivateVerts()

{

// on Subdivision, all edge Vertices are always enabled

Vertices[(int)VertPos.Left].Active = true;

Vertices[(int)VertPos.Top].Active = true;

Vertices[(int)VertPos.Right].Active = true;

Vertices[(int)VertPos.Bottom].Active = true;

}

private void DeactivateVerts()

{

// on Unification, all edge Vertices are always disabled

if (Vertices[(int)VertPos.Left].Usages < 2)

{

// we are the only one using it so it can safely be deactivated

Vertices[(int)VertPos.Left].Active = false;

}

if (Vertices[(int)VertPos.Top].Usages < 2)

{

// we are the only one using it so it can safely be deactivated

Vertices[(int)VertPos.Top].Active = false;

}

if (Vertices[(int)VertPos.Right].Usages < 2)

{

// we are the only one using it so it can safely be deactivated

Vertices[(int)VertPos.Right].Active = false;

}

if (Vertices[(int)VertPos.Bottom].Usages < 2)

{

// we are the only one using it so it can safely be deactivated

Vertices[(int)VertPos.Bottom].Active = false;

}

}

}

public class QuadVert

{

private int _usedBy;

public bool Active {get; set;}

public int Index {get; set;}

public Vector3 Point { get; set; }

public bool InUse { get { return _usedBy > 0; } }

public int Usages { get { return _usedBy; } }

public void Increment()

{

_usedBy++;

}

public void Decrement()

{

_usedBy--;

}

}

public enum QuadType

{

Root = -1, // no neighbors

BottomLeft = 0,

BottomRight = 1,

TopRight = 2,

TopLeft = 3

}

public enum VertPos

{

BottomLeft = 0,

Bottom = 1,

BottomRight = 2,

Left = 3,

Centre = 4,

Right = 5,

TopLeft = 6,

Top = 7,

TopRight = 8

}

bicarbon8 · Oct 29, 2018

ok, so I couldn't get the older code by @BradMick working, but I did manage to get my own implementation of a QuadSphere with level of detail support working. Hope this helps someone!

https://github.com/bicarbon8/QuadSphere

BradMick · Nov 1, 2018

Oh wow! This is fantastic! I'll have to sit down and play with this. The LOD bit is what has been kicking my butt royally! Conceptually, it seems so simple...but the implementation has been a pain in the butt! The code is rather out of date, and I've not really played with it in a long while, so I probably need to update it and reupload.

Fantastic work! and I'm glad this spawned the spirit of sharing!

Brad

bicarbon8 · Nov 6, 2018

BradMick said: ↑

Oh wow! This is fantastic! I'll have to sit down and play with this. The LOD bit is what has been kicking my butt royally! Conceptually, it seems so simple...but the implementation has been a pain in the butt! The code is rather out of date, and I've not really played with it in a long while, so I probably need to update it and reupload.

Fantastic work! and I'm glad this spawned the spirit of sharing!

Brad
Click to expand...

I've just updated the code as I realised that the entire unification process wasn't needed and the distance calculation should have only been subdividing the closest Quad and not all quads within range. This improves the performance overall. I also added UV mappings to the mesh so you can apply a sort of Cube map texture (example textures and materials uploaded too) and I've made it work wherever you place the empty object that the _QuadSphere_ script attaches to and however that empty is rotated (also works with scaling the empty). Hope this proves helpful!

bicarbon8 · Nov 28, 2018

Just wanted to let you know I've updated the QuadSphere yet again. When I added it to my Space Game I found that the scaled space script wasn't able to scale the planet properly to allow for landing on it when the sizes being used were around that of the actual Earth. Because of this I went back to the drawing board and fully redesigned my QuadSphere to use separate objects for each Quad. Because I was doing a full re-write, I also took the opportunity to create a cache of the possible triangles and to simplify the vertices generation process. I've pushed all the changes to github at: https://github.com/bicarbon8/QuadSphere and you can see a demo video at:

With all the Quads being separate objects and having their centres be at the centre of their vertices (instead of the centre of the Sphere itself), you can now independently scale each Quad. Hope this proves useful for someone!

HunterNacho338 · Apr 15, 2019

This looks great, man! You've obviously put in some work. Thanks for sharing it.

bb8_1 · Apr 5, 2020

Great work!

Soulice · Nov 3, 2020

@bicarbon8 Gorgeous! So you were able to land on your planet? What did you do to make that work? Should the capsule in your demo "land" on the planet?

Search Unity

Procedural Planet Terrain Engine

AlucardJay

BradMick

Attached Files:

planet5.png

planetGenWorkbook.zip

BradMick

BradMick

Attached Files:

planet6.png

BradMick

BradMick

BradMick

BradMick

BradMick

AlucardJay

MachoBrizzin

BradMick

kolbosa

BradMick

BradMick

AnyOtherProgrammer

BradMick

MachoBrizzin

EricL2

HansenDJ

HansenDJ

Hanowde

BradMick

bicarbon8

bicarbon8

bicarbon8

bicarbon8

BradMick

bicarbon8

bicarbon8

HunterNacho338

bb8_1

Soulice

Search Unity

Unity ID

Useful Searches

Procedural Planet Terrain Engine

Attached Files:

Attached Files: