void Initialize()
{
// Dont want to make 6 sided mesh filter everyime, so only called under special conditions
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
// Create a cardinal vector to be set as localUp
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
// Keep the mesh object transform transfixed to the planet's transform
meshObj.transform.parent = transform;
// Add a renderer with a default materials shader
meshObj.AddComponent <MeshRenderer>().sharedMaterial = new Material(Shader.Find("Standard"));
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
//set terrain face for each side of the cube
terrainFaces[i] = new TerrainFace(meshFilters[i].sharedMesh, resolution, directions[i]);
}
}
/// <summary>
/// Initialize the planet mesh
/// </summary>
private void Initialize()
{
shapeGenerator.UpdateSettings(shapeSettings);
colourGenerator.UpdateSettings(colourSettings);
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[MAX_FACES];
}
terrainFaces = new TerrainFace[MAX_FACES];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < MAX_FACES; ++i)
{
if (meshFilters[i] == null)
{
GameObject meshObject = new GameObject("mesh");
meshObject.transform.parent = transform;
meshObject.AddComponent <MeshRenderer>();
meshFilters[i] = meshObject.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colourSettings.planetMaterial;
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i;
meshFilters[i].gameObject.SetActive(renderFace);
}
}
void init()
{
Debug.Log("init");
if (mesh_filters == null || mesh_filters.Length == 0)
{
Debug.Log("new mesh filters");
mesh_filters = new MeshFilter[6];
}
this.terrain_faces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
//create radius of each vertex
for (int i = 0; i < vertex_radiuses.Length; i++)
{
vertex_radiuses[i] = planet_options.min + (planet_options.max - planet_options.min) * Random.Range(0f, 1f);
}
for (int i = 0; i < 6; i++)
{
if (mesh_filters[i] == null)
{
GameObject meshobj = new GameObject("mesh");
meshobj.transform.parent = transform;
meshobj.AddComponent <MeshRenderer>().sharedMaterial = new Material(Shader.Find("Standard"));
mesh_filters[i] = meshobj.AddComponent <MeshFilter>();
mesh_filters[i].mesh = new Mesh();
}
//terrain_faces[i] = new TerrainFace(mesh_filters[i].sharedMesh, res, directions[i], radius);
terrain_faces[i] = new TerrainFace(mesh_filters[i].sharedMesh, res, directions[i], planet_options);
}
}
void Initialize()
{
shapeGenerator.UpdateSettings(shapeSettings);
colorGenerator.UpdateSettings(colorSettings);
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>();
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colorSettings.planetMaterial;
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
}
}
// ********************************************************************** //
void Initialize(bool reset=false)
{
shapeGenerator.UpdateSettings(shapeSettings, reset, shapeSampleStats);
colourGenerator.UpdateSettings(colourSettings, reset, colourSampleStats);
tintColor = colourGenerator.GetTintColor();
colourLevel = colourGenerator.GetColourLevel();
saturation = colourGenerator.GetSaturation();
particleLauncher.UpdateSettings(tintColor, reset, particleSampleStats);
// only create new meshFilters when you need them
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[cubeFaces];
}
terrainFaces = new TerrainFace[cubeFaces];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back }; // one for each of the cube faces
for (int i = 0; i < cubeFaces; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent<MeshRenderer>();
meshFilters[i] = meshObj.AddComponent<MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent<MeshRenderer>().sharedMaterial = colourSettings.planetMaterial;
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
}
}
private void GenerateFaces(Vector3[] directions, Vector2[] offsets, int d, int divisions)
{
if (divisions < 0)
{
return;
}
if (meshFilters[d, divisions] == null)
{
GameObject meshObj = new GameObject("Chunk");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>().sharedMaterial = new Material(Shader.Find("Standard"));
meshFilters[d, divisions] = meshObj.AddComponent <MeshFilter>();
meshFilters[d, divisions].sharedMesh = new Mesh();
}
// Size of 0.125 has offset of 6.5f, 6.5f
// Size of 0.25 has offset of 2.5f, 2.5f
// Size of 0.5 has offset of 0.5f, 0.5f
// Size of 1 has offset of -0.5f, -0.5f
// Size of 2 has offset of -1f, -1f
Vector2 offset = offsets[divisions % 4] + new Vector2(-1.5f + Mathf.Sqrt(_divisions) / 2, -1.5f + Mathf.Sqrt(_divisions) / 2);
Mesh mesh = meshFilters[d, divisions].sharedMesh;
//float size = 0.125f;
float size = 2.0f / Mathf.Sqrt(_divisions);
TerrainFace terrainFace = new TerrainFace(shapeGenerator, mesh, resolution, directions[d], offset, size);
terrainFaces[d, divisions] = terrainFace;
GenerateFaces(directions, offsets, d, divisions - 1);
}
void Initialize()
{
if (shapeGenerator == null)
{
shapeGenerator = new shapeGenerator(shapeSettings);
}
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>().sharedMaterial = new Material(Shader.Find("Standard"));
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
}
}
void Initialize()
{
USED_SHADER = Shader.Find("Universal Render Pipeline/Lit");
shapeGenerator.UpdateSettings(shapeSettings);
colorGenerator.UpdateSettings(colorSettings);
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>();
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colorSettings.planetMaterial;
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i;
meshFilters[i].gameObject.SetActive(renderFace);
}
}
public void Initialize(ShapeGenerator shapeGenerator, ColorSettings colorSettings, Vector3 localUp, Vector3 axisA, Vector3 axisB, int resolution = 2)
{
this.shapeGenerator = shapeGenerator;
this.colorSettings = colorSettings;
CurrentFace = new TerrainFace(shapeGenerator, Mesh, resolution, localUp, axisA, axisB);
MeshRenderer.sharedMaterial = colorSettings.planetMaterial;
}
// Credit to Sebastian Lague for the following code
void Initialize()
{
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObject = new GameObject("mesh");
meshObject.transform.parent = transform;
meshObject.AddComponent <MeshRenderer>().sharedMaterial = new Material(surfaceMat);
meshFilters[i] = meshObject.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
terrainFaces[i] = new TerrainFace(meshFilters[i].sharedMesh, directions[i], size, this);
}
}
void Initialize()
{
resolution = Random.Range(3, 10);
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i].sharedMesh == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>().sharedMaterial = new Material(Shader.Find("Standard"));
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
terrainFaces[i] = new TerrainFace(meshFilters[i].sharedMesh, resolution, directions[i]);
}
//GetComponent<Renderer>().material.color = new Color(Random.Range(0f, 255f), Random.Range(0f, 255f), Random.Range(0f, 255f));
}
private void CreatTerrainFaces()
{
terrainFaces = new TerrainFace[6];
for (int i = 0; i < NumberFaces; i++)
{
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, settings.resolution, directions[i]);
}
}
void Initialize()
{
if (mMeshFiliters == null)
{
mMeshFiliters = new MeshFilter[6];
}
if (mTerrainface == null)
{
mTerrainface = new TerrainFace[6];
}
Vector3[] dirs = new Vector3[]
{
Vector3.up, Vector3.down, Vector3.right,
Vector3.forward, Vector3.back, Vector3.left,
};
for (int i = 0; i < dirs.Length; ++i)
{
if (mMeshFiliters[i] == null)
{
GameObject go = new GameObject(dirs[i].ToString());
go.transform.SetParent(this.transform);
go.transform.localPosition = Vector3.zero;
mMeshFiliters[i] = go.AddComponent <MeshFilter>();
go.AddComponent <MeshRenderer>();
}
if (mTerrainface[i] == null)
{
mTerrainface[i] = new TerrainFace();
}
mTerrainface[i].Resolution = resoultion;
mTerrainface[i].Up = dirs[i];
mMeshFiliters[i].sharedMesh = mTerrainface[i].Mesh;
}
if (mShapeGenerator == null)
{
mShapeGenerator = new PlanetShapeGenerator();
}
mShapeGenerator.Initialize(ShapeSetting);
if (mColorGenerator == null)
{
mColorGenerator = new PlanetColorGenerator();
}
mColorGenerator.Initialize(ColorSetting);
}
void Initialize()
{
shapeGenerator.UpdateSettings(shapeSettings);
colorGenerator.UpdateSettings(colorSettings);
if (meshFilters == null || meshFilters.Length == 0) //Only create meshFilter when null
{
meshFilters = new MeshFilter[6];
}
if (meshColliders == null || meshColliders.Length == 0)
{
meshColliders = new MeshCollider[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null) //Only create when empty
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.transform.position = new Vector3(0, 0, 0);
meshObj.gameObject.tag = "Gardenable";
meshObj.AddComponent <MeshRenderer>();
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
if (meshColliders[i] == null)
{
meshColliders[i] = meshObj.AddComponent <MeshCollider>();
meshObj.GetComponent <MeshCollider>().sharedMesh = null;
meshObj.GetComponent <MeshCollider>().sharedMesh = meshFilters[i].sharedMesh;
}
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colorSettings.mountainMaterial;
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, meshColliders[i],
resolution, directions[i], seed, spawnDensity, enemyPrefab, otherPrefabs, otherPrefabsWithRotation, terrainCircle,
meshFilters[i].gameObject.transform, enemyMaxNum, othersMaxNum, othersWRMaxNum, player);//Add to terrainface
//Debug.Log(transform.position);
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i;
meshFilters[i].gameObject.SetActive(renderFace);
if (meshColliders[i] != null)
{
meshColliders[i].gameObject.SetActive(renderFace);
}
}
}
void Initialize()
{
int n = CalculateN();
int n2 = n * n;
shape = new ShapeGenerator(shapeSettings);
color = new ColorGenerator(colorSettings);
if (meshFilters == null || meshFilters.Length == 0 || meshFilters.Length != n2 * 6)
{
for (int i = 0; i < meshFilters.Length; i++)
{
if (meshFilters[i])
{
DestroyImmediate(meshFilters[i].gameObject);
}
}
meshFilters = null;
meshFilters = new MeshFilter[n2 * 6];
}
if (terrainFaces == null)
{
terrainFaces = new TerrainFace[6];
}
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
MeshFilter[][] tmp = new MeshFilter[6][];
for (int i = 0; i < tmp.Length; i++)
{
tmp[i] = new MeshFilter[n2];
}
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < n2; j++)
{
if (meshFilters[i * n2 + j] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>().sharedMaterial = colorSettings.planetMaterial;
meshFilters[i * n2 + j] = meshObj.AddComponent <MeshFilter>();
meshFilters[i * n2 + j].sharedMesh = new Mesh();
}
tmp[i][j] = meshFilters[i * n2 + j];
}
terrainFaces[i] = new TerrainFace(shape, tmp[i], resolution, directions[i], n2, MAX_RES);
}
}
void Initialize()
{
shapeGenerator.UpdateSettings(shapeSettings);
colourGenerator.UpdateSettings(colourSettings);
//if (meshFilters == null || meshFilters.Length == 0 || meshFilters.Length < 6*divisions)
//{
var children = new List <GameObject>();
foreach (Transform child in gameObject.transform)
{
children.Add(child.gameObject);
}
children.ForEach(child => DestroyImmediate(child));
meshFilters = new MeshFilter[6 * divisions * divisions];
//}
terrainFaces = new TerrainFace[6 * divisions * divisions];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6 * divisions * divisions; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh" + i);
meshObj.transform.parent = transform;
meshObj.transform.localPosition = Vector3.zero;
meshObj.transform.localScale = Vector3.one;
meshObj.layer = meshObj.transform.parent.gameObject.layer;
meshObj.AddComponent <MeshRenderer>();
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colourSettings.planetMaterial;
meshFilters[i].GetComponent <MeshRenderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshFilters[i].GetComponent <MeshRenderer>().receiveShadows = false;
genFace = new bool[6 * divisions * divisions];
genFace[i] = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 2 == i / (divisions * divisions) || maskException == i;
if (genFace[i])
{
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, divisions, directions[i / (divisions * divisions)]);
}
else
{
terrainFaces[i] = null;
}
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 2 == i / (divisions * divisions) || maskException == i;
//Debug.Log(renderFace);
meshFilters[i].gameObject.SetActive(renderFace);
}
}
void Initialize()
{
int subfaceCount = (int)Mathf.Pow(2, subfaceLevel);
numberOfTerrainFaces = 6 * (subfaceCount * subfaceCount);
shapeGenerator.UpdateSettings(shapeSettings);
colorGenerator.UpdateSettings(colorSettings);
if (meshFilters != null)
{
if (meshFilters.Length != numberOfTerrainFaces)
{
for (int i = 0; i < meshFilters.Length; i++)
{
if (meshFilters[i] != null)
{
DestroyImmediate(meshFilters[i].sharedMesh);
DestroyImmediate(meshFilters[i]);
}
}
meshFilters = new MeshFilter[numberOfTerrainFaces];
}
}
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[numberOfTerrainFaces];
}
terrainFaces = new TerrainFace[numberOfTerrainFaces];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < numberOfTerrainFaces; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>();
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colorSettings.planetMaterial;
int subfaceIndex = i % (subfaceCount * subfaceCount); // subfaces
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i / (subfaceCount * subfaceCount)], subfaceIndex, subfaceCount);
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i / (subfaceCount * subfaceCount);
meshFilters[i].gameObject.SetActive(renderFace);
}
}
public Chunk(uint hashvalue, TerrainFace terrainFace, DVector3 position, double radius, int detailLevel, DVector3 localUp, DVector3 axisA, DVector3 axisB, byte corner)
{
this.hashvalue = hashvalue;
this.terrainFace = terrainFace;
this.planetScript = terrainFace.planetScript;
this.position = position;
this.radius = radius;
this.detailLevel = detailLevel;
this.localUp = localUp;
this.axisA = axisA;
this.axisB = axisB;
this.corner = corner;
this.normalizedPos = (Vector3)position.normalized; // ?
this.children = new Chunk[0]; // remove from constructor
this.neighbours = new bool[4]; // remove from constructor
}
/// <summary>
/// Executes the actions queued by other threads on the main thread. Credit to Sebastian Lague for much of the code.
/// </summary>
public void Initialize()
{
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
// Connect existing faces to the mesh filters (This is a code smell)
Transform[] faces = transform.GetChildrenWithTag("PlanetFace");
for (int i = 0; i < faces.Length; i++)
{
meshFilters[i] = faces[i].GetComponent <MeshFilter>();
}
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
// Create new game objects
GameObject meshObject = new GameObject("mesh");
meshObject.transform.parent = transform;
meshObject.transform.position = transform.position;
meshObject.tag = "PlanetFace";
meshObject.layer = LayerMask.NameToLayer("Planet");
meshObject.AddComponent <MeshRenderer>().sharedMaterial = new Material(SurfaceMat);
meshFilters[i] = meshObject.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
meshFilters[i].sharedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32; // Allow more vertices
}
else
{
// Update old game objects
if (meshFilters[i].GetComponent <MeshRenderer>() == null)
{
meshFilters[i].gameObject.AddComponent <MeshRenderer>();
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = new Material(SurfaceMat);
meshFilters[i].gameObject.layer = LayerMask.NameToLayer("Planet");
}
terrainFaces[i] = new TerrainFace(meshFilters[i].sharedMesh, directions[i], Size, this);
}
}
void Initialize()
{
colorSettings = (ColorSettings)ScriptableObject.CreateInstance("ColorSettings");
colorSettings.InitColorSettings(new Material(shader), BiomeCount);
shapeSettings = (ShapeSettings)ScriptableObject.CreateInstance("ShapeSettings");
shapeSettings.InitShapeSettings(NoiseLayerCount, PlanetRadius);
shapeGenerator.UpdateSettings(shapeSettings);
colorGenerator.UpdateSettings(colorSettings);
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
if (meshColliders == null || meshColliders.Length == 0)
{
meshColliders = new MeshCollider[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
if (transform != null)
{
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("Face " + FaceNames[i]);
meshObj.transform.parent = transform;
meshObj.transform.localPosition = Vector3.zero;
meshObj.AddComponent <MeshRenderer>();
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshColliders[i] = meshObj.AddComponent <MeshCollider>();
meshColliders[i].convex = true;
}
if (meshFilters[i].sharedMesh == null)
{
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colorSettings.planetMaterial;
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, meshColliders[i], resolution, directions[i]);
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i;
meshFilters[i].gameObject.SetActive(renderFace);
}
}
}
public void GenerateLOD()
{
float camDist = Vector3.Distance(transform.position, playercam.transform.position);
//float camAngle =
float scale = transform.lossyScale.x;
//Mesh[] meshLODs = new Mesh[];
int divisionsLOD = divisions;
int meshCoords = divisionsLOD / 2; //Automatically rounded down because of int division.
shapeGenerator.UpdateSettings(shapeSettings);
colourGenerator.UpdateSettings(colourSettings);
/* Delete all children:
* var children = new List<GameObject>();
* foreach (Transform child in gameObject.transform)
* {
* children.Add(child.gameObject);
* }
* children.ForEach(child => DestroyImmediate(child));*/
if (meshFilterLOD == null)
{
GameObject meshObj = new GameObject("meshLOD");
meshObj.transform.parent = transform;
meshObj.transform.localPosition = Vector3.zero;
meshObj.transform.localScale = Vector3.one;
meshObj.layer = meshObj.transform.parent.gameObject.layer;
meshObj.AddComponent <MeshRenderer>();
if (transform.lossyScale.magnitude < Mathf.Pow(90000, 2))
{
meshObj.GetComponent <MeshRenderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshObj.GetComponent <MeshRenderer>().receiveShadows = false;
}
meshFilterLOD = meshObj.AddComponent <MeshFilter>();
meshFilterLOD.sharedMesh = new Mesh();
}
meshFilterLOD.GetComponent <MeshRenderer>().sharedMaterial = colourSettings.planetMaterial;
terrainFaceLOD = new TerrainFace(shapeGenerator, meshFilterLOD.sharedMesh, resolution, divisionsLOD, playercam.transform.position.normalized);
terrainFaceLOD.ConstructMeshMono(meshCoords, divisionsLOD, colourGenerator, this);
//StartCoroutine(terrainFaceLOD.ConstructMeshCo(meshCoords, meshCoords, divisionsLOD, Vector3.zero, colourGenerator)); Doesn't work for some reason? Had to pass the monobehaviour into terrainFaceLOD and start the coroutine there (see above).
/* Non coroutine version:
* terrainFaceLOD.ConstructMeshCo(meshCoords, meshCoords, divisionsLOD, Vector3.zero, colourGenerator);
* terrainFaceLOD.UpdateUVs(colourGenerator, meshCoords, meshCoords); */
}
public byte[] neighbours = new byte[4]; //East, west, north, south. True if less detailed (Lower LOD)
// Constructor
public TerrainChunk(uint hashvalue, Planet planetScript, TerrainFace terrainFace, TerrainChunk[] children, Vector3 position, float radius, int detailLevel, Vector3 localUp, Vector3 axisA, Vector3 axisB, byte[] neighbours, byte corner, bool devMode = false)
{
this.hashvalue = hashvalue;
this.planetScript = planetScript;
this.terrainFace = terrainFace;
this.children = children;
this.position = position;
this.radius = radius;
this.detailLevel = detailLevel;
this.localUp = localUp;
this.axisA = axisA;
this.axisB = axisB;
this.neighbours = neighbours;
this.corner = corner;
this.normalizedPos = position.normalized;
this.devMode = devMode;
}
void Initialise()
{
shapeGenerator.UpdateSettings(shapeSettings);
colourGenerator.UpdateSettings(colourSettings);
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
for (int i = 0; i < 6; i++) //Iterate over 6 faces of cube
{
if (meshFilters[i] == null)
{
GameObject meshObject = new GameObject("mesh");
meshObject.transform.parent = transform; //Add the new meshobject to current transform
meshObject.AddComponent <MeshRenderer>();
meshObject.AddComponent <MeshCollider>();
meshFilters[i] = meshObject.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
meshObject.GetComponent <MeshCollider>().sharedMesh = meshFilters[i].sharedMesh;
meshObject.tag = "ground";
meshObject.AddComponent <Rigidbody>();
meshObject.GetComponent <Rigidbody>().isKinematic = true;
meshObject.GetComponent <Rigidbody>().useGravity = false;
Debug.Log(meshObject.GetComponent <Rigidbody>());
}
if (meshFilters[i].sharedMesh == null)
{
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colourSettings.planetMaterial;
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i;
meshFilters[i].gameObject.SetActive(renderFace);
// Debug.Log(meshFilters[i].gameObject);
//meshColliders[i] = meshFilters[i].gameObject.AddComponent<MeshCollider>() as MeshCollider;
// meshColliders[i].sharedMesh = meshFilters[i].mesh;
}
}
void Initialize()
{
if (!this.gameObject.GetComponent(typeof(Rigidbody)))
{
this.gameObject.AddComponent <Rigidbody>().mass = 1;
}
if (shapeSettings == null)
{
Debug.Log("nullshapesettings...");
}
shapeGenerator = new PlanetShapeGenerator(shapeSettings);
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>().sharedMaterial = new Material(Shader.Find("Standard"));
meshObj.AddComponent <MeshCollider>().convex = true;
MeshCollider meshCollider = meshObj.GetComponent(typeof(MeshCollider)) as MeshCollider;
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
meshCollider.sharedMesh = meshFilters[i].mesh;
meshCollider.material = shapeSettings.material;
}
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
}
}
void Initialize()
{
shapeGenerator.UpdateSettings(shapeSettings);
colorGenerator.UpdateSettings(colorSettings);
//create it once, and later update it ONLY
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6]; //a cube has 6 sided
}
terrainFaces = new TerrainFace[6];
//used as localUp or side, that the `terrainFaces[i]` use it as the base direction
Vector3[] directions =
{
Vector3.up, Vector3.down,
Vector3.left, Vector3.right,
Vector3.forward, Vector3.back
};
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh" + i);
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>();
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent <Renderer>().sharedMaterial = colorSettings.planetMaterial;
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
//For optimizing rendering faces, So now I can choose to render all or one face at the time
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i;
meshFilters[i].gameObject.SetActive(renderFace);
}
}
private void Initialize()
{
m_shapeGenerator.UpdateSettings(m_shapeSettings);
m_colorGenerator.UpdateSettings(m_colorSettings);
if (m_meshFilters == null || m_meshFilters.Length == 0)
{
m_meshFilters = new MeshFilter[6];
}
m_terrainFaces = new TerrainFace[6];
Vector3[] directions =
{
Vector3.up,
Vector3.down,
Vector3.left,
Vector3.right,
Vector3.forward,
Vector3.back
};
for (int i = 0; i < 6; i++)
{
if (m_meshFilters[i] == null || m_meshFilters[i].sharedMesh == null)
{
GameObject meshObj = new GameObject("Mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>();
m_meshFilters[i] = meshObj.AddComponent <MeshFilter>();
m_meshFilters[i].sharedMesh = new Mesh();
}
m_meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = m_colorSettings.m_planetMat;
m_terrainFaces[i] = new TerrainFace(m_shapeGenerator, m_meshFilters[i].sharedMesh, m_res, directions[i]);
bool renderFace = m_faceRenderMask == FaceRenderMask.All || (int)m_faceRenderMask - 1 == i;
m_meshFilters[i].gameObject.SetActive(renderFace);
}
}
// Initialize mesh
void Initialize()
{
// Initialize shapeGenerator
shapeGenerator.UpdateSettings(shapeSettings);
// Initialize colourGenerator
colourGenerator.UpdateSettings(colourSettings);
// Reinitialise mesh filters if array is empty
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>(); // .sharedMaterial = new Material(Shader.Find("Standard")); // mesh renderer
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
// Set material
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colourSettings.planetMaterial;
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
// Render face by face
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i;
meshFilters[i].gameObject.SetActive(renderFace);
}
}
private void GenerateFaces(Vector3[] directions, Vector2[] offsets, int d, int divisions)
{
if (divisions < 0)
{
return;
}
if (_meshFilters[d, divisions] == null)
{
GameObject meshObj = new GameObject("Chunk");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>();
_meshFilters[d, divisions] = meshObj.AddComponent <MeshFilter>();
_meshFilters[d, divisions].sharedMesh = new Mesh();
MeshCollider collider = meshObj.AddComponent <MeshCollider>();
_meshColliders[d, divisions] = collider;
collider.convex = false;
}
_meshFilters[d, divisions].GetComponent <MeshRenderer>().sharedMaterial = ColourSettings.PlanetMaterial;
// Size of 0.125 has offset of 6.5f, 6.5f
// Size of 0.25 has offset of 2.5f, 2.5f
// Size of 0.5 has offset of 0.5f, 0.5f
// Size of 1 has offset of -0.5f, -0.5f
// Size of 2 has offset of -1f, -1f
Vector2 offset = offsets[divisions % 4] + new Vector2(-1.5f + Mathf.Sqrt(_divisions) / 2, -1.5f + Mathf.Sqrt(_divisions) / 2);
Mesh mesh = _meshFilters[d, divisions].sharedMesh;
//float size = 0.125f;
float size = 2.0f / Mathf.Sqrt(_divisions);
TerrainFace terrainFace = new TerrainFace(_shapeGenerator, mesh, Resolution, directions[d], offset, size);
_terrainFaces[d, divisions] = terrainFace;
GenerateFaces(directions, offsets, d, divisions - 1);
}
public void Initialize()
{
shapeGenerator.UpdateSettings(shapeSettings);
colorGenerator.UpdateSettings(colorSettings);
if (planetMaterial == null)
{
planetMaterial = new Material(colorSettings.planetMaterial);
}
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6];
}
terrainFaces = new TerrainFace[6];
Vector3[] directions = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; ++i)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.transform.localPosition = Vector3.zero;
meshObj.AddComponent <MeshRenderer>();
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = planetMaterial; //new Material(colorSettings.planetMaterial);
//Debug.Log(meshFilters[i].mesh, meshFilters[i].mesh);
terrainFaces[i] = new TerrainFace(shapeGenerator, meshFilters[i].sharedMesh, resolution, directions[i]);
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i;
meshFilters[i].gameObject.SetActive(renderFace);
}
}
private void Initialize()
{
shapeGenerator.updateSettings(shapeSettings);
colorGenerator.updateSettings(colorSettings);
if (meshFilters == null || meshFilters.Length == 0)
{
meshFilters = new MeshFilter[6]; //Cubes have 6 surface.
}
terrainFaces = new TerrainFace[6];
Vector3[] localUpVectors = { Vector3.up, Vector3.down, Vector3.left, Vector3.right, Vector3.forward, Vector3.back };
for (int i = 0; i < 6; i++)
{
if (meshFilters[i] == null)
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.position = transform.position;
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>();
meshFilters[i] = meshObj.AddComponent <MeshFilter>();
meshFilters[i].sharedMesh = new Mesh();
}
terrainFaces[i] = new TerrainFace(transform.position, shapeGenerator, meshFilters[i].sharedMesh, resolution, localUpVectors[i]);
bool renderFace = faceRenderMask == FaceRenderMask.All || (int)faceRenderMask - 1 == i;
meshFilters[i].gameObject.SetActive(renderFace); //if this it is false, surface won't render in scene.
if (meshFilters[i].GetComponent <MeshRenderer>() != null)
{
meshFilters[i].GetComponent <MeshRenderer>().sharedMaterial = colorSettings.planetMaterial;
}
}
}
