public void CreateChunk(int x, int y, int z) { Vector3Int worldPos = new Vector3Int(x, y, z); var chunkObject = Instantiate(ChunkPrefab, new Vector3(x, y, z), Quaternion.Euler(Vector3.zero), transform) as GameObject; Chunk newChunk = chunkObject.GetComponent <Chunk>(); newChunk.pos = worldPos; newChunk.world = this; newChunk.name = $"{worldPos.x}_{worldPos.y}_{worldPos.z}"; chunks.Add(worldPos, newChunk); bool loaded = Serialization.Load(newChunk); if (loaded) { return; } var terrainGenerationMethod = new TerrainGeneration(BlocsDefinition); newChunk = terrainGenerationMethod.GenerateChunk3D(newChunk); }
void UpdateTerrains() { Vector3 cameraPosition = cam.Position; currentTerrain = (int)(cameraPosition.z / terrainSize.y); if (currentTerrain > previousTerrain) { Destroy(terrains[TerrainPosition.Bot].gameObject); int size = terrains.Count - 1; for (int i = 0; i < size; i++) { terrains[(TerrainPosition)i] = terrains[(TerrainPosition)i + 1]; } GameObject regionClone = PrefabController.CreateGameObject(PrefabController.Prefab.Terrain); Vector3 position = regionClone.transform.position; position.z = terrains[(TerrainPosition)((int)TerrainPosition.Top - 1)].Position.z + terrainSize.y; regionClone.transform.position = position; TerrainGeneration terrain = regionClone.GetComponent <TerrainGeneration>(); terrain.Setup(halfRegionSize); terrains[TerrainPosition.Top] = terrain; } previousTerrain = currentTerrain; }
/// <summary> /// Places objects randomly on a given chunk /// </summary> /// <param name="chunk"></param> public static void PlaceObjectsAtChunk(TerrainChunk chunk) { System.Random random = new System.Random(TerrainGeneration.instance.Seed + chunk.ChunkPosition.GetHashCode()); for (int i = 0; i < instance.gameObjectLayers.Length; i++) { if (!instance.gameObjectLayers[i].Enabled || chunk.ChunkObjects[i].GameObjects.Count > 0) { continue; } for (int o = 0; o < instance.gameObjectLayers[i].NumberPerChunk; o++) { float xPos = MathUtility.GetRandomNumber(random, chunk.Position.x, chunk.Position.x + TerrainGeneration.instance.ChunkSize); float zPos = MathUtility.GetRandomNumber(random, chunk.Position.z, chunk.Position.z + TerrainGeneration.instance.ChunkSize); float yPos = TerrainGeneration.SampleHeightMapWorld(xPos, zPos); if (yPos >= instance.gameObjectLayers[i].MinHeight && yPos < instance.gameObjectLayers[i].MaxHeight) { Vector3 newPosition = new Vector3(xPos, yPos, zPos); GameObject placedObject = instance.gameObjectLayers[i].ObjectsWaiting.Dequeue(); placedObject.transform.position = newPosition; placedObject.SetActive(true); chunk.ChunkObjects[i].GameObjects.Add(placedObject); } } } }
void generatePerson(TerrainGeneration TG) { Vector3 point = new Vector3(dimensions.x / 2, 0f, dimensions.z / 2); point.y = TG.terrain.SampleHeight(point) + 2.1f; Instantiate(person, point, Quaternion.identity); }
void drawMesh() { Mesh mesh = TerrainGeneration.generateMesh(noiseMap, heightSacle); GetComponent <MeshFilter>().sharedMesh = mesh; GetComponent <MeshRenderer>().sharedMaterial.mainTexture = texture; }
private void Awake() { if (this.terrainGeneration == null) { this.terrainGeneration = GameObject.Find("TerrainGeneration").GetComponent <TerrainGeneration>(); } }
void Update() { TerrainGeneration m = FindObjectOfType <TerrainGeneration>(); float boundsY = m.ChunkSize * m.NumOfChunks.y; boundsY += boundsY * 0.2f; //20% buffer to ensure texture doesnt wrap //update textures if (TextureMesh) { Init(); UpdateTexture(); //set texture mat.SetFloat("boundsY", boundsY); mat.SetTexture("ramp", texture); Vector4 shaderParams = new Vector4(TextureStretch.x, TextureStretch.y, 0.0f, 0.0f); mat.SetVector("params", shaderParams); } else { //new blank texture Texture2D tex = new Texture2D(textureResolution, 1, TextureFormat.RGBA32, false);; mat.SetFloat("boundsY", boundsY); mat.SetTexture("ramp", tex); mat.SetVector("params", Vector3.zero); } //update fog if (ShowFog) { if (playerController == null) { playerController = GameObject.FindGameObjectWithTag("Player").GetComponent <BallControl>(); } if (cam == null) { cam = FindObjectOfType <Camera>(); } //enable and set the fog RenderSettings.fog = true; RenderSettings.fogColor = cam.backgroundColor; RenderSettings.fogEndDistance = playerController.visionRadius * fogDstMultiplier * 4; //turn up the directional light directionalLight.intensity = 2.3f; playerLight.intensity = 23.0f; } else { //disable the fog RenderSettings.fog = false; //turn down the directional light directionalLight.intensity = 1.0f; playerLight.intensity = 3.0f; } }
void placeBuilding(TerrainGeneration TG, Vector3 cityCentre, float cityRadius) { Vector3 point = Random.insideUnitSphere * cityRadius; point += cityCentre; point.y = TG.terrain.SampleHeight(point); //Instantiate(city,point,Quaternion.identity); }
// Start is called before the first frame update void Start() { buildingAttributes = GetComponent <BuildingAttributes>(); terrainGeneration = TerrainGeneration.instance; gameManager = GameManager.instance; x = (int)(transform.position.x + 0.5); y = (int)(transform.position.z + 0.5); }
void Awake() { if (instance != null) { Debug.LogError("More than one TerrainGeneration Script!"); return; } instance = this; }
void Start() { terrainGeneration = gameObject.GetComponent <TerrainGeneration>(); meshFilter = gameObject.GetComponent <MeshFilter>(); //meshFilter.mesh = terrainGeneration.World.LoadWorldMesh(); Mesh mesh = terrainGeneration.World.OneRoomTest(); mesh.RecalculateNormals(); meshFilter.mesh = mesh; }
private void Awake() { if (!instance) instance = this; Seed = /*-6394955; */UnityEngine.Random.Range(-9999, 9999); // Generate the random seed ChunkScale = new Vector3(ChunkSize / 10, 1, ChunkSize / 10); // Generate the chunk scale for the chunk object x,z size. GenerateLodLevels(); CreatePool(); if (IsMultiThreaded) Instantiate(ThreadManager); GenerateChunks(_updatedPosition); GenerateAllChunkNeighbours(); }
public void OnGUI() { MountainFreq = EditorGUILayout.Slider("Mountain Frequency", MountainFreq, 0, 100); Roughness = EditorGUILayout.Slider("Roughness", Roughness, 0, 5); HeightMultiplier = EditorGUILayout.Slider("Height multiplier", HeightMultiplier, 0, 3); BumpbMultiplier = EditorGUILayout.Slider("Bump multiplier", BumpbMultiplier, 0, 3); BumpRoughness = EditorGUILayout.Slider("Bump roughness", BumpRoughness, 0, 2); randomSeed = EditorGUILayout.Toggle("Use random seed", randomSeed); if (!randomSeed) { EditorGUILayout.HelpBox("abc123", MessageType.Info); seed = EditorGUILayout.TextField("Seed", seed); } useWater = EditorGUILayout.Toggle("Use water", useWater); if (useWater) { if (GameObject.Find("Water")) { GameObject water = GameObject.Find("Water"); water.transform.position = new Vector3(water.transform.position.x, WaterLevel, water.transform.position.z); WaterLevel = EditorGUILayout.FloatField("Waterlevel", WaterLevel); } else { EditorGUILayout.HelpBox("No water found!\n Name your water GameObject as 'Water'", MessageType.Error); } } if(GUILayout.Button("Generate")){ TerrainGeneration TG = new TerrainGeneration(); TG.SetMountainFreq = MountainFreq; TG.SetWaterlevel = WaterLevel; TG.BumpMultiplier = BumpbMultiplier; TG.BumbRoughness = BumpRoughness; TG.HeightMultiplier = HeightMultiplier; TG.Roughness = Roughness; TG.terrain = Terrain.activeTerrain; if (useWater && GameObject.Find("Water")) { TG.waterplane = GameObject.Find("Water"); TerrainFoliage.waterLevel = WaterLevel; } TG.editor = true; if (randomSeed) { TG.TerrainSeed = "" + (int)UnityEngine.Random.Range(0, int.MaxValue); seed = TG.TerrainSeed; } else TG.TerrainSeed = seed; Debug.Log("Using seed: " + TG.TerrainSeed); TG.makeHeightmap(); } Terrain.activeTerrain.heightmapPixelError = EditorGUILayout.Slider("Pixel error", Terrain.activeTerrain.heightmapPixelError, 1, 200); Terrain.activeTerrain.basemapDistance = EditorGUILayout.Slider("Basemap distance", Terrain.activeTerrain.basemapDistance, 0, 2000); }
// Use this for initialization private void Start() { _generation = (TerrainGeneration) FindObjectOfType(typeof (TerrainGeneration)); _character = GetComponent<CharacterController>(); _waypoint = new Transform[_generation.pathOrder.Count]; foreach (var tile in _generation.pathOrder) { _waypoint[_generation.pathOrder.IndexOf(tile)] = new GameObject().transform; _waypoint[_generation.pathOrder.IndexOf(tile)].position = new Vector3(tile.x * _generation.tileOffset, 0, tile.y * _generation.tileOffset); } }
void Awake() { // Register the singleton if (Instance != null) { Debug.LogError("Multiple instances of BeatsEngine!"); } Instance = this; audioSource = GetComponent <AudioSource>(); sunScript = sun.GetComponent <SunScript>(); terrainGeneration = GetComponent <TerrainGeneration>(); }
public override void OnInspectorGUI() { DrawDefaultInspector(); TerrainGeneration generation = (TerrainGeneration)target; if (GUILayout.Button("ReGenerate All Chunk Meshes")) { foreach(TerrainChunk chunk in TerrainGeneration.Chunks.Values) { chunk.GenerateChunkMesh(); } } }
public void GenerateTerrain(int xDir, int yDir) {//Will handle all procedures that involve the board manager GameObject[] enemyPosition2 = GameObject.FindGameObjectsWithTag("Enemy") as GameObject[]; if (xDir != 0) { int y; int x = generationSize * xDir; int xpos = (int)transform.position.x; int ypos = (int)transform.position.y; for (y = -generationSize; y <= generationSize; y++) { TerrainGeneration toQueue = new TerrainGeneration(xpos + x, ypos + y, 1); generationQueue.Enqueue(toQueue); toQueue = new TerrainGeneration(xpos - x, ypos + y, 0); generationQueue.Enqueue(toQueue); } y = UnityEngine.Random.Range(-generationSize + 1, generationSize); if (enemyPosition2.Length < 10)//If there are less than 10 enemies, then generate some more - keeps enemy spawning from going out of control { TerrainGeneration toQueue = new TerrainGeneration(x + (int)transform.position.x, y + (int)transform.position.y, 2); generationQueue.Enqueue(toQueue); } } else//Same thing except for the y direction { int x; int y = generationSize * yDir; int xpos = (int)transform.position.x; int ypos = (int)transform.position.y; for (x = -generationSize; x <= generationSize; x++) { TerrainGeneration toQueue = new TerrainGeneration(xpos + x, ypos + y, 1); generationQueue.Enqueue(toQueue); toQueue = new TerrainGeneration(xpos + x, ypos - y, 0); generationQueue.Enqueue(toQueue); } x = UnityEngine.Random.Range(-generationSize + 1, generationSize); if (enemyPosition2.Length < 10)//If there are less than 10 enemies, then generate some more - keeps enemy spawning from going out of control { TerrainGeneration toQueue = new TerrainGeneration(x + (int)transform.position.x, y + (int)transform.position.y, 2); generationQueue.Enqueue(toQueue); } } }
void InitializeTerrain() { // Generate the terrain mesh Mesh mesh = TerrainGeneration.GenerateTerrainMesh(terrainWidth, resolution, terrainValues); // Add a Mesh Renderer and Filter to the terrain game object, and apply the mesh to the filter terrainGameObject.AddComponent <MeshRenderer>(); MeshFilter filter = terrainGameObject.AddComponent <MeshFilter>(); filter.mesh = mesh; // Add EdgeCollider2D //EdgeCollider2D edgeCollider = terrainGameObject.AddComponent<EdgeCollider2D>(); //edgeCollider.points = TerrainGeneration.CreateColliderPoints(mesh); }
public void init() { int[,] chunkTileIDs; int[,] backgroundTileIDs; // get the chunk data from the terrain generator class and set the tilemap to it chunkTileIDs = TerrainGeneration.generateChunkTiles(chunkX, chunkY, seed, biomeRefrence.biome, out backgroundTileIDs); setTileToIdArray(chunkTileIDs); // create the chunk background object createChunkBackground(); // set the backgrounds tiles correctly based on our tile id chunkBackground.setTileToIdArray(backgroundTileIDs); }
void findCity(TerrainGeneration TG) { Vector2 point = Random.insideUnitCircle * (dimensions.x * 0.15f); Vector3 start = new Vector3(point.x, 0.0f, point.y); start += dimensions * 0.15f; start.y = TG.terrain.SampleHeight(start); /*for(int i=0;i<5;i++){ * placeBuilding(TG,start,50.0f); * }*/ Transform t = Instantiate(city, start, Quaternion.identity) as Transform; t.localScale = new Vector3(25.0f, 0.0f, 25.0f); }
public void PrepareTerrainCell(TerrainGeneration tg) { this.tg = tg; if (transform.position.z >= 30f) { resolution = tg.resolution * 4f; } else { resolution = tg.resolution; } PrepareMesh(); CalculateMesh(); SpawnButterfly(); }
//find a reasonable point on mesh to spawn an object Vector3 FindPointOnMesh() { //get a new location coord across x and z axis float visRad = GameObject.FindGameObjectWithTag("Player").GetComponent <BallControl>().visionRadius; Vector3 playerPos = GameObject.FindGameObjectWithTag("Player").transform.position; //get random direction Vector3 NewLocation = Random.insideUnitSphere * visRad; //zero out the vertical NewLocation = new Vector3(NewLocation.x, 0.0f, NewLocation.z); NewLocation += playerPos; //find the chunk that is in TerrainGeneration tG = FindObjectOfType <TerrainGeneration>(); Vector3Int coord = Vector3Int.RoundToInt(NewLocation / tG.ChunkSize); //find the chunk if it already exists GameObject chunk = GameObject.Find($"Chunk ({coord.x}, {coord.y}, {coord.z})"); //chunks mesh Mesh mesh; Chunk NewChunk = null; //if no chunk exists at that coord, create it for this purpose if (chunk == null) { NewChunk = tG.CreateChunkObject(coord); NewChunk.SetUp(false, tG.material); mesh = NewChunk.GetComponent <Chunk>().mesh; tG.UpdateTerrainGPU(NewChunk); } else { mesh = chunk.GetComponent <Chunk>().mesh; } Vector3 MarkerLocation = FindClosestVertex(mesh, NewLocation); //remove chunk if one was made to find mesh position if (chunk == null) { NewChunk.Destroy(); } return(MarkerLocation); }
public void PrepareMesh(float height, float trunkThickness, int roots, float rootLength, TerrainGeneration tg) { this.height = height; this.trunkThickness = trunkThickness; this.roots = roots; this.rootLength = rootLength; this.tg = tg; wood = tg.treeWoodMaterial; leaves = new Material(tg.treeLeafMaterial); leaves.color = new Color(Random.Range(0.3f, 0.8f), Random.Range(0.5f, 1.0f), Random.Range(0.2f, 0.4f), leaves.color.a); meshRenderer = gameObject.AddComponent <MeshRenderer>(); meshRenderer.sharedMaterial = wood; meshFilter = gameObject.AddComponent <MeshFilter>(); }
// Start is called before the first frame update void Awake() { gm = GameObject.FindGameObjectWithTag("GameController").GetComponent <GameManager>(); CurrentBpm = bpm; path = GetComponent <Path>(); terrainGeneration = GetComponent <TerrainGeneration>(); musicStructure = new NoteIndex[levelDuration + startOffset * 2]; ResetNotes(musicStructure); bassSeed = Random.Range(0, 100f); CreateDrumSequence(); CreateKickSequence(); CreateBassSequence(); CreateRoadPattern(); //path.GenerateStartPoints(stepDistance,2); }
/* * Get the position of the camera and then generate terrains around the camera * TODO : Move Generate Trees to TerrainGeneration script * TODO : Make water plane height adjustable */ public void UpdateMap() { var tileSize = tilePrefab.GetComponent <Terrain>().terrainData.size; int tileWidth = (int)tileSize.x; int tileDepth = (int)tileSize.z; var currentCameraPosition = camera.transform.position; var x = Mathf.Floor(currentCameraPosition.x / tileWidth) * tileWidth; var z = Mathf.Floor(currentCameraPosition.z / tileDepth) * tileDepth; int minMax = (int)Mathf.Floor(mapWidthInTiles / 2); for (int zIndex = -minMax; zIndex <= minMax; zIndex++) { for (int xIndex = -minMax; xIndex <= minMax; xIndex++) { var tilePosition = new Vector3(x + xIndex * tileWidth, 0, z + zIndex * tileDepth); int tilePositionIndexX = (int)(tilePosition.x / tileSize.x); int tilePositionIndexZ = (int)(tilePosition.z / tileSize.z); if (tilePosition.x >= 0 && tilePosition.z >= 0 && terrains[tilePositionIndexZ, tilePositionIndexX] == null) { var tile = Instantiate(Resources.Load("TerrainAssets/TerrainChunk") as GameObject, tilePosition, Quaternion.identity); tile.transform.parent = world.transform; var terrainTile = tile.GetComponent <TerrainGeneration>().GenerateTile(); var terrain = terrainTile.terrain; terrains[tilePositionIndexZ, tilePositionIndexX] = terrain; TerrainGeneration.Fix(terrain, terrains[tilePositionIndexZ, tilePositionIndexX - 1], terrains[tilePositionIndexZ - 1, tilePositionIndexX]); // Create water plane, move and scale it at the center of the terrain var waterTilePosition = new Vector3(tilePosition.x + (tileSize.x / 2), 39f, tilePosition.z + (tileSize.z / 2)); var waterTile = Instantiate(Resources.Load("TerrainAssets/WaterBasicDaytime") as GameObject, waterTilePosition, Quaternion.identity); waterTile.transform.localScale = new Vector3(13, 1, 13); waterTile.transform.parent = terrain.transform; objectGeneration.GenerateTrees(terrainTile); objectGeneration.GenerateGrass(terrainTile); objectGeneration.GenerateRocks(terrainTile); creatureGeneration.GenerationCreatures(terrainTile); } // Set currentTile to be where camera new position is currentTile = new Bounds(new Vector3(x + (tileWidth / 2), 0, z + (tileDepth / 2)), new Vector3(tileWidth, 1000, tileDepth)); } } }
IEnumerator InitialisationCoroutine() { moveSpeed = 0.15f; //Random.InitState(randomSeed); uncomment to seed simulation mf = gameObject.AddComponent <MeshFilter>(); mr = gameObject.AddComponent <MeshRenderer>(); sliderProgress += 0.2f; yield return(null); testCrust = new Crust(meshWidth, meshHeight, triSize, seaLevel: 1.0f); sliderProgress += 0.2f; yield return(null); testCrust.Mesh = MeshBuilder.BuildMesh(mf, mr, meshWidth, meshHeight, triSize); testCrust = TerrainGeneration.ApplyFractalToCrust(testCrust); Debug.Log("in apply: " + testCrust.CrustNodes[30, 222][0].Height); sliderProgress += 0.2f; yield return(null); testCrust = PlateGeneration.SplitCrustIntoPlates(testCrust, meshWidth, meshHeight, plateCount, voronoiRelaxationSteps); sliderProgress += 0.2f; yield return(null); for (int i = 0; i < testCrust.Plates.Length; i++) { while ((testCrust.Plates[i].XSpeed <0.3f && testCrust.Plates[i].XSpeed> -0.3f) && (testCrust.Plates[i].ZSpeed <0.3f && testCrust.Plates[i].ZSpeed> -0.3f)) { testCrust.Plates[i].AccurateXSpeed = Random.Range(-2f, 2f); testCrust.Plates[i].AccurateZSpeed = Random.Range(-2f, 2f); } sliderProgress += (0.2f / testCrust.Plates.Length); yield return(null); } sliderBar.gameObject.SetActive(false); }
public void generate() { generateWater(); TerrainGeneration TG = new TerrainGeneration(); TerrainGeneration.current = TG; TerrainData tData = new TerrainData(); tData.size = dimensions; Terrain.CreateTerrainGameObject(tData); TG.SetMountainFreq = MountainFreq; TG.SetWaterlevel = WaterLevel; TG.BumpMultiplier = BumpMultiplier; TG.BumpRoughness = BumpRoughness; TG.HeightMultiplier = HeightMultiplier; TG.Roughness = Roughness; TG.terrain = Terrain.activeTerrain; TG.waterplane = GameObject.Find("Water"); TG.ClipEdges = ClipEdges; TerrainFoliage.waterLevel = WaterLevel; TG.editor = true; if (randomSeed) { TG.TerrainSeed = "" + (int)UnityEngine.Random.Range(0, int.MaxValue); seed = TG.TerrainSeed; } else { TG.TerrainSeed = seed; } TG.makeHeightmap(); generateTextures(); generatePerson(TG); generateSun2(); findCity(TG); TerrainFoliage.grass = grass; TerrainFoliage.grass2 = grass; TerrainFoliage.BigTree = BigTree; TerrainFoliage.Tree = Tree; TerrainFoliage.GenerateFoliage(dimensions.x); TerrainFoliage.GenerateGrass(); }
public void GenerateMap() { float[,] noiseMap = Noise.GenerateNoise(mapWidth, mapHeight, seed, noiseScale, octaves, persistance, lacunarity, offset); Color[] colorMap = new Color[mapWidth * mapHeight]; for (int x = 0; x < mapWidth; x++) { for (int y = 0; y < mapHeight; y++) { float currentHeight = noiseMap[x, y]; for (int i = 0; i < regions.Length; i++) { if (currentHeight <= regions[i].height) { colorMap[y * mapWidth + x] = regions[i].color; break; } } } } TerrainDisplay display = FindObjectOfType <TerrainDisplay>(); if (drawMode == DrawMode.NoiseMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap)); } else if (drawMode == DrawMode.ColorMap) { display.DrawTexture(GenerateTexture(colorMap)); } else if (drawMode == DrawMode.Mesh) { display.DrawMesh(MeshGenerator.GenerateMesh(noiseMap, meshHeightMultiplier, meshHeightCurve), GenerateTexture(colorMap)); } else if (drawMode == DrawMode.Terrain) { display.DrawTerrain(TerrainGeneration.GenerateTerrain(terrainData, noiseMap), regions); } }
//Implemented using particle deposition private void EruptVolcanos(List <Volcano> volcanos, int maxAge, int maxSearchRange, int maxElevationThreshold, int dropZoneRadius, float rockSize, float heightSimilarityEpsilon, bool updateCoords = false) { for (int v = 0; v < volcanos.Count; v++) { var vol = volcanos[v]; //Increase age vol.Age++; //If it's at the end of it's lifetime, remove it from the list and return it to the volcano object pool if (vol.Age >= maxAge) { ObjectPooler.current.ReturnVolcanoToPool(vol); volcanos.RemoveAt(v); } else //otherwise, do eruption (particle deposition) { crustNodes = TerrainGeneration.ParticleDeposition(crustNodes, vol, rockSize, heightSimilarityEpsilon, dropZoneRadius, maxSearchRange, maxElevationThreshold); } if (updateCoords) { if (crustNodes[vol.X, vol.Z][0].Plate.CheckMoveX()) { vol.X = (vol.X + crustNodes[vol.X, vol.Z][0].Plate.XSpeed) % width; if (vol.X < 0) { vol.X = width + vol.X; } } if (crustNodes[vol.X, vol.Z][0].Plate.CheckMoveZ()) { vol.Z = (vol.Z + crustNodes[vol.X, vol.Z][0].Plate.ZSpeed) % height; if (vol.Z < 0) { vol.Z = height + vol.Z; } } } } }
public override void OnInspectorGUI() { DrawDefaultInspector(); TerrainGeneration terrain = (TerrainGeneration)target; if (GUILayout.Button("Generate")) { terrain.ClearTerrain(); terrain.GenerateTerrain(); // Sets Terrain Chunks to be navigation static for (int i = 0; i < terrain.transform.childCount; ++i) { GameObjectUtility.SetStaticEditorFlags(terrain.transform.GetChild(i).gameObject, StaticEditorFlags.NavigationStatic); } } if (GUILayout.Button("Clear")) { terrain.ClearTerrain(); } }
public static Color[] GenerateHeightmapTexture(TerrainGeneration terrainGeneration, DebugPlaneType planeContent) { Color[] terrainTexture = new Color[terrainGeneration.TerrainInfo.TerrainWidth * terrainGeneration.TerrainInfo.TerrainHeight]; for (int y = 0; y < terrainGeneration.TerrainInfo.TerrainHeight; y++) { for (int x = 0; x < terrainGeneration.TerrainInfo.TerrainWidth; x++) { if (planeContent == DebugPlaneType.kAll) { if (terrainGeneration.TerrainInfo.TerrainTextureType == TextureType.kColored) { terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = terrainGeneration.TerrainInfo.TerrainParameterList[BiomeGeneration.GetCorrectBiomeIndex(terrainGeneration.TerrainInfo, x, y)].TerrainColor; } else { var valsTogether = terrainGeneration.TerrainInfo.HeightMap[x, y] + terrainGeneration.TerrainInfo.TemperatureMap[x, y] + terrainGeneration.TerrainInfo.MoistureMap[x, y]; valsTogether = valsTogether / 3; terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = Color.Lerp(Color.white, Color.black, valsTogether); } } else if (terrainGeneration.TerrainInfo.TerrainTextureType == TextureType.kGrayscale) { if (planeContent == DebugPlaneType.kHeightMap) { terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = Color.Lerp(Color.white, Color.black, terrainGeneration.TerrainInfo.HeightMap[x, y]); } else if (planeContent == DebugPlaneType.kMoistureMap) { terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = Color.Lerp(Color.white, Color.black, terrainGeneration.TerrainInfo.MoistureMap[x, y]); } else if (planeContent == DebugPlaneType.kTemperatureMap) { terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = Color.Lerp(Color.white, Color.black, terrainGeneration.TerrainInfo.TemperatureMap[x, y]); } } } } return(terrainTexture); }
public void CreateChunk(int x, int y, int z) { WorldPos worldPos = new WorldPos(x, y, z); //Instantiate the chunk at the coordinates using the chunk prefab GameObject newChunkObject = Instantiate(chunkPrefab, new Vector3(x, y, z), Quaternion.Euler(Vector3.zero)) as GameObject; Chunk newChunk = newChunkObject.GetComponent <Chunk>(); newChunk.pos = worldPos; newChunk.world = this; //Add it to the chunks dictionary with the position as the key chunks.Add(worldPos, newChunk); //Generate the terrain TerrainGeneration terrainGen = new TerrainGeneration(); newChunk = terrainGen.ChunkGen(newChunk); newChunk.SetBlocksUnmodified(); Serialization.Load(newChunk); }