|
public static TextureFromColourMap ( Color colourMap, int width, int height ) : |
||
| colourMap | Color | |
| width | int | |
| height | int | |
| return | ||
public void GenerateMap()
{
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;
}
}
}
}
MapDisplay display = FindObjectOfType <MapDisplay> ();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap));
}
else if (drawMode == DrawMode.ColourMap)
{
display.DrawTexture(TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
}
Texture2D GenerateTexture(float[,] noiseMap)
{
Color[] colorMap = new Color[dimensions.x * dimensions.z];
Random.InitState(seed);
for (int y = 0; y < dimensions.z; y++)
{
for (int x = 0; x < dimensions.x; x++)
{
for (int i = 0; i < regions.Length; i++)
{
if (noiseMap[x, y] <= regions[i].height)
{
colorMap[y * dimensions.x + x] = regions[i].color.Evaluate(Random.value);
break;
}
}
}
}
string id = "Terrain" + System.DateTime.UtcNow.ToFileTime().ToString();
AssetDatabase.CreateAsset(TextureGenerator.TextureFromColourMap(colorMap, dimensions.x, dimensions.z), "Assets/Terrain Data/" + id + " Texture.asset");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return((Texture2D)AssetDatabase.LoadAssetAtPath("Assets/Terrain Data/" + id + " Texture.asset", typeof(Texture2D)));
}
public void DrawMapInEditor()
{
MapData mapData = GenerateMapData(Vector2.zero, drawMode, noiseData.lineSpacing);
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.Lines)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, terrainData.meshHeightMultiplier, terrainData.meshHeightCurve, editorPreviewLOD, terrainData.useFlatShading), TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, terrainData.meshHeightMultiplier, terrainData.meshHeightCurve, editorPreviewLOD, terrainData.useFlatShading), TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.FalloffMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize)));
}
}
public void DrawMapInEditor()
{
MapData mapData = GenerateMap(Vector2.zero);
MapDisplay display = FindObjectOfType <MapDisplay>();
planeObj = GameObject.Find("Plane");
meshObj = GameObject.Find("Mesh");
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(mapData.heightMap));
planeObj.transform.position = new Vector3(0, 1, 0);
meshObj.transform.position = new Vector3(0, -200, 0);
}
else if (drawMode == DrawMode.ColourMap)
{
display.DrawTexture(TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
planeObj.transform.position = new Vector3(0, 1, 0);
meshObj.transform.position = new Vector3(0, -200, 0);
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, levelOfDetail), TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
planeObj.transform.position = new Vector3(0, -200, 0);
meshObj.transform.position = new Vector3(0, 1, 0);
}
else if (drawMode == DrawMode.FallOfMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(FallOffGenerator.GenerateFallOffMap(mapChunkSize)));
}
}
public void DrawMapInEditor()
{
MapData mapData = GenerateMapData(Vector2.zero);
//Referencing the MapDisplay method
MapDisplay display = FindObjectOfType <MapDisplay>();
//Saying which drawMode we are in and whether to draw the colours or not
if (drawMode == DrawMode.NoiseMap)
{
//Displaying the noise map
display.DrawTexture(TextureGenerator.TextureFromHeightMap(mapData.heightMap));
}
else if (drawMode == DrawMode.ColourMap)
{
//Displaying the colour map
display.DrawTexture(TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
//Displaying the mesh map
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 GenerateMap()
{
//float[,] noiseMap = Noise.
float[,] noiseMap = Noise.GenerateNoiseMap(MapWidht, MapHeight, Seed, NoiseScale, Octaves, Persistance, Lacunarity, Offset);
//Loop through the noiseMap, get the height and if the Region has that certain height then print the color
Color[] colourMap = new Color[MapWidht * MapHeight];
for (int y = 0; y < MapHeight; y++)
{
for (int x = 0; x < MapWidht; x++)
{
float currentHeight = noiseMap[x, y];
for (int i = 0; i < Regions.Length; i++)
{
if (currentHeight <= Regions[i].Height)
{
colourMap[y * MapWidht + 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(colourMap, MapWidht, MapHeight));
}
}
public void CreateIsland()
{
Texture2D islandTexture = TextureGenerator.TextureFromColourMap(this.islandData.colorMap, (int)this.meshDensity - 1, (int)(this.jaggedDensity * 2f) + 1);
meshRenderer.material.mainTexture = islandTexture;
this.meshFilter.mesh = this.islandData.meshData.CreateMesh();
SetVisible(true);
}
public void GenerateMap()
{
MapDisplay display = FindObjectOfType <MapDisplay>();
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
if (drawMode == DrawMode.NoiseMap || drawMode == DrawMode.ColourMap)
{
float[,] noiseMapI = Mesh.GenerateNoiseMap(mapSize, mapSize, seed, scale, octaves, persistance, lacunarity, offset);
if (drawMode == DrawMode.ColourMap)
{
float[,] falloffMapI = FalloffGenerator.GenerateFalloffMap(mapSize, falloff.x, falloff.y, falloffMode.ToString());
Color[] colourMap = new Color[mapSize * mapSize];
for (int y = 0; y < mapSize; y++)
{
for (int x = 0; x < mapSize; x++)
{
if (useFalloff)
{
noiseMapI[x, y] = Mathf.Clamp(noiseMapI[x, y] - falloffMapI[x, y], 0, border);
}
float currentHeight = noiseMapI[x, y];
for (int i = 0; i < regions.Length; i++)
{
if (currentHeight <= regions[i].height)
{
colourMap[y * mapSize + x] = regions[i].colour;
break;
}
}
}
}
display.DrawTexture(TextureGenerator.TextureFromColourMap(colourMap, mapSize));
}
else
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMapI));
}
Debug.Log("Max height jump between neighbours: " + MaxNeighbourJump(noiseMapI) + "\n");
}
else if (drawMode == DrawMode.FalloffMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapSize, falloff.x, falloff.y, falloffMode.ToString())));
}
else if (drawMode == DrawMode.PolygonMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(MeshGenerator.GeneratePolygons(mapSize, polygonSize, polygonSeed)));
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
Debug.Log("PolygonsRunTime " + elapsedTime);
}
public void GenerateMap()
{
float[,] noiseMap = Noise.GenerateNoiseMap(seed, mapWidth, mapHeight, noiseScale, octaves, persistance, lacunarity, offset);
MapDisplay display = FindObjectOfType <MapDisplay>();
display.threshold = threshold;
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;
}
}
}
}
_upperWall.transform.position = new Vector3(0, 0, mapHeight / 2 - 1);
_upperWall.transform.localScale = new Vector3(mapWidth + 1, multiplier * 2, 2.5f);
_downWall.transform.position = new Vector3(0, 0, -mapHeight / 2 + 1);
_downWall.transform.localScale = new Vector3(mapWidth + 1, multiplier * 2, 2.5f);
_leftWall.transform.position = new Vector3(-mapWidth / 2 + 1, 0, 0);
_leftWall.transform.localScale = new Vector3(2.5f, multiplier * 2, mapHeight + 1);
_rightWall.transform.position = new Vector3(mapWidth / 2 - 1, 0, 0);
_rightWall.transform.localScale = new Vector3(2.5f, multiplier * 2, mapHeight + 1);
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.terrainMesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap, multiplier), TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
else if (drawMode == DrawMode.DungeonMap)
{
display.DrawNoiseDungeon(noiseMap);
}
else if (drawMode == DrawMode.dungeonMesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap, multiplier, threshold), TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
else if (drawMode == DrawMode.infiniteDungeonMesh)
{
}
}
void onMapDataResived(MapData mapData)
{
this.mapData = mapData;
mapDataRecived = true;
Texture2D texture = TextureGenerator.TextureFromColourMap(mapData.ColorMap, MapGenerator.mapChunkSize_plus_1, MapGenerator.mapChunkSize_plus_1);
meshRenderer.material.mainTexture = texture;
updateTerrianChunk();
}
/*
* public void DrawMapInEditor ()
* {
* MapData mapData = GenerateMapData();
*
* 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, levelOfDetail), TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
* }
* }
*/
public void Generate()
{
float[,] noiseMap;
MapDisplay display = FindObjectOfType <MapDisplay>();
if (textureHeightMap)
{
float xRatio = textureHeightMap.width / mapWidth;
float yRatio = textureHeightMap.height / mapHeight;
noiseMap = new float[mapWidth, mapHeight];
for (int x = 0; x < mapWidth; x++)
{
for (int y = 0; y < mapWidth; y++)
{
noiseMap[x, y] = textureHeightMap.GetPixel(x * (int)xRatio, y * (int)yRatio).grayscale;
}
}
}
else
{
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;
}
}
}
switch (drawMode)
{
case DrawMode.NoiseMap:
display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap));
break;
case DrawMode.ColourMap:
display.DrawTexture(TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
break;
case DrawMode.Mesh:
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap, meshHeightMultiplier, meshHeightCurve, levelOfDetail), TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
break;
}
}
}
public void Draw()
{
var mapData = GenerateMapData(Vector2.zero);
var display = GetComponent <MapDisplay>();
var texture = TextureGenerator.TextureFromColourMap(mapData.ColourMap, MapChunkSize, MapChunkSize);
display.DrawMinimap(texture);
display.DrawMesh(GenerateMeshFromHeightmap(mapData.HeightMap, heightCurve, previewLevelOfDetail), texture);
}
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));
if (generateGameObjects)
{
GenerateGameObjects genGOScript = display.meshRenderer.transform.gameObject.GetComponent <GenerateGameObjects>();
if (genGOScript == null)
{
genGOScript = display.meshRenderer.transform.gameObject.AddComponent <GenerateGameObjects>();
}
genGOScript.seed = seed;
genGOScript.StartGenerateObjects();
genGOScript.offset = offset;
genGOScript.levelOfDetail = editorPreviewLOD;
genGOScript.mapData = mapData;
genGOScript.genClouds = generateClouds;
}
}
else if (drawMode == DrawMode.Falloff)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize)));
}
if (generateWater)
{
bool genNewWater = true;
foreach (Transform child in gameObject.transform)
{
if (child.tag == "Water")
{
genNewWater = false;
}
}
if (genNewWater)
{
EndlessTerrain endTer = GetComponent <EndlessTerrain>();
GameObject waterIns = GameObject.Instantiate(endTer.waterPlane, new Vector3(0, -0.22f * EndlessTerrain.scale, 0), Quaternion.identity);
waterIns.transform.parent = gameObject.transform;
waterIns.AddComponent <DisableOnStartup>();
}
}
}
void OnMapDataReceived(MapData mapData)
{
this.mapData = mapData;
mapDataReceived = true;
Texture2D texture = TextureGenerator.TextureFromColourMap(mapData.colourMap, MapGenerator.dimensione, MapGenerator.dimensione);
meshRenderer.material.mainTexture = texture;
UpdateTerrainChunk();
}
public void GenerateMap()
{
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++)
{
if (useFalloff)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffMap[x, y]);
}
if (useOverlay)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - overlayMap[x, y]);
}
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;
}
}
}
}
MapDisplay display = FindObjectOfType <MapDisplay>();
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.FalloffMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapHeight)));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap), TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
else if (drawMode == DrawMode.OverlayMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(OverlayGenerator.GenerateOverlayMap(mapHeight)));
}
}
private void OnMapDataReceived(MapData mapData)
{
m_mapData = mapData;
m_mapDataReceived = true;
var texture = m_meshRenderer.material.mainTexture as Texture2D;
texture = TextureGenerator.TextureFromColourMap(mapData.colourMap, MapGenerator.MapChunkSize, MapGenerator.MapChunkSize, texture);
m_meshRenderer.material.mainTexture = texture;
UpdateTerrainChunk();
}
void OnMapDataRecieved(MapData mapData)
{
this.mapData = mapData;
mapDataRecieved = true;
Texture2D texture = TextureGenerator.TextureFromColourMap(mapData.colourMap, mapGeneration.mapChunkSize, mapGeneration.mapChunkSize);
meshRenderer.material.mainTexture = texture;
UpdateTerrainChunk();
}
void OnMapDataRecieved(MapData mapData)
{
//mapGenerator.RequestMeshData(mapData, OnMeshDataRecieved);
this.mapData = mapData;
mapDataRecieved = true;
Texture2D texture = TextureGenerator.TextureFromColourMap(mapData.colourMap, MapGenerator.mapChunkSize, MapGenerator.mapChunkSize);
meshRenderer.material.mainTexture = texture;
UpdateTerrainChunk();
}
void OnMapDataReceived(MapData mapData)
{
_mapData = mapData;
_mapDataReceived = true;
Texture2D texture2D = TextureGenerator.TextureFromColourMap(mapData.ColourMap,
TerrainGenerator.MapChunkSize, TerrainGenerator.MapChunkSize);
_meshRenderer.material.mainTexture = texture2D;
Update();
}
void OnMapDataReceived(MapData mapData)
{
this.mapData = mapData;
mapDataReceived = true;
// Add texture
Texture2D texture = TextureGenerator.TextureFromColourMap(mapData.colourMap, MapGenerator.mapChunkSize, MapGenerator.mapChunkSize);
meshRenderer.material.mainTexture = texture;
UpdateTerrainChunk(); // also update terrain chunk when we receive map data
}
public static Texture2D GenerateTexture(MapData mapData, int lod)
{
if (SatelliteImageService.UseSatelliteImage())
{
ColorMap colorMap = TextureGenerator.ColorMapForSatelliteImage(mapData);
return(TextureGenerator.TextureFromColourMap(colorMap.colorArray, colorMap.width, colorMap.height));
}
else
{
ColorMap colorMap = TextureGenerator.ColorMapForHeightAndAreas(mapData, lod);
return(TextureGenerator.TextureFromColourMap(colorMap.colorArray, colorMap.width, colorMap.height));
}
}
public void GenerateMap()
{
// random generation for variables if wanted
/*mapWidth = (int)Random.Range(1, 20);
* mapHeight = (int)Random.Range(1, 20);
* noiseScale = Random.Range(0f, 1f);*/
float[,] noiseMap = Noise.GenerateNoiseMap(mapWidth, mapHeight, seed, noiseScale, octaves, persistance, lacunarity, offset);
// determining which region each part of the map is
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;
}
}
}
}
MapDisplay display = FindObjectOfType <MapDisplay>();
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.MESH)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap), TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
else if (drawMode == DrawMode.PLANEANDMAP)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap), TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
display.DrawTexture(TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
}
public void TextureColorCorrectWithSmallColourMap()
{
Color[] colourMap = new Color[9];
for (int x = 0; x < colourMap.GetLength(0); x++)
{
colourMap[x] = x == 0 ? Color.black : Color.white;
}
Texture2D texture2D = TextureGenerator.TextureFromColourMap(colourMap, 3, 3);
Assert.True(texture2D.GetPixel(0, 0).Equals(Color.black), "Test heightmap (0,0) not black.");
Assert.True(texture2D.GetPixel(2, 2).Equals(Color.white), "Test heightmap (2,2) not white.");
}
public void GenerateMap()
{
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++)
{
if (useFalloff)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffMap[x, y]);
}
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 (currentHeight <= 0.4 && aux > 0)
{
//Instantiate(pfb1, new Vector3(x, currentHeight, y), Quaternion.identity);
aux--;
}
}
}
}
MapDisplay display = FindObjectOfType <MapDisplay>();
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.Mesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap, meshHeightMultiplier, meshHeightCurve, useFlatShading), TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
else if (drawMode == DrawMode.FalloffMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapWidth)));
}
}
public void GenerateMap()
{
float[,] noiseMap = Noise.GenerateNoiseMap(mapWidth, mapHeight, seed, noiseScale, octaves, persistence, 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].color;
break;
}
}
}
}
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.noiseMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap));
}
else if (drawMode == DrawMode.colourMap)
{
display.DrawTexture(TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
/*for(int x = 0; x < mapWidth; x++)
* {
* for(int y = 0; y < mapHeight; y++)
* {
* if (y % 2 == 1)
* {
*
* }
*
* Vector3 instantiateLocation = new Vector3(x * 10, y * 10, -10);
* GameObject tile = Instantiate(deepWater, instantiateLocation, Quaternion.identity);
* tile.transform.SetParent(GameObject.Find("TileHolder").transform);
*
* }
* }*/
}
public void GenerateMap()
{
float[,] noiseMap = Noise.GenerateNoiseMap(mapWidth, mapHeight, (int)seed, noiseScale, octaves, persistance, lacunarity, offset);
float GridSpace = mapHeight * mapWidth;
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)
{
//if (PointInSphere(new Vector3(transform.position.x + x * GridSpace, transform.position.y, transform.position.z + y * GridSpace),
// new Vector3(transform.position.x + GridSpace, transform.position.y, transform.position.z + GridSpace), GridSpace))
colourMap[y * mapWidth + x] = regions[i].colour;
Building_Spawn.x = x;
Building_Spawn.z = y;
Instantiate(Building_Base, Building_Spawn, Quaternion.Euler(-90, 0, 0), Buildings);
break;
}
}
}
MapDisplay display = FindObjectOfType <MapDisplay>();
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.Mesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(noiseMap), TextureGenerator.TextureFromColourMap(colourMap, mapWidth, mapHeight));
Debug.Log(display.name);
}
}
}
public override void Generate()
{
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>();
switch (drawMode)
{
case DrawMode.ColourMap:
display.DrawTexture(TextureGenerator.TextureFromColourMap(colourMap, mapChunkSize, mapChunkSize));
break;
case DrawMode.NoiseMap:
display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap));
break;
case DrawMode.MeshMap:
var mesh = MeshGenerator.GenerateTerrainMesh(noiseMap, mapHeightMultiplier, heightCurve, meshLoD);
var texture = TextureGenerator.TextureFromColourMap(colourMap, mapChunkSize, mapChunkSize);
display.DrawMesh(mesh, texture);
break;
}
}
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));
}
}
public void DrawMapInEditor()
{
MapDisplay display = FindObjectOfType <MapDisplay> ();
if (drawMode == DrawMode.Gizmos)
{
drawGizmos = true;
}
else if (drawMode == DrawMode.Mesh)
{
drawGizmos = false;
FloatingIsland editorIsland = new FloatingIsland(gameObject.transform.position, this.maxRadius, seed, islandScale, jaggedDensity, jaggedScale, meshDensity, this.maxTopHeight, this.maxBotHeight);
Texture2D islandTexture = TextureGenerator.TextureFromColourMap(editorIsland.islandData.colorMap, (int)meshDensity - 1, (int)(jaggedDensity * 2f) + 1);
display.DrawIslandMesh(editorIsland.islandData.meshData, islandTexture);
}
}
public void GenerateMap()
{
float[,] noiseMap;
if (usingGANS)
{
noiseMap = MagnusScript.ganmap;
}
else
{
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 == DrawMode.NoiseMap)
{
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));
}
}