/// <summary>
/// Initialises the component.
/// </summary>
public void Start()
{
this.MeshGenerator = new TerrainMeshGeneratorCubes();
// Get a reference to the related terrain components
this.cTerrain = this.GetComponent<TerrainComponent>();
this.cMeshFilter = this.GetComponent<MeshFilter>();
this.cMeshRenderer = this.GetComponent<MeshRenderer>();
// Create the empty mesh
this.cMeshFilter.mesh = new Mesh();
}
void GenerateTerrain()
{
m_terrainMeshGenerator = gameObject.GetComponent <TerrainMeshGenerator>();
m_terrainMeshGenerator.Init();
m_terrainMeshGenerator.mapName = mapName;
#if UNITY_EDITOR && !TEST_NOT_EDITOR
m_terrainMeshGenerator.Generate(MapPointsArr);
#else
m_terrainMeshGenerator.LoadData();
#endif
}
void Gen()
{
TerrainMap tMap = new TerrainMap(92, 128, pointDistance);
TerrainGenerator.GenerateTerrain(ref tMap);
GetComponent <MeshFilter>().mesh.Clear();
GetComponent <MeshFilter>().mesh = TerrainMeshGenerator.CreateMeshFilter(tMap);
//GetComponent<MeshCollider>().sharedMesh = TerrainMeshGenerator.CreateCollisionMesh();
GetComponent <Mesh2DColliderMaker>().CreatePolygon2DColliderPoints();
TerrainMeshGenerator.ClearMeshData();
}
public void GenerateMap()
{
int minSize = Mathf.Min(mapWidth, mapHeight); //Get the smaller size for the FalloffGenerator
float[,] noiseMap = PerlinNoise.GenerateNoiseMap(mapWidth, mapHeight, seed, noiseScale, octaves, persistance, lacunarity, offset);
Color[] colourMap = new Color[mapWidth * mapHeight];
falloffMap = FalloffGenerator.GenerateFalloffMap(minSize);
//Loop through the map and apply heights
for (int x = 0; x < mapWidth; x++)
{
for (int y = 0; y < mapHeight; y++)
{
if (useFalloff) //If using Falloff to create islands, subtract the falloff map and clamp between 0-1 values
{
noiseMap[x, y] = Mathf.Clamp(noiseMap[x, y] - falloffMap[x, y], 0, 1);
}
float height = noiseMap[x, y];
//Loop through the Biomes
for (int i = 0; i < biomes.Length; i++)
{
if (height <= biomes[i].height)
{
colourMap[y * mapWidth + x] = biomes[i].colour;
break;
}
}
}
}
if (renderMode == RenderMode.Noise)
{
terrainMap.RenderMap(TextureMaker.TextureFromHeightMap(noiseMap));
}
else if (renderMode == RenderMode.Colour)
{
terrainMap.RenderMap(TextureMaker.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
else if (renderMode == RenderMode.Mesh)
{
terrainMap.RenderMesh(TerrainMeshGenerator.GenerateTerrainMesh(noiseMap, heightMultiplier), TextureMaker.TextureFromColourMap(colourMap, mapWidth, mapHeight));
}
GeneratePlants(800);
}
GameObject GenerateChunk(float[,] heightMap, float[,] humidityMap, Vector2 coord)
{
GameObject chunk = null;
Mesh terrainMesh = TerrainMeshGenerator.CreateTerrain(heightMap, heightMultiplier, heightCurve, LOD);
if (drawMode == DrawType.terrain_customMaterial)
{
chunk = noiseDisplay.DrawTerrainChunkWithCustomMaterial(terrainMesh, humidityMap, coord);
}
else if (drawMode == DrawType.terrain_colorMap)
{
chunk = noiseDisplay.DrawTerrainChunkWithColorMap(terrainMesh, heightMap, humidityMap, coord);
}
return(chunk);
}
public void GenerateMap()
{
float[,] noiseMap = NoiseGenerator.GenerateNoiseMap(seed, chunkSize, chunkSize, levelOfDetail, mainNoiseData.scale, mainNoiseData.octaves, mainNoiseData.persistance, mainNoiseData.lacunarity, mainNoiseData.offset, true);
float[,] secondNoiseMap = null, combinedNoiseMap = null;
if (useSecondNoiseMap)
{
secondNoiseMap = NoiseGenerator.GenerateNoiseMap(seed, chunkSize, chunkSize, levelOfDetail, secondNoiseData.scale, secondNoiseData.octaves, secondNoiseData.persistance, secondNoiseData.lacunarity, secondNoiseData.offset, false);
combinedNoiseMap = NoiseGenerator.CombineNoiseMaps(noiseMap, secondNoiseMap, influencePower);
}
noiseMap = SetNoiseFilters(noiseMap);
switch (drawMode)
{
case DrawType.heightMap:
if (useSecondNoiseMap)
{
FindObjectOfType <MapDisplay>().DrawHeightMap(combinedNoiseMap);
}
else
{
FindObjectOfType <MapDisplay>().DrawHeightMap(noiseMap);
}
break;
case DrawType.colorMap:
if (useSecondNoiseMap)
{
FindObjectOfType <MapDisplay>().DrawColorMap(combinedNoiseMap, regions);
}
else
{
FindObjectOfType <MapDisplay>().DrawColorMap(noiseMap, regions);
}
break;
case DrawType.terrain:
FindObjectOfType <MapDisplay>().DrawMesh(TerrainMeshGenerator.CreateTerrain(noiseMap, heightMultiplier, secondNoiseMap, influencePower, levelOfDetail));
break;
case DrawType.terrain_colorMap:
FindObjectOfType <MapDisplay>().DrawMeshWithColorMap(TerrainMeshGenerator.CreateTerrain(noiseMap, heightMultiplier, secondNoiseMap, influencePower, levelOfDetail), noiseMap, regions);
break;
}
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(this);
return;
}
gameObject.hideFlags = HideFlags.HideInHierarchy;
DontDestroyOnLoad(gameObject);
init();
}
public TerrainGenerator()
{
HeightMapGenerator = new HeightMapGenerator();
TerrainChunks = new Dictionary <Vector2, TerrainChunk>();
TerrainObject = new GameObject("Terrain");
for (int y = -2; y < 3; y++)
{
for (int x = -2; x < 3; x++)
{
Vector2 coordinates = new Vector2(x, y);
float[,] heightMap = HeightMapGenerator.GetHeightMap(x, y);
TerrainChunk chunk = TerrainMeshGenerator.GenerateTerrainMesh(heightMap, 0);
chunk.transform.SetParent(TerrainObject.transform);
TerrainChunks.Add(coordinates, chunk);
chunk.Init(x, -y, heightMap);
}
}
}
public Chunk(float x, float y, float z, int size, int height, float surfaceCrossValue, float noiseScaleFactor, Material material)
{
size++;
this.size = size;
this.height = height;
data = new float[size, height, size];
this.xOrigin = x;
this.yOrigin = y;
this.zOrigin = z;
this.surfaceCrossValue = surfaceCrossValue;
this.noiseScaleFactor = noiseScaleFactor;
meshGameObject = new GameObject("Chunk" + x + "," + y + "," + z, typeof(MeshFilter), typeof(MeshRenderer), typeof(MeshCollider));
meshGameObject.transform.position = new Vector3(x, y, z);
mesh = new Mesh();
FillData();
TerrainMeshGenerator.FillMesh(ref mesh, data, size, height, surfaceCrossValue);
data = null;
meshGameObject.GetComponent <MeshFilter>().mesh = mesh;
meshGameObject.GetComponent <MeshCollider>().sharedMesh = mesh;
meshGameObject.GetComponent <MeshRenderer>().material = material;
}
public void GenerateMap()
{
if (newSeed)
{
seed = Random.Range(0, 100000);
}
float[,] noiseMap = PerlinNoise.GenerateNoiseMap(seed, chunkSize, chunkSize, scale, octaves, persistance, lacunarity, offset);
switch (drawMode)
{
case DrawType.heightMap:
FindObjectOfType <NoiseDisplay>().DrawHeightMap(noiseMap);
break;
case DrawType.colorMap:
FindObjectOfType <NoiseDisplay>().DrawColorMap(noiseMap, regions);
break;
case DrawType.terrain:
FindObjectOfType <NoiseDisplay>().DrawMesh(TerrainMeshGenerator.CreateTerrain(noiseMap, heightMultiplier, meshHeightCurve, LOD), noiseMap, regions);
break;
}
}
void ApplyDataToMesh()
{
TerrainMeshGenerator.FillMesh(ref localMesh, data, width, height, surfaceCrossValue);
meshFilter.mesh = localMesh;
}
void ApplyDataToMesh()
{
TerrainMeshGenerator.FillMesh(ref mesh, data, size, height, surfaceCrossValue);
GetComponent <MeshFilter>().mesh = mesh;
}
