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; } } }