public void drawMapInEditor()
{
textureData.applyToMaterial(terrainMaterial);
textureData.updateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maxHeight);
HeightMap heightMap = HeightMapGenerator.generateHeightmap(meshSettings.numVerticesPerLine, meshSettings.numVerticesPerLine, heightMapSettings, Vector2.zero);
if (drawMode == DrawMode.NoiseMap)
{
drawTexture(TextureGenerator.textureFromHeightmap(heightMap));
}
else if (drawMode == DrawMode.Mesh)
{
if (heightMapSettings.useFalloff)
{
float[,] falloff = FalloffGenerator.generateFalloffMap(meshSettings.numVerticesPerLine);
for (int i = 0; i < heightMap.values.GetLength(0); i++)
{
for (int j = 0; j < heightMap.values.GetLength(1); j++)
{
heightMap.values[i, j] = heightMap.values[i, j] * (1 - falloff[i, j]);
}
}
}
drawMesh(MeshGenerator.generateTerrainMesh(heightMap.values, meshSettings, editorPreviewLOD));
}
else if (drawMode == DrawMode.Falloff)
{
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.TextureFromNoiseMap(mapData.heightMap));
}
else if (drawMode == DrawMode.ColorMap)
{
display.DrawTexture(TextureGenerator.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(
MeshGenerator.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, editorLevelOfDetail),
TextureGenerator.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize)
);
}
else if (drawMode == DrawMode.FalloffMap)
{
if (falloffMode == FalloffMode.Square)
{
display.DrawTexture(TextureGenerator.TextureFromNoiseMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize)));
}
else
{
display.DrawTexture(TextureGenerator.TextureFromNoiseMap(FalloffGenerator.GenerateCircularFalloffMap(mapChunkSize)));
}
}
}
MapData GenerateMapData(Vector2 center)
{
mapGrid = new MapCell[mapChunkSize, mapChunkSize];
if (falloffShape == FalloffShape.square)
{
falloffMap = FalloffGenerator.GenerateSquareFalloffMap(mapChunkSize);
}
else if (falloffShape == FalloffShape.circle)
{
falloffMap = FalloffGenerator.GenerateCircularFalloffMap(mapChunkSize);
}
float[,] noiseMap = Noise.GenerateNoiseMap(mapChunkSize, mapChunkSize, seed, noiseData.noiseScale, noiseData.octaves, noiseData.persistance, noiseData.lacunarity, center + noiseData.offset, noiseData.normalizeMode);
for (int y = 0; y < mapChunkSize; y++)
{
for (int x = 0; x < mapChunkSize; x++)
{
if (useFalloff)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffMap[x, y]);
}
float currentHeight = noiseMap[x, y];
mapGrid[x, y].height = currentHeight;
}
}
return(new MapData(noiseMap));
}
void UpdatePreview()
{
FalloffGenerator generator = (FalloffGenerator)target;
float[,] noiseMap = generator.Generate(120, 120);
texture = TextureGenerator.TextureFromHeightMap(noiseMap);
}
MapData GenerateMapData(Vector2 center)
{
float [,] noiseMap = Noise.GenerateNoiseMap(mapChunkSize + 2, mapChunkSize + 2, noiseData.seed, noiseData.noiseScale, noiseData.octaves, noiseData.persistance, noiseData.lacunarity, center + noiseData.offset, noiseData.normalizeMode);
if (terrainData.useFalloff)
{
if (falloffMap == null)
{
falloffMap = FalloffGenerator.GenerateFalloffMap(mapChunkSize + 2);
}
for (int y = 0; y < mapChunkSize + 2; y++)
{
for (int x = 0; x < mapChunkSize + 2; x++)
{
if (terrainData.useFalloff)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffMap[x, y]);
}
}
}
}
// textureData.UpdateMeshHeights(terrainMaterial, terrainData.minHeight, terrainData.maxHeight);
return(new MapData(noiseMap));
}
/**
* Method that generates the noise map and color map
* @param center Center of the map
*/
MapData GenerateMapData(Vector2 center)
{
float[,] noiseMap = Noise.GenerateNoiseMap(mapChunkSize + 2, mapChunkSize + 2, noiseData.seed, noiseData.noiseScale, noiseData.octaves, noiseData.persistence, noiseData.lacunarity, center + noiseData.offset, noiseData.normalizeMode);
if (terrainData.useFalloff)
{
if (falloffMap == null)
{
falloffMap = FalloffGenerator.GenerateFalloffMap(mapChunkSize + 2);
}
// Noise map generation based on the height map
for (int y = 0; y < mapChunkSize + 2; y++)
{
for (int x = 0; x < mapChunkSize + 2; x++)
{
// Apply the falloff map to the generated terrain
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffMap[x, y]);
}
}
}
textureData.UpdateMeshHeights(terrainMaterial, terrainData.MinHeight, terrainData.MaxHeight);
return(new MapData(noiseMap));
}
MapData GenerateMapData(Vector2 center)
{
// Generate Noisemap
float[,] noiseMap = Noise.GenerateNoiseMap(mapChunkSize + 2, mapChunkSize + 2, noiseData.seed, noiseData.noiseScale, noiseData.octaves, noiseData.persistance, noiseData.lacunarity, center + noiseData.offset, noiseData.normalizeMode);
if (terrainData.useFalloff)
{
if (falloffMap == null)
{
falloffMap = FalloffGenerator.GenerateFalloffMap(mapChunkSize + 2);
}
for (int y = 0; y < mapChunkSize + 2; y++)
{
for (int x = 0; x < mapChunkSize + 2; x++)
{
// Clamp to falloff map
if (terrainData.useFalloff)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffMap[x, y]);
}
}
}
}
return(new MapData(noiseMap));
}
private float[,] GenerateNoiseMap()
{
float[,] noiseMap =
Noise.GenerateNoise(
noiseData.mapWidth,
noiseData.mapHeight,
noiseData.seed,
noiseData.noiseScale,
noiseData.octaves,
noiseData.persistance,
noiseData.lacunarity,
noiseData.offset);
float[,] falloffMap =
FalloffGenerator.GenerateFalloffMap(noiseData.mapWidth, noiseData.mapHeight);
if (noiseData.falloff)
{
for (int y = 0; y < noiseData.mapHeight; y++)
{
for (int x = 0; x < noiseData.mapWidth; x++)
{
noiseMap[x, y] = noiseMap[x, y] - falloffMap[x, y];
}
}
}
// noiseMap = falloffMap;
return(noiseMap);
}
public void ToSmall()
{
mapWidth = 100;
mapHeight = 100;
falloffMap = FalloffGenerator.GenerateFalloffMap(mapWidth, mapHeight);
Generatemap();
}
public void DrawMapInEditor()
{
if (newSeed)
{
heightMapSettings.noiseSettings.seed = rng.Next();
}
else
{
heightMapSettings.noiseSettings.seed = seed;
}
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)
{
DrawMesh(MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, editorPreviewLOD));
}
else if (drawMode == DrawMode.FalloffMap)
{
DrawTexture(TextureGenerator.TextureFromHeightMap(new HeightMap(FalloffGenerator.GenerateFalloffMap(meshSettings.numVertsPerLine), 0, 1)));
}
}
// When script variable is changed in inspector
void OnValidate()
{
// Clamp values
if (size < 1)
{
size = 1;
}
if (size < 1)
{
size = 1;
}
if (octaves < 1)
{
octaves = 1;
}
if (lacunarity < 1.0f)
{
lacunarity = 1.0f;
}
if (noiseScale < 0.0f)
{
noiseScale = 0.0f;
}
// Create the falloff map
falloffMap = FalloffGenerator.GenerateFalloffMap(size, falloffPower, falloffDistance);
}
/// <summary>
/// Draws the preview map in the scene.
/// </summary>
public void DrawMapInEditor()
{
// applies the texture settings to the material
textureSettings.ApplyToMaterial(terrainMaterial);
textureSettings.UpdateMeshHeights(terrainMaterial, heightMapSettings.MinHeight, heightMapSettings.MaxHeight);
// generates a height map from the mesh, height map and noise settings at location (0, 0)
HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings.NumVertsPerLine, meshSettings.NumVertsPerLine, heightMapSettings, Vector2.zero);
// draws a noise map on a texture
if (drawMode == DrawMode.NoiseMap)
{
DrawTexture(TextureGenerator.TextureFromHeightMap(heightMap));
}
// generates a mesh from the height map
else if (drawMode == DrawMode.Mesh)
{
DrawMesh(MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, editorPreviewLOD));
}
// draws a falloff map on a texture
else if (drawMode == DrawMode.FalloffMap)
{
// passes in a height map generated from the falloff generator
DrawTexture(TextureGenerator.TextureFromHeightMap(new HeightMap(FalloffGenerator.GenerateFalloffMap(meshSettings.NumVertsPerLine), 0, 1)));
}
}
public void DrawMapInEditor()
{
MapData mapData = GenerateMapData(Vector2.zero);
textureData.UpdateMeshHeights(
terrainMaterial, terrainData.minHeight, terrainData.maxHeight);
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(
mapData.heightMap)
);
}
else if (drawMode == DrawMode.Mesh)
{
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.ApplyToMaterial(terrainMaterial);
textureData.UpdateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maxHeight);
HeightMap heightMap;
if (eastSettings != null && westSettings != null && westLocation != null && westLocation != null)
{
Region east = new Region(eastSettings, eastLocationPos);
Region west = new Region(westSettings, westLocationPos);
heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings, new Region(heightMapSettings, east, west, Vector3.zero, power), Vector2.zero);
}
else
{
heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings, heightMapSettings, Vector2.zero);
}
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.numVertsPerLine), 0, 1)));
}
}
public void DrawMapInEditor()
{
GenerarMeshTerreno();
GenerarMapaColores();
//Obtenemos el script MapDisplay que esta en nuestro mismo GameObject
MapDisplay mapDisplay = FindObjectOfType <MapDisplay>();
if (modoDibujo == ModoDibujo.MapaRuido)
{
mapDisplay.DibujarTextura(TextureGenerator.TextureFromHeigthMap(mapaRuido));
}
else if (modoDibujo == ModoDibujo.MapaColores)
{
mapDisplay.DibujarTextura(GeneradorTextura.TextureFromColourMap(mapaColores, dimensionMapa, dimensionMapa));
}
else if (modoDibujo == ModoDibujo.Mesh)
{
//mapDisplay.DibujarMesh2(mesh, TextureGenerator.TextureFromHeigthMap(mapaRuido));
mapDisplay.DibujarMesh2(mesh, TextureGenerator.TextureFromColourMap(mapaColores, dimensionMapa, dimensionMapa));
}
else if (modoDibujo == ModoDibujo.MapaFalloff)
{
mapDisplay.DibujarTextura(GeneradorTextura.TextureFromHeigthMap(FalloffGenerator.GenerateFalloffMap(dimensionMapa)));
}
}
public void ToMedium()
{
mapWidth = 200;
mapHeight = 200;
falloffMap = FalloffGenerator.GenerateFalloffMap(mapWidth, mapHeight);
Generatemap();
}
public void DrawMap()
{
var display = GetComponent <MapDisplay>();
var noiseMap = Noise.GenerateNoiseMap(meshSize, meshSize, seed, scale, octaves, amplitude, frequency, offsets);
if (useFalloff)
{
var falloffData = FalloffGenerator.GenerateFalloffMap(meshSize);
for (int y = 0; y < meshSize; y++)
{
for (int x = 0; x < meshSize; x++)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffData[x, y]);
}
}
}
switch (drawMode)
{
case DrawMode.NoiseMap:
display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap, layers));
break;
case DrawMode.Mesh:
display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap, layers));
display.DrawMesh(MeshGenerator.GenerateTerrianMesh(noiseMap, meshHeightMulti, lod, heightAdjuestCurve));
break;
case DrawMode.FalloffMap:
display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(meshSize), layers));
break;
}
}
public void ToLarge()
{
mapWidth = 255;
mapHeight = 255;
falloffMap = FalloffGenerator.GenerateFalloffMap(mapWidth, mapHeight);
Generatemap();
}
/// <summary>
/// Creates two different noise maps
/// NoiseMap2 : Breaks up the clean edges of each noise map
/// : Will subtract and add to the original noise map
///
/// NoiseMap3 : Breaks up the original noise map by subtrating large chunks
/// </summary>
private float[,] GenerateWorlds(float[,] noiseMap, int _width, int _height, int seed, Vector2 offset, bool useErode,
bool useFalloff, bool useBreakUp)
{
float[,] falloffMap = FalloffGenerator.GenerateFalloffMap(_width, _height);
float[,] noiseMap2 = Noise.GenerateNoiseMap(_width, _height, seed, 14, 2, 5, 2, offset);
float[,] noiseMap3 = Noise.GenerateNoiseMap(_width, _height, seed, 60, 4, 0.1f, 0.1f, offset);
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
if (useErode && noiseMap[x, y] > noiseMap2[x, y])
{
noiseMap[x, y] -= noiseMap2[x, y] / 10;
}
if (useFalloff)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffMap[x, y]);
}
if (useBreakUp)
{
noiseMap[x, y] -= Mathf.Clamp01(noiseMap[x, y] - noiseMap3[x, y]);
}
if (useErode && noiseMap[x, y] > noiseMap2[x, y] && noiseMap[x, y] < 0.67)
{
noiseMap[x, y] += noiseMap2[x, y] / 6;
}
}
}
return(noiseMap);
}
public void DrawMapInEditor()
{
textureData.ApplyToMaterial(terrainMaterial);
textureData.UpdateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maxHeight);
HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(
meshSettings.numVertsPerLine,
meshSettings.numVertsPerLine,
heightMapSettings,
Vector2.zero
);
switch (drawMode)
{
case DrawMode.NoiseMap:
DrawTexture(TextureGenerator.TextureFromeHeightMap(heightMap));
break;
case DrawMode.Mesh:
DrawMesh(MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, editorPreviewLOD));
break;
case DrawMode.FallofMap:
DrawTexture(TextureGenerator.TextureFromeHeightMap(new HeightMap(FalloffGenerator.GenerateFalloffMap(meshSettings.numVertsPerLine), 0, 1)));
break;
}
}
public void GenerateMap()
{
int seed = (worldSeed != "") ? ((int.TryParse(worldSeed, out int i))? i : worldSeed.GetHashCode()) : UnityEngine.Random.Range(int.MinValue, int.MaxValue);
float[,] noiseMap = Noise.GenerateNoiseMap(mapChunkSize, mapChunkSize, seed, noiseScale, octaves, persistance, lacunarity);
Debug.Log("World generated with seed: " + seed.ToString());
if (useFalloff)
{
for (int y = 0; y < mapChunkSize; y++)
{
for (int x = 0; x < mapChunkSize; x++)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffMap[x, y]);
}
}
}
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawNoiseMap(noiseMap);
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap, meshHeightMultiplier, meshHeightCurve, levelOfDetail, true));
}
else if (drawMode == DrawMode.FalloffMap)
{
display.DrawNoiseMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize));
}
newMapGenerated?.Invoke();
}
private void Awake()
{
playersGO = GameObject.FindGameObjectsWithTag("Player");
if (NetworkManager.singleton.playerPrefab.GetComponent <PlayerSetup>().isServer)
{
isHost = true;
}
//mapChunkSize = 241;
//MapData.mapChunkSize = mapChunkSize;
falloffMap = FalloffGenerator.GenerateFalloffMap(mapChunkSize);
if (isHost)
{
seed = Random.Range(int.MinValue, int.MaxValue);
NetworkManager.singleton.playerPrefab.GetComponent <PlayerSetup>().mapSeed = seed;
}
else
{
for (int i = 0; i < playersGO.Length; ++i)
{
if (playersGO[i].GetComponent <PlayerSetup>().isServer)
{
seed = playersGO[i].GetComponent <PlayerSetup>().mapSeed;
break;
}
}
}
MapData.seed = seed;
GenerateMap();
MapData.regions = this.regions;
}
// Each island has it's own perlin noise map
// TODO: Try islands with varying width and heigth
public Island generateIsland(Vector2Int origin, int size, int islandIndex)
{
float[,] noiseMap = NoiseGenerator.GenerateNoiseMap(size, size, seed, scale, octaves, persistance, lacunarity, Vector2.zero, NoiseGenerator.NormalizeMode.Global);
float[,] falloffMap = FalloffGenerator.GenerateFalloffMap(size);
List <TileData> tiles = new List <TileData>();
for (int j = 0; j < size; j++)
{
for (int i = 0; i < size; i++)
{
float value = Mathf.Clamp01(noiseMap[i, j] - falloffMap[i, j]); // Get value by subtracting falloff from noise
// If this is above a certain value then add a tile
if (value > heightMapCutoff)
{
TileData tile = new TileData(origin.x + i, origin.y + j, TileType.Ground);
tile.island = islandIndex;
tiles.Add(tile);
}
}
}
Island island = new Island()
{
origin = origin,
size = size,
tiles = tiles.ToArray(),
index = islandIndex
};
return(island);
}
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
(MeshGenerator.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 DrawMapInEditor()
{
textureData.ApplyToMaterial(terrainMaterial);
textureData.UpdateMeshHeights(terrainMaterial,
heightMapSettings.minHeight, heightMapSettings.maxHeight);
HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(
meshSettings.numVerticesPerLine,
meshSettings.numVerticesPerLine,
heightMapSettings,
Vector2.zero
);
if (drawMode == DrawMode.NoiseMap)
{
DrawTexture(TextureGenerator.TextureFromHeightMap(heightMap));
}
else if (drawMode == DrawMode.Mesh)
{
DrawMesh(MeshGenerator.GenerateTerrainMesh(
heightMap.values,
editorPreviewLOD,
meshSettings
)
);
}
else
{
float[,] values = FalloffGenerator.GenerateFalloffMap(meshSettings.numVerticesPerLine);
DrawTexture(TextureGenerator.TextureFromHeightMap(new HeightMap(values, 0, 1)));
}
}
/// <summary>
/// This function is used to preview all changes made to the map generating functionality in the editor
/// </summary>
public void drawMapInEditor()
{
//Generate the mapData centered around the origin
MapData mapData = generateMapData(Vector2.zero);
//Get the mapDisplay script
MapDisplay mapDisplay = FindObjectOfType <MapDisplay>();
//If the NOISEMAP enum has been selected, we display the noisemap in the editor
if (drawMode == DrawMode.NOISEMAP)
{
//Generate the texture for the heightmap
Texture2D texture = TextureGenerator.textureFromHeightMap(mapData.heightMap);
//Apply the generated texture to the plane game object in map display
mapDisplay.drawTexture(texture);
//If the MESH enum has been selected, we generate the mesh in the editor
}
else if (drawMode == DrawMode.MESH)
{
//Generate the meshData necessary for the mesh
MeshData meshData = MeshGenerator.generateTerrainMesh(mapData.heightMap, terrainData.meshHeightMultiplier, terrainData.meshHeightCurve, editorLOD, terrainData.useFlatShading);
//Apply the mesh to the mesh game object in map display
mapDisplay.drawMesh(meshData);
//If the FALLOFFMAP enum has been selected, we draw a black-and-white texture similar to the noisemap
}
else if (drawMode == DrawMode.FALLOFFMAP)
{
falloffMap = FalloffGenerator.generateFalloffMap(mapChunkSize + 2, falloffCurveA, falloffCurveB);
Texture2D texture = TextureGenerator.textureFromHeightMap(falloffMap);
mapDisplay.drawTexture(texture);
}
}
public static HeightMap GenerateHeightMap(int width, int height, HeightMapSettings settings, MeshSettings meshSettings, Vector2 sampleCenter)
{
float[,] values = Noise.GenerateNoiseMap(width, height, settings.noiseSettings, sampleCenter);
float[,] falloffMap = FalloffGenerator.GenerateFallofMap(meshSettings.numVertsPerLine);
// create a new animation curve for each mesh so that weird spikes dont be spiky (fixes an animation curve 'optamization')
AnimationCurve heightCurve_threadsafe = new AnimationCurve(settings.heightCurve.keys);
float minValue = float.MaxValue;
float maxValue = float.MinValue;
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
if (settings.useFalloff)
{
values[i, j] = Mathf.Clamp01(values[i, j] - falloffMap[i, j]);
}
values[i, j] *= heightCurve_threadsafe.Evaluate(values[i, j]) * settings.heightMultiplier;
if (values[i, j] > maxValue)
{
maxValue = values[i, j];
}
if (values[i, j] < minValue)
{
minValue = values[i, j];
}
}
}
return(new HeightMap(values, minValue, maxValue));
}
public void DrawMapInEditor()
{
textureData.ApplyToMaterial(terrainMaterial);
textureData.UpdateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maxHeight);
HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMapSettings, Vector2.zero);
HeatMap heatMap = HeatMapGenerator.GenerateHeatMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMap, heatMapSettings, Vector2.zero);
TreeMap treeMap = TreeMapGenerator.generateVegetationMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMap, heatMap, treeMapSettings, Vector2.zero);
DestroyTrees(); //temporary fix
if (drawMode == DrawMode.HeightMap)
{
DrawTexture(TextureGenerator.TextureFromHeightMap(heightMap));
}
else if (drawMode == DrawMode.Mesh)
{
DrawMesh(MeshGenerator.GenerateTerrainMesh2(heightMap.values, meshSettings, editorPreviewLOD, heatMap.values));
DrawTrees(heightMap.values, meshSettings, treeMap.values);
}
else if (drawMode == DrawMode.FalloffMap)
{
DrawTexture(TextureGenerator.TextureFromHeightMap(new HeightMap(FalloffGenerator.GenerateFalloffMap(meshSettings.numVertsPerLine), 0, 1)));
}
else if (drawMode == DrawMode.HeatMap)
{
DrawTexture(TextureGenerator.TextureColorizedFromHeatMap(heatMap));
}
else if (drawMode == DrawMode.TreeMap)
{
DrawTexture(TextureGenerator.TextureFromTreeMap(treeMap));
}
}
public void GenerateMap()
{
Random.InitState(mapSeed);//seed
terrainMesh = terrainObject.GetComponent<MeshFilter>().mesh;
fallOffMap = FalloffGenerator.GenerateFalloffMap(chuckSize);
float[,] noisemap = Noise.GenerateNoiseMap(chuckSize, chuckSize, mapSeed, noiseScale, ocataves, presitance, lacunarity, offset);
for (int y = 0; y < chuckSize; y++)
{
for (int x = 0; x < chuckSize; x++)
{
if (useFallOffs)
{
if (fallOffMap == null)
{
fallOffMap = FalloffGenerator.GenerateFalloffMap(chuckSize);
}
noisemap[x, y] = Mathf.Clamp01(noisemap[x, y] - fallOffMap[x, y]);
}
}
}
MapDisplay display = FindObjectOfType<MapDisplay>();
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noisemap, meshHeightMultiplier, meshHeightCurve, editorPrevieuwLOD, flatShading,GetComponent<MapGenerator>()), TextureGenerator.TextureFromColourMap(collorMap, chuckSize, chuckSize));
Invoke("ColorMap", 1);
}
public void DrawMapInEditor()
{
textureData.ApplyToMaterial(terrainMaterial);
textureData.UpdateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maxHeight);
ChunkBorderInfo chunkBorderInfo = new ChunkBorderInfo(false, FalloffGenerator.Corner.TOPLEFT, false, FalloffGenerator.Edge.TOP);
HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings.numberVerticesPerLine, meshSettings.numberVerticesPerLine, heightMapSettings, mapRulesSettings, Vector2.zero, chunkBorderInfo);
CleanScene();
if (drawMode == DrawMode.NoiseMap)
{
DrawTexture(TextureGenerator.TextureFromHeightMap(heightMap));
}
else if (drawMode == DrawMode.FalloffMap)
{
DrawTexture(TextureGenerator.TextureFromHeightMap(new HeightMap(FalloffGenerator.GenerateFalloffMap(meshSettings.numberVerticesPerLine, mapRulesSettings), 0, 1)));
}
else if (drawMode == DrawMode.Mesh)
{
DrawMesh(MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, editorPreviewLOD));
}
else if (drawMode == DrawMode.Map)
{
DrawMesh(MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, editorPreviewLOD));
DrawMap();
}
}
