BiomeData Generate2DBiomeData()
{
BiomeData biomeData = new BiomeData();
BiomeSwitchGraph switchGraph = new BiomeSwitchGraph();
Sampler2D terrainHeight = new Sampler2D(size, step);
PerlinNoise2D perlin = new PerlinNoise2D(seed);
perlin.UpdateParams(seed, step, octaves, persistance, lacunarity);
perlin.ComputeSampler2D(terrainHeight);
terrainHeight = NoiseFunctions.Map(terrainHeight, 0, maxTerrainHeight);
biomeData.waterLevel = waterLevel;
biomeData.isWaterless = isWaterless;
biomeData.UpdateSamplerValue(BiomeSamplerName.terrainHeight, terrainHeight);
if (!isWaterless)
{
biomeData.UpdateSamplerValue(BiomeSamplerName.waterHeight, GenerateWaterHeight(terrainHeight));
}
switchGraph.BuildTestGraph(0);
biomeData.biomeMap = Generate2DBiomeMap(0);
biomeData.biomeSwitchGraph = switchGraph;
return(biomeData);
}
public void UpdateWaterMap()
{
outputBiome.UpdateSamplerValue(BiomeSamplerName.terrainHeight, terrainNoise);
outputBiome.waterLevel = waterLevel;
if (terrainNoise.type == SamplerType.Sampler2D)
{
//terrain mapping
var mappedTerrain = NoiseFunctions.Map(terrainNoise as Sampler2D, mapMin, mapMax, true);
outputBiome.UpdateSamplerValue(BiomeSamplerName.terrainHeight, mappedTerrain);
//waterHeight evaluation
Sampler2D waterHeight = new Sampler2D(terrainNoise.size, terrainNoise.step);
waterHeight.min = waterLevel - mappedTerrain.max;
waterHeight.max = waterLevel;
mappedTerrain.Foreach((x, y, val) => {
waterHeight[x, y] = waterLevel - val;
});
outputBiome.UpdateSamplerValue(BiomeSamplerName.waterHeight, waterHeight);
}
else
{
//TODO 3D terrain water level
}
}
// ====================================================================================== Generate Basic Terrain
// Loops through all verteces and gives them an altiude based on their position and perlin noise
private void ApplyPerlinNoise()
{
for (int index = 0; index < vertices.Count; index++)
{
float noise = NoiseFunctions.LayeredPerlinNoise(vertices[index] + offset, cellSizes, weights);
vertices[index] += (Vector3.Normalize(vertices[index]) * noise * altitude);
}
SetState(states.GENERATE_NORMALS);
}
public override void OnNodeProcess()
{
outputBiome.Reset();
if (terrain != null && terrain.type == SamplerType.Sampler2D)
{
//terrain mapping
outputBiome.UpdateSamplerValue(BiomeSamplerName.terrainHeight, NoiseFunctions.Map(terrain as Sampler2D, mapMin, mapMax, true));
}
}
public void Update()
{
var noise = NoiseFunctions.windNoise(transform.position / 100) * 10;
for (int i = 1; i < Bones.Count; i++)
{
Bones[i].Bone.localPosition = Bones[i].InitialPos + Bones[i].Bone.right * noise * 0.035f;
Bones[i].Bone.localRotation = Bones[i].InitialRot * Quaternion.Euler(0, 0, noise * 5);
}
}
public void LoadPresets(string filePath) //loads map from a given string location
{
if (File.Exists(filePath))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(filePath, FileMode.Open);
NoisePresets[] loadedPresets = (NoisePresets[])bf.Deserialize(file);
NoiseFunctions[] holder = new NoiseFunctions[loadedPresets.Length];
for (int i = 0; i < loadedPresets.Length; i++)
{
holder[i] = new NoiseFunctions(loadedPresets[i]);
}
noiseFunctions = new NoiseFunctions[holder.Length];
noiseFunctions = holder;
file.Close();
}
}
public override void OnInspectorGUI()
{
#region Standard Calls
MapGenerator mapGen = (MapGenerator)target;
if (DrawDefaultInspector())
{
if (mapGen.autoUpdate)
{
mapGen.GenerateMap();
}
}
#endregion
#region Error Control
//error control to keep height positive and non zero
if (mapGen.mapWidth < 1)
{
mapGen.mapWidth = 1;
}
if (mapGen.mapHeight < 1)
{
mapGen.mapHeight = 1;
}
#endregion
#region Terrain Group Functionality
#region Terrain Group Fold Out
#endregion
#endregion
#region Image Save Functionality
if (GUILayout.Button("Save Image"))
{
fileName = EditorUtility.SaveFilePanel("Save a Copy of Texture", Application.dataPath, "mapimage", "png");
mapGen.SaveImage(fileName);
}
#endregion
#region Regions Foldout
showRegionGroups = EditorGUILayout.Foldout(showRegionGroups, "Regions");
if (showRegionGroups)
{
if (GUILayout.Button("Add New Region"))
{
TerrainType[] placeHolder = new TerrainType[mapGen.regions.Length + 1];
for (int k = 0; k < mapGen.regions.Length; k++)
{
placeHolder[k] = mapGen.regions[k];
}
placeHolder[mapGen.regions.Length] = new TerrainType();
mapGen.regions = new TerrainType[placeHolder.Length];
for (int k = 0; k < mapGen.regions.Length; k++)
{
mapGen.regions[k] = placeHolder[k];
}
return;
}
if (GUILayout.Button("Save Regions"))
{
fileName = EditorUtility.SaveFilePanel("Save Current Regions", Application.dataPath, "Regions", "tpr");
mapGen.SaveTerrain(mapGen.regions, fileName);
}
if (GUILayout.Button("Load Regions From File"))
{
fileName = EditorUtility.OpenFilePanel("Load Regions from File ", null, "tpr");
mapGen.LoadTerrain(fileName);
mapGen.GenerateMap();
}
if (GUILayout.Button("Sort Regions By Height"))
{
mapGen.SortRegions();
return;
}
}
for (int i = 0; i < mapGen.regions.Length; i++)
{
if (showRegionGroups)
{
GetInspectorElements(mapGen.regions[i], i, mapGen);
}
}
#endregion
#region Noise Functions Foldout
showNoiseFunctions = EditorGUILayout.Foldout(showNoiseFunctions, "Noise Functions");
if (showNoiseFunctions)
{
if (GUILayout.Button("Add New Noise Function"))
{
NoiseFunctions[] placeholder = new NoiseFunctions[mapGen.noiseFunctions.Length + 1];
for (int j = 0; j < mapGen.noiseFunctions.Length; j++)
{
placeholder[j] = mapGen.noiseFunctions[j];
}
placeholder[mapGen.noiseFunctions.Length] = new NoiseFunctions();
mapGen.noiseFunctions = new NoiseFunctions[placeholder.Length];
for (int j = 0; j < placeholder.Length; j++)
{
mapGen.noiseFunctions[j] = placeholder[j];
}
return;
}
#region Save / Load Functions
if (GUILayout.Button("Save This Noise Preset"))
{
fileName = EditorUtility.SaveFilePanel("Save a New Preset", Application.dataPath, "Noise Preset", "npr");
mapGen.SavePresets(mapGen.noiseFunctions, fileName);
}
if (GUILayout.Button("Load Preset From File"))
{
fileName = EditorUtility.OpenFilePanel("Load a noise File ", null, "npr");
mapGen.LoadPresets(fileName);
mapGen.GenerateMap();
}
}
#endregion
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
if (showNoiseFunctions)
{
GetInspectorElements(mapGen.noiseFunctions[i], i, mapGen);
}
}
#endregion
if (GUILayout.Button("Generate"))
{
mapGen.GenerateMap();
}
}
public void GetInspectorElements(NoiseFunctions noiseFunc, int index, MapGenerator generator)
{
//to autoupdate if this panel has been changed
EditorGUI.BeginChangeCheck();
#region Perlin Function UI
if (noiseFunc.type == NoiseFunctions.NoiseType.Perlin)
{
EditorGUILayout.Space();
string name = "Perlin Noise";
EditorGUILayout.LabelField(name);
noiseFunc.type = (NoiseFunctions.NoiseType)EditorGUILayout.EnumPopup("Type of Noise", noiseFunc.type);
noiseFunc.enabled = EditorGUILayout.ToggleLeft("Enabled", noiseFunc.enabled);
noiseFunc.frequency = (double)EditorGUILayout.Slider("Frequency", (float)noiseFunc.frequency, -20f, 20f);
noiseFunc.lacunarity = (double)EditorGUILayout.Slider("Lacunarity", (float)noiseFunc.lacunarity, -2.0000000f, 2.5000000f);
noiseFunc.persistence = (double)EditorGUILayout.Slider("Persistence", (float)noiseFunc.persistence, -1f, 1f);
noiseFunc.octaves = EditorGUILayout.IntSlider("Octaves", noiseFunc.octaves, 0, 18);
noiseFunc.qualityMode = (LibNoise.QualityMode)EditorGUILayout.EnumPopup("Quality Mode", noiseFunc.qualityMode);
if (GUILayout.Button("Remove"))
{
MapGenerator mapGen = (MapGenerator)target;
NoiseFunctions[] placeholder = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
int tempIndex = 0;
if (i != index)
{
placeholder[tempIndex] = mapGen.noiseFunctions[i];
tempIndex++;
}
}
mapGen.noiseFunctions = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
mapGen.noiseFunctions[i] = placeholder[i];
}
}
}
#endregion
#region Billow Function UI
else if (noiseFunc.type == NoiseFunctions.NoiseType.Billow)
{
EditorGUILayout.Space();
string name = "Billow Noise";
EditorGUILayout.LabelField(name);
noiseFunc.type = (NoiseFunctions.NoiseType)EditorGUILayout.EnumPopup("Type of Noise", noiseFunc.type);
noiseFunc.enabled = EditorGUILayout.ToggleLeft("Enabled", noiseFunc.enabled);
noiseFunc.frequency = (double)EditorGUILayout.Slider("Frequency", (float)noiseFunc.frequency, 0f, 20f);
noiseFunc.lacunarity = (double)EditorGUILayout.Slider("Lacunarity", (float)noiseFunc.lacunarity, 1.5000000f, 3.5000000f);
noiseFunc.persistence = (double)EditorGUILayout.Slider("Persistence", (float)noiseFunc.persistence, 0f, 1f);
noiseFunc.octaves = EditorGUILayout.IntSlider("Octaves", noiseFunc.octaves, 0, 18);
noiseFunc.qualityMode = (LibNoise.QualityMode)EditorGUILayout.EnumPopup("Quality Mode", noiseFunc.qualityMode);
if (GUILayout.Button("Remove"))
{
MapGenerator mapGen = (MapGenerator)target;
NoiseFunctions[] placeholder = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
int tempIndex = 0;
if (i != index)
{
placeholder[tempIndex] = mapGen.noiseFunctions[i];
tempIndex++;
}
}
mapGen.noiseFunctions = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
mapGen.noiseFunctions[i] = placeholder[i];
}
}
}
#endregion
#region Voronoi UI
else if (noiseFunc.type == NoiseFunctions.NoiseType.Voronoi)
{
EditorGUILayout.Space();
string name = "Voronoi Noise";
EditorGUILayout.LabelField(name);
noiseFunc.type = (NoiseFunctions.NoiseType)EditorGUILayout.EnumPopup("Type of Noise", noiseFunc.type);
noiseFunc.enabled = EditorGUILayout.ToggleLeft("Enabled", noiseFunc.enabled);
noiseFunc.frequency = (double)EditorGUILayout.Slider("Frequency", (float)noiseFunc.frequency, 0f, 20f);
noiseFunc.displacement = (double)EditorGUILayout.Slider("Displacement", (float)noiseFunc.displacement, 0f, 20f);
noiseFunc.distance = EditorGUILayout.ToggleLeft("Use Distance", noiseFunc.distance);
if (GUILayout.Button("Remove"))
{
MapGenerator mapGen = (MapGenerator)target;
NoiseFunctions[] placeholder = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
int tempIndex = 0;
if (i != index)
{
placeholder[tempIndex] = mapGen.noiseFunctions[i];
tempIndex++;
}
}
mapGen.noiseFunctions = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
mapGen.noiseFunctions[i] = placeholder[i];
}
}
}
#endregion
#region Ridged Multifractal UI
else if (noiseFunc.type == NoiseFunctions.NoiseType.RidgedMultifractal)
{
EditorGUILayout.Space();
string name = "Ridged Multifractal";
EditorGUILayout.LabelField(name);
noiseFunc.type = (NoiseFunctions.NoiseType)EditorGUILayout.EnumPopup("Type of Noise", noiseFunc.type);
noiseFunc.enabled = EditorGUILayout.ToggleLeft("Enabled", noiseFunc.enabled);
noiseFunc.frequency = (double)EditorGUILayout.Slider("Frequency", (float)noiseFunc.frequency, 0f, 20f);
noiseFunc.lacunarity = (double)EditorGUILayout.Slider("Lacunarity", (float)noiseFunc.lacunarity, 1.5000000f, 3.5000000f);
noiseFunc.octaves = EditorGUILayout.IntSlider("Octaves", noiseFunc.octaves, 0, 18);
noiseFunc.qualityMode = (LibNoise.QualityMode)EditorGUILayout.EnumPopup("Quality Mode", noiseFunc.qualityMode);
if (GUILayout.Button("Remove"))
{
MapGenerator mapGen = (MapGenerator)target;
NoiseFunctions[] placeholder = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
int tempIndex = 0;
if (i != index)
{
placeholder[tempIndex] = mapGen.noiseFunctions[i];
tempIndex++;
}
}
mapGen.noiseFunctions = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
mapGen.noiseFunctions[i] = placeholder[i];
}
return;
}
}
#endregion
#region None UI
else if (noiseFunc.type == NoiseFunctions.NoiseType.None)
{
EditorGUILayout.Space();
string name = "None";
EditorGUILayout.LabelField(name);
noiseFunc.type = (NoiseFunctions.NoiseType)EditorGUILayout.EnumPopup("Type of Noise", noiseFunc.type);
if (GUILayout.Button("Remove"))
{
MapGenerator mapGen = (MapGenerator)target;
NoiseFunctions[] placeholder = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
int tempIndex = 0;
if (i != index)
{
placeholder[tempIndex] = mapGen.noiseFunctions[i];
tempIndex++;
}
}
mapGen.noiseFunctions = new NoiseFunctions[mapGen.noiseFunctions.Length - 1];
for (int i = 0; i < mapGen.noiseFunctions.Length; i++)
{
mapGen.noiseFunctions[i] = placeholder[i];
}
}
noiseFunc.enabled = false;
}
#endregion
//to autoupdate if this inspector element has changed
if (generator.autoUpdate && EditorGUI.EndChangeCheck())
{
generator.GenerateMap();
}
}
