// Use this for initialization void Start() { terrain = terrainObj.GetComponent<TextureGenerator> (); mainCamera = this.GetComponent<Camera> (); isActive = true; screenMargin = (int)(Screen.width * marginRate); }
void Awake() { textureGenerator = GetComponent<TextureGenerator>(); if (textureGenerator != null) { texture = textureGenerator.GenerateTexture(); } }
void Start() { terrain = this.gameObject.GetComponent<TextureGenerator> (); ///******** Testing For Sprite Displays ******** Faction f = new Faction(); f.initialize("A Faction", Color.black); Reader r = new Reader(); Troop t = this.gameObject.AddComponent<Troop>(); TroopType tt = Reader.getTroopType("cavalry_heavy"); tt.faction = f; t.initialize(tt, 500); GameObject troopObj = TroopOnField.instantiate(t, new Vector2(0, 0), this.gameObject); //TroopOnField.instantiate(t, new Vector2(1, 0), this.gameObject); //TroopOnField.instantiate(t, new Vector2(1, 1), this.gameObject); troopObj.GetComponent<TroopOnField>().troop_stat.status = TroopStats.TroopStatus.Rout; }
protected virtual void Generate() { GetData(); LoadTiles(); UpdateNeighbours(); GenerateRivers(); BuildRiverGroups(); DigRiverGroups(); AdjustMoistureMap(); UpdateBitmasks(); FloodFill(); GenerateBiomeMap(); UpdateBiomeBitmasks(); heightMapRenderer.materials [0].mainTexture = TextureGenerator.GenerateHeightMapTexture(width, height, tiles); heatMapRenderer.materials [0].mainTexture = TextureGenerator.GenerateHeatMapTexture(width, height, tiles); moistureMapRenderer.materials [0].mainTexture = TextureGenerator.GenerateMoistureMapTexture(width, height, tiles); biomeMapRenderer.materials [0].mainTexture = TextureGenerator.GenerateBiomeMapTexture(width, height, tiles, coldestValue, colderValue, coldValue); }
public void GenerateMap() { float[,] noiseMap = Noise.GenerateNoiseMap(width, height, seed, noiseScale, octaves, persistance, lacunarity, offset); colourMap = new Color[width * height]; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { float currentHeight = noiseMap [x, y]; //now finf whihc region this current height falls within for (int i = 0; i < regions.Length; i++) { if (currentHeight <= regions [i].height) { colourMap [y * width + x] = regions [i].colour; break; } } } } DrawTexture(TextureGenerator.TextureFromColourMap(colourMap, width, height)); }
public override void Draw(UISpriteBatch batch) { if (!Visible || Thumb == null) { return; } var ThumbImg = Thumb.LotTexture; if (ThumbImg != null && BgImg != null && HoverImg != null) { UITerrainHighlight.DrawArrow(batch, ((CoreGameScreen)GameFacade.Screens.CurrentUIScreen).CityRenderer, (Position + new Vector2(40, 25)) * FSOEnvironment.DPIScaleFactor, (int)LotId); DrawLocalTexture(batch, (m_isOver && !m_isDown) ? HoverImg : BgImg, new Vector2()); var scale = new Vector2(0.25f, 0.25f); DrawLocalTexture(batch, ThumbImg, null, new Vector2(40, 25) - new Vector2(32, 32), scale); var px = TextureGenerator.GetPxWhite(batch.GraphicsDevice); DrawLocalTexture(batch, px, null, new Vector2(0, 50), new Vector2(80, 16 * NameLabel.NumLines + 7), Color.Black * 0.6f); base.Draw(batch); } }
public void DrawMapInEditor() { MapData mapData = GenerateMapData(Vector2.zero); MapDisplay mapDisplay = FindObjectOfType <MapDisplay> (); if (drawMode == DrawMode.NoiseMap) { mapDisplay.drawTexture(TextureGenerator.textureFromHeightMap(mapData.heightMap)); } else if (drawMode == DrawMode.ColorMap) { mapDisplay.drawTexture(TextureGenerator.textureFromColorMap(mapData.colorMap, MAP_CHUNK_SIZE, MAP_CHUNK_SIZE)); } else if (drawMode == DrawMode.Mesh) { mapDisplay.DrawMesh(MeshGenerator.GeneratTerrainMesh(mapData.heightMap, meshHeightMultipier, meshHeightCurve, editorPreviewLOD), TextureGenerator.textureFromColorMap(mapData.colorMap, MAP_CHUNK_SIZE, MAP_CHUNK_SIZE)); } else if (drawMode == DrawMode.FalloffMap) { mapDisplay.drawTexture(TextureGenerator.textureFromHeightMap(FalloffGenerator.GenerateFalloffMap(MAP_CHUNK_SIZE))); } }
public void DrawMapEditor() { //value might not be correct if we apply the falloffmap because it might falten down the highest point textureData.UpdateMeshHeight(terrainMaterial, terrainData.minHeight, terrainData.maxHeight); MapData mapData = generateMapData(Vector2.zero); MapDisplay mapDisplay = FindObjectOfType <MapDisplay>(); if (drawMode == DrawMode.noiseMap) { Texture2D texture = TextureGenerator.textureHeightMap(mapData.heightMap); mapDisplay.drawTexture(texture); } else if (drawMode == DrawMode.Mesh) { mapDisplay.drawMesh(MeshGenerator.generateTerrainMesh(mapData.heightMap, terrainData.meshHeight, terrainData.meshHeightCurve, previewLevelOfDetail)); } else if (drawMode == DrawMode.FallOffMap) { Texture2D texture = TextureGenerator.textureHeightMap(fallOffMap); mapDisplay.drawTexture(texture); } }
public void DrawMapInEditor() { textureData.ApplyToMaterial(terrainMaterial); textureData.UpdateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maxHeight); HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMapSettings, Vector2.zero); if (drawMode == DrawMode.NoiseMap) { DrawTexture(TextureGenerator.TextureFromHeightMap(heightMap)); } else if (drawMode == DrawMode.Mesh) { MeshData meshData = MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, editorPreviewLOD); DrawMesh(meshData); ObjectsGenerator.GeneratePointsRandom(objectData.objectList, meshData.CreateMesh(), meshSettings, heightMapSettings.noiseSettings.seed); ObjectsGenerator.SpawnObjects(objectData, transform, meshSettings, heightMapSettings.noiseSettings.seed); } else if (drawMode == DrawMode.FalloffMap) { DrawTexture(TextureGenerator.TextureFromHeightMap(new HeightMap(FalloffGenerator.GenerateFalloffMap(meshSettings.numVertsPerLine), 0, 1))); } }
public void PrepareLighting() { var adv = (Light?.LightMap) ?? TextureGenerator.GetDefaultAdv(Device); var amb = AmbientLight ?? TextureGenerator.GetPxWhite(Device); WorldContent._2DWorldBatchEffect.Parameters["advancedLight"].SetValue(adv); WorldContent.GrassEffect.Parameters["advancedLight"].SetValue(adv); WorldContent._2DWorldBatchEffect.Parameters["ambientLight"].SetValue(amb); Avatar.Effect.Parameters["advancedLight"].SetValue(adv); var frontDir = WorldCamera.FrontDirection(); var lightOffset = new Vector2(frontDir.X / (6 * 75), frontDir.Z / (6 * 75)); if (Light != null) { lightOffset *= Light.InvMapLayout; } WorldContent._2DWorldBatchEffect.Parameters["LightOffset"].SetValue(lightOffset); WorldContent.GrassEffect.Parameters["LightOffset"].SetValue(lightOffset); Avatar.Effect.Parameters["LightOffset"].SetValue(lightOffset); WorldContent._2DWorldBatchEffect.Parameters["MaxFloor"].SetValue((float)Level - 1); }
public void DrawMapInEditor() { MapData mapData = GenerateMapData(Vector2.zero); // Reference to the MapDisplay object MapDisplay display = FindObjectOfType <MapDisplay> (); if (drawMode == DrawMode.NoiseMap) { // Draw the noise map on the MapDisplay object display.DrawTexture(TextureGenerator.TextureFromHeightMap(mapData.heightMap)); } else if (drawMode == DrawMode.ColorMap) { // Draw the color map on the MapDisplay object display.DrawTexture(TextureGenerator.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize)); } else if (drawMode == DrawMode.Mesh) { // Draw the mesh display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, editorPreviewLOD, useFlatShading), TextureGenerator.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize)); } }
public void DrawMapInEditor() { MapData mapData = GenerateMapData(Vector2.zero); DisplayMap display = FindObjectOfType <DisplayMap>(); if (drawMode == DrawMode.NoiseMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(mapData.heightMap)); } else if (drawMode == DrawMode.ColorMap) { display.DrawTexture(TextureGenerator.TextureFromColourMap(mapData.colorMap, mapChunkSize, mapChunkSize)); } else if (drawMode == DrawMode.Mesh) { display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, editorPreviewLOD, useFlatShading), TextureGenerator.TextureFromColourMap(mapData.colorMap, mapChunkSize, mapChunkSize)); } else if (drawMode == DrawMode.FalloffMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(IslandGenerator.GenerateIslandEffect(mapChunkSize))); } }
public override void Initialize(_3DLayer layer) { /** * Setup world state, this object acts as a facade * to world objects as well as providing various * state settings for the world and helper functions */ State = new WorldState(layer.Device, layer.Device.Viewport.Width / FSOEnvironment.DPIScaleFactor, layer.Device.Viewport.Height / FSOEnvironment.DPIScaleFactor, this); State.AmbientLight = new Texture2D(layer.Device, 256, 256); State._3D = new FSO.LotView.Utils._3DWorldBatch(State); State._2D = new FSO.LotView.Utils._2DWorldBatch(layer.Device, 2, new SurfaceFormat[] { World2D.BUFFER_SURFACE_FORMATS[0], World2D.BUFFER_SURFACE_FORMATS[World2D.BUFFER_THUMB_DEPTH] }, new bool[] { true, false }, World2D.SCROLL_BUFFER); State._2D.AdvLight = TextureGenerator.GetDefaultAdv(layer.Device); State.DrawOOB = true; UseBackbuffer = false; base.Camera = State.Camera; HasInitGPU = true; HasInit = HasInitGPU & HasInitBlueprint; }
public override void Draw(UISpriteBatch batch) { //simple overide that always draws lots that are community regardless of their online status //Visible=cityview (don't draw in lotview), Lot_IsOnline= lotthread is open(blinking red on map), CLots= list with specific overrides based on db location if (!Visible || Thumb == null || (!Target.Value.Lot_IsOnline && !WorldObjectCatalog.CLots.Contains(Convert.ToString(LotId)))) { return; } var ThumbImg = Thumb.LotTexture; if (ThumbImg != null && BgImg != null && HoverImg != null) { UITerrainHighlight.DrawArrow(batch, ((CoreGameScreen)GameFacade.Screens.CurrentUIScreen).CityRenderer, Position + new Vector2(40, 25), (int)LotId); DrawLocalTexture(batch, (m_isOver && !m_isDown) ? HoverImg : BgImg, new Vector2()); var scale = new Vector2(0.25f, 0.25f); DrawLocalTexture(batch, ThumbImg, null, new Vector2(40, 25) - new Vector2(32, 32), scale); var px = TextureGenerator.GetPxWhite(batch.GraphicsDevice); DrawLocalTexture(batch, px, null, new Vector2(0, 50), new Vector2(80, 16 * NameLabel.NumLines + 7), Color.Black * 0.6f); base.Draw(batch); } }
public void DrawMapInEditor() { textureData.ApplyToMaterial(terrainMaterial); textureData.UpdateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maxHeight); HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings.numVerticesPerLine, meshSettings.numVerticesPerLine, heightMapSettings, Vector2.zero); MapPreview display = FindObjectOfType <MapPreview>(); if (drawMode == DrawMode.NoiseMap) { DrawTexture(TextureGenerator.TextureFromHeightMap(heightMap)); } else if (drawMode == DrawMode.Mesh) { DrawMesh( MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, editorPreviewLod)); } else if (drawMode == DrawMode.FalloffMap) { DrawTexture(TextureGenerator.TextureFromHeightMap( new HeightMap(FalloffGenerator.GenerateFalloffMap(meshSettings.numVerticesPerLine), 0, 1))); } }
public void DrawMapInEditor() { MapData mapData = GenerateMapData(Vector2.zero); MapDisplay display = FindObjectOfType <MapDisplay>(); if (drawMode == DrawMode.NoiseMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(mapData.heightMap)); } else if (drawMode == DrawMode.ColourMap) { display.DrawTexture(TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize)); } else if (drawMode == DrawMode.Mesh) { display.DrawMesh(NoiseMeshGenerator.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, editorPreviewLOD), TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize)); } else if (drawMode == DrawMode.FalloffMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize))); } }
public void GenerateMap() { float[,] noiseMap = Noise.GenerateNoiseMap(mapChunkSize, mapChunkSize, seed, noiseScale, octaves, persistance, lacunarity, offset); Color[] colorMap = new Color[mapChunkSize * mapChunkSize]; for (int y = 0; y < mapChunkSize; y++) { for (int x = 0; x < mapChunkSize; x++) { float currentHeight = noiseMap[x, y]; for (int i = 0; i < regions.Length; i++) { if (currentHeight <= regions[i].height) { colorMap[y * mapChunkSize + x] = regions[i].color; break; } } } } MapDisplay display = FindObjectOfType <MapDisplay>(); if (drawMode == DrawMode.NoiseMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap)); } else if (drawMode == DrawMode.ColorMap) { display.DrawTexture(TextureGenerator.TextureFromColorMap(colorMap, mapChunkSize, mapChunkSize)); } else if (drawMode == DrawMode.Mesh) { display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap, meshHeightMultiplier, meshHeightCurve, levelOfDetail), TextureGenerator.TextureFromColorMap(colorMap, mapChunkSize, mapChunkSize)); } }
public UIFamiliesCASPanel() { var gd = GameFacade.GraphicsDevice; var ui = Content.Get().CustomUI; var sh = UIScreen.Current.ScreenHeight; var sw = UIScreen.Current.ScreenWidth; FamilyList = new UITouchScroll(FamilyLength, FamilyProvider); FamilyList.VerticalMode = true; FamilyList.Size = new Vector2(810, sh); FamilyList.X = (sw - 810) / 2; FamilyList.ItemWidth = 180; FamilyList.Margin = 90; FamilyList.DrawBounds = false; Add(FamilyList); WhitePx = TextureGenerator.GetPxWhite(GameFacade.GraphicsDevice); Title = new UILabel(); Title.NewStyle(UIStyle.Current.Text, 37); Title.Caption = "Select a Family"; Title.Size = new Vector2(sw, 60); Title.Alignment = TextAlignment.Middle | TextAlignment.Center; Title.Y = -85; Add(Title); DeleteButton = new UITwoStateButton(ui.Get("btn_deletefam.png").Get(gd)); DeleteButton.Position = new Vector2(sw - 140, sh - 260); Add(DeleteButton); NewButton = new UITwoStateButton(ui.Get("btn_createfam.png").Get(gd)); NewButton.Position = new Vector2(sw - 140, sh - 380); Add(NewButton); NewButton.OnButtonClick += (btn) => OnNewFamily?.Invoke(); TitleI = TitleI; SetSelection(-1); }
public override void OnInspectorGUI() { GUIStyle styleFold = EditorStyles.foldout; styleFold.fontStyle = FontStyle.Bold; styleFold.fontSize = 14; serializedObject.Update(); statusNoise = EditorGUILayout.Foldout(statusNoise, "Noise", styleFold); if (statusNoise) { EditorGUILayout.BeginVertical("Box"); EditorGUILayout.PropertyField(plantOct); EditorGUILayout.PropertyField(plantFre); if (GUILayout.Button("Generate")) { noiseTex = TextureGenerator.GetNoiseTex(sizeTex, sizeTex, grass.floatValue, plantOct.intValue, plantFre.floatValue); } GUILayout.Label(noiseTex); EditorGUILayout.EndVertical(); } statusPlants = EditorGUILayout.Foldout(statusPlants, "Plant Map", styleFold); if (statusPlants) { EditorGUILayout.BeginVertical("Box"); EditorGUILayout.PropertyField(grass); EditorGUILayout.PropertyField(serializedObject.FindProperty("savanna")); EditorGUILayout.PropertyField(serializedObject.FindProperty("swamp")); EditorGUILayout.PropertyField(serializedObject.FindProperty("desert")); EditorGUILayout.PropertyField(serializedObject.FindProperty("cold")); EditorGUILayout.EndVertical(); } EditorGUILayout.PropertyField(serializedObject.FindProperty("textures"), true); EditorGUILayout.PropertyField(serializedObject.FindProperty("prefChunk")); serializedObject.ApplyModifiedProperties(); }
public void GenerateMap() { float[,] noiseMap = Noise.GenerateNoiseMap(MapWidth, MapHeight, Seed, NoiseScale, OctavesNumber, Persistance, Lacunarity, Offset); //Store the colors in respect of the Map height Color[] colorMap = new Color[MapWidth * MapHeight]; // for (int y = 0; y < MapHeight; y++) { for (int x = 0; x < MapWidth; x++) { float currentHeight = noiseMap[x, y]; for (int i = 0; i < Regions.Length; i++) { if (currentHeight <= Regions[i].Height) { colorMap [y * MapWidth + x] = Regions [i].TerrainColor; break; //no need to } } } } MapDisplayBehaviour display = FindObjectOfType <MapDisplayBehaviour> (); if (Mode == DrawMode.NoiseMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap)); } if (Mode == DrawMode.ColorMap) { display.DrawTexture(TextureGenerator.TextureFromColorMap(colorMap, MapWidth, MapHeight)); } }
public void GenerateMap() { float[,] noiseMap = Noise.GenerateNoiseMap(mapWidth, mapHeight, seed, noiseScale, octaves, persistance, lacunarity, offset); Color[] colorMap = new Color[mapHeight * mapWidth]; for (var y = 0; y < mapHeight; y++) { for (var x = 0; x < mapWidth; x++) { float currentHeight = noiseMap[x, y]; for (var i = 0; i < regions.Length; i++) { if (currentHeight <= regions[i].height) { colorMap[y * mapWidth + x] = regions[i].color; break; } } } } MapDisplay display = FindObjectOfType <MapDisplay>(); if (drawMode == DrawMode.NoiseMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap)); } else if (drawMode == DrawMode.ColorMap) { display.DrawTexture(TextureGenerator.TextureFromColourMap(colorMap, mapWidth, mapHeight)); } else if (drawMode == DrawMode.Mesh) { display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap), TextureGenerator.TextureFromColourMap(colorMap, mapWidth, mapHeight)); } }
public void GenerateMap() { float[,] noiseMap = Noise.GenerateNoiseMap(mapWidth, mapHeight, noiseScale, seed, octaves, persistance, lacunarity, offset); Color[] colorMap = new Color[mapWidth * mapHeight]; for (int y = 0; y < mapHeight; y++) { for (int x = 0; x < mapWidth; x++) { float currentHeight = noiseMap[x, y]; for (int i = 0; i < regions.Length; i++) { if (currentHeight <= regions[i].height) { colorMap[y * mapWidth + x] = regions[i].TerrainColor; break; } } } } MapDisplay display = GetComponent <MapDisplay>(); if (drawMode == DrawMode.NoiseMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap)); } else if (drawMode == DrawMode.ColorMap) { display.DrawTexture(TextureGenerator.TextureFromColorMap(colorMap, mapWidth, mapHeight)); } else if (drawMode == DrawMode.Mesh) { display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap, heightMultiplier, heightCurve), TextureGenerator.TextureFromColorMap(colorMap, mapWidth, mapHeight)); } }
public void GenerateMap() { float[,] noiseMap = Noise.generateNoiseMap(MAP_CHUNK_SIZE, MAP_CHUNK_SIZE, seed, noiseScale, octaves, persistance, lacunarity, offSet); Color[] colourMap = new Color[MAP_CHUNK_SIZE * MAP_CHUNK_SIZE]; for (int y = 0; y < MAP_CHUNK_SIZE; y++) { for (int x = 0; x < MAP_CHUNK_SIZE; x++) { float currentHeight = noiseMap[x, y]; for (int i = 0; i < regions.Length; i++) { if (currentHeight <= regions[i].height) { colourMap[y * MAP_CHUNK_SIZE + x] = regions[i].colour; break; } } } } MapDisplay display = FindObjectOfType <MapDisplay>(); if (drawMode == DrawMode.NoiseMap) { texture2d = TextureGenerator.TextureFromHeightMap(noiseMap); display.DrawTexture(texture2d); } else if (drawMode == DrawMode.ColourMap) { texture2d = TextureGenerator.TextureFromColourMap(colourMap, MAP_CHUNK_SIZE, MAP_CHUNK_SIZE); display.DrawTexture(texture2d); } else if (drawMode == DrawMode.Mesh) { display.DrawMesh(MeshGenerator.GenerateTerrainMwsh(noiseMap, meshHeightMultiplier, meshHeightCurve, levelOfDetail), TextureGenerator.TextureFromColourMap(colourMap, MAP_CHUNK_SIZE, MAP_CHUNK_SIZE)); } }
public void drawMapInEditor() { MapData map = generateMapData(Vector2.zero, false); MapDisplay display = FindObjectOfType <MapDisplay> (); switch (drawMode) { case DrawMode.NoiseMap: display.drawMap(TextureGenerator.generateNoiseTexture(map.heightMap)); break; case DrawMode.Mesh: display.drawMesh(MeshGenerator.generateTerrainMesh(map.heightMap, terrainSettings.meshHeightMultiplier, terrainSettings.meshHeightCurve, editorPreviewLOD)); break; case DrawMode.NoiseMesh: display.drawTextureMesh(MeshGenerator.generateTerrainMesh(map.heightMap, terrainSettings.meshHeightMultiplier, terrainSettings.meshHeightCurve, editorPreviewLOD), TextureGenerator.generateNoiseTexture(map.heightMap)); break; default: break; } }
public void GenerateMap() { float[,] NoiseMap = Noise.GenerateNoiseMap(MapChunkSize, MapChunkSize, Seed, NoiseScale, Octaves, Persistance, Lacunarity, Offset); Color[] ColourMap = new Color[MapChunkSize * MapChunkSize]; for (int y = 0; y < MapChunkSize; y++) { for (int x = 0; x < MapChunkSize; x++) { float CurrentHeight = NoiseMap[x, y]; for (int i = 0; i < Regions.Length; i++) { if (CurrentHeight <= Regions[i].Height) { ColourMap[y * MapChunkSize + x] = Regions[i].Colour; break; } } } } MapDisplay Display = FindObjectOfType <MapDisplay>(); if (drawMode == DrawnMode.NoiseMap) { Display.DrawTexture(TextureGenerator.TextureFromHeightMap(NoiseMap)); } else if (drawMode == DrawnMode.ColourMap) { Display.DrawTexture(TextureGenerator.TextureFromColourMap(ColourMap, MapChunkSize, MapChunkSize)); } else if (drawMode == DrawnMode.Mesh) { Display.DrawMesh(MeshGenerator.GenerateTerrainMesh(NoiseMap, MeshHeightMultiplier, MeshHeightCurve, LevelOfDetail), TextureGenerator.TextureFromColourMap(ColourMap, MapChunkSize, MapChunkSize)); } }
// Main thread public void DrawMapInEditor() { // Update textureData textureData.ApplyToMaterial(terrainMaterial); textureData.UpdateMeshHeights(terrainMaterial, terrainData.minHeight, terrainData.maxHeight); MapData mapData = GenerateMapData(Vector2.zero); // Draw texture to the display MapDisplay display = FindObjectOfType <MapDisplay>(); if (drawMode == DrawMode.NoiseMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(mapData.heightMap)); } else if (drawMode == DrawMode.MeshMap) { display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, terrainData.meshHeightMultiplier, terrainData.meshHeightCurve, editorPreviewLOD, terrainData.useFlatShading)); } else if (drawMode == DrawMode.FalloffMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize))); } }
public void DrawMapInEditor() { textureData.UpdateMeshHeights(terrainMaterial, terrainData.minHeight, terrainData.maxHeight); MapData mapdata = GenerateMapData(Vector2.zero); MapDisplay display = FindObjectOfType <MapDisplay>(); switch (drawMode) { case DrawMode.NoiseMap: display.DrawTexture(TextureGenerator.TextureFromHeightMap(mapdata.heightMap)); break; case DrawMode.Mesh: display.DrawMesh( MeshGenerator.GenerateTerrainMesh(mapdata.heightMap, terrainData.meshHeightMultiplier, terrainData.meshHeightCurve, editorPreviewLOD, terrainData.useFlatShading) ); break; case DrawMode.FalloffMap: display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize))); break; } }
public void GenerateMap() { MapDisplay display = FindObjectOfType <MapDisplay>(); float[,] noiseMap = Noise.GenerateNoiseMap(mapWidth, mapHeight, seed, noiseScale, octaves, persistance, lacunarity, offset); Color[] colourMap = new Color[mapWidth * mapHeight]; for (int y = 0; y < mapHeight; y++) { for (int x = 0; x < mapWidth; x++) { float currentHeight = noiseMap [x, y]; for (int i = 0; i < regions.Length; i++) { if (currentHeight <= regions [i].height) { colourMap [y * mapWidth + x] = regions [i].colour; break; } } } } if (drawMode == DrawMode.NoiseMap) { display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap)); } else if (drawMode == DrawMode.ColourMap) { display.DrawTexture(TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight)); } else if (drawMode == DrawMode.TextureTerrain) { display.DrawCubes(textures, noiseMap, mapWidth, mapHeight, heightDescrepancy, cubeScale); } }
public void generateMap() { float[,] map = Noise.generateNosieMap(map_width, map_height, seed, noise_scale, octaves, persistance, lacunarity, offset); Color[] color_map = new Color[map_width * map_height]; for (int x = 0; x < map_width; x++) { for (int y = 0; y < map_height; y++) { float current_height = map[x, y]; for (int i = 0; i < regions.Length; i++) { if (current_height <= regions[i].height) { color_map[y * map_width + x] = regions[i].color; break; } } } } MapDisplay display = FindObjectOfType <MapDisplay>(); if (draw_mode == DrawMode.NoiseMap) { display.drawTexture(TextureGenerator.textureFromHeightMap(map)); } else if (draw_mode == DrawMode.ColorMap) { display.drawTexture(TextureGenerator.textureFromColorMap(color_map, map_width, map_height)); } else if (draw_mode == DrawMode.Mesh) { display.drawMesh(MeshGenerator.generateTerrainMesh(map), TextureGenerator.textureFromColorMap(color_map, map_width, map_height)); } }
public void DrawMapInEditor() { textureData.ApplyToMaterial(terrainMaterial); textureData.UpdateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maxHeight); HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMapSettings, Vector2.zero); if (drawMode == DrawMode.NoiseMap) { DrawTexture(TextureGenerator.TextureFromHeightMap(heightMap)); } else if (drawMode == DrawMode.Mesh) { var data = MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, editorPreviewLOD); DrawMesh(data); // Sagie: Place an item //GenItem(data); } else if (drawMode == DrawMode.FalloffMap) { DrawTexture(TextureGenerator.TextureFromHeightMap(new HeightMap(FalloffGenerator.GenerateFalloffMap(meshSettings.numVertsPerLine), 0, 1))); } }
public void DrawMapInEditor() { MapData mapData = GenerateMapData(Vector2.zero); MapDisplay display = FindObjectOfType <MapDisplay>(); switch (drawMode) { case DrawMode.NoiseMap: display.DrawTexture(TextureGenerator.TextureFromHeightMap(mapData.heightMap)); break; case DrawMode.ColorMap: display.DrawTexture(TextureGenerator.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize)); break; case DrawMode.Mesh: display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, heightFactor, heightCurve, editorPreviewLOD), TextureGenerator.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize)); break; case DrawMode.FalloffMap: display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize))); break; } }
public void GenerateMap() { Stopwatch total = new Stopwatch(); total.Start(); Initialize(); Stopwatch s = new Stopwatch(); s.Start(); CreateContinentHeightMap(); UnityEngine.Debug.Log("total time to create continents: " + s.ElapsedMilliseconds); s.Restart(); CreatePerlinMap(); CreateRidgedMap(); CreateVelleyMap(); UnityEngine.Debug.Log("total time to create noisemaps: " + s.ElapsedMilliseconds); s.Restart(); CombineHeightMaps(); RecalculateMinMax(); float[,] heightMap = CreateHeightMap(); Color[] colorMap = GenerateColorMap(heightMap); display.DrawMesh(MeshGenerator.GenerateTerrainMesh(heightMap), TextureGenerator.TextureFromColourMap(colorMap, mapWidth, mapHeight)); UnityEngine.Debug.Log("total time to do everything: " + total.ElapsedMilliseconds); }
///<summary> ///Generates the map texture via a noiseMap or a colourMap. Acts as user-interface in the Unity Inspector panel. ///</summary> ///<remarks> ///Whether a noiseMap or colourMap is generated is determined by the DrawMode setting set in the Unity Inspector. ///</remarks> public void GenerateMap() { float[,] noiseMap = Noise.GenerateNoiseMap (mapChunkSize,mapChunkSize, seed, noiseScale, octaves, persistance, lacunarity, offset); //Detecting height and assigning colour. Color[] colourMap = new Color[mapChunkSize*mapChunkSize]; for (int y = 0; y < mapChunkSize; y++) //loop through y coordinates of map. { for (int x = 0; x < mapChunkSize; x++) //loop through x coordinates of map. { float currentHeight = noiseMap[x, y]; for (int i = 0; i < regions.Length; i++) //Judging color by comparing height value to each region's bounds. { if (currentHeight <= regions[i].height) { colourMap[y * mapChunkSize + x] = regions[i].colour; //[y * mapwidth + x] is a 2D array to 1D array mapping. break; } } } } MapDisplay display = FindObjectOfType<MapDisplay>(); if (drawMode == DrawMode.NoiseMap) //Depending on Draw Mode setting in inspector, generate a BW texture from heightMap, color texture by colourMap, or Mesh from the Map data. { display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap)); } else if (drawMode == DrawMode.ColourMap) { display.DrawTexture(TextureGenerator.TextureFromColourMap(colourMap, mapChunkSize, mapChunkSize)); } else if (drawMode == DrawMode.Mesh) { display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap, meshHeightMultiplier, meshHeightCurve, levelOfDetail), TextureGenerator.TextureFromColourMap(colourMap, mapChunkSize, mapChunkSize)); } }