public void AddNoiseOctave(float a_lacunarityOfOctave, float a_persistanceOfOctave, float a_scaleFactorMin, float a_scaleFactorMax, float a_variationMin, float a_variationMax)
{
//Adds a new layer of noise the generation of this planet.
NoiseLayer temp = new NoiseLayer(a_lacunarityOfOctave, a_persistanceOfOctave, a_scaleFactorMin, a_scaleFactorMax, a_variationMin, a_variationMax);
m_noiseLayers.Add(temp);
}
public NoiseGroup(int layerCount, float baseFreq, float freqMult, float baseAmp, float ampMult, int seed = 42000)
{
noises = new List <NoiseLayer>(layerCount);
for (int i = 0; i < layerCount; i++)
{
NoiseLayer noise = new NoiseLayer(baseFreq * (float)System.Math.Pow(freqMult, i), baseAmp * (float)System.Math.Pow(ampMult, i), seed);
noises.Add(noise);
}
}
NoiseVector[] CreateNoiseVectors(NoiseLayer[] noiseLayers)
{
int vectorCount = 0;
foreach (NoiseLayer layer in noiseLayers)
vectorCount += layer.Samples;
NoiseVector[] vectors = new NoiseVector[vectorCount];
int vIndex = 0;
foreach (NoiseLayer layer in noiseLayers) {
uint scrambleU = (uint)Random.Range(int.MinValue, int.MaxValue);
uint scrambleV = (uint)Random.Range(int.MinValue, int.MaxValue);
uint offset = 2011;
for (uint i = 0; i < (uint)layer.Samples; ++i) {
Vector2 sample2D = RandomSamplers.Utils.Sample02(i + offset, scrambleU, scrambleV);
vectors[vIndex].Normal = SphereDistribution.Sample(sample2D).Direction;
vectors[vIndex].Amplitude = layer.Amplitude;
vectors[vIndex].Radius = layer.Radius;
++vIndex;
}
}
return vectors;
}
public void SetupNoiseLayers()
{
for (int i = 0; i < noiseLayers.Length; i++)
{
noiseLayers[i] = new NoiseLayer();
noiseLayers[i].noiseSettings = new NoiseSettings();
// Generate Type of Noise
if (RidgidNoiseLayerChance < Random.Range(0, 100))
{
noiseLayers[i].noiseSettings.filterType = NoiseSettings.FilterType.Ridgid;
}
else
{
noiseLayers[i].noiseSettings.filterType = NoiseSettings.FilterType.Simple;
}
// Generate needed Noise Settings
noiseLayers[i].noiseSettings.simpleNoiseSettings = new NoiseSettings.SimpleNoiseSettings();
noiseLayers[i].noiseSettings.ridgidNoiseSettings = new NoiseSettings.RidgidNoiseSettings();
// Generate Values for Simple Noise
noiseLayers[i].noiseSettings.simpleNoiseSettings.strength = Random.Range(Control.MinStrength, Control.MaxStrength);
noiseLayers[i].noiseSettings.simpleNoiseSettings.numLayers = Random.Range(Control.MinNumLayers, Control.MaxNumLayers);
noiseLayers[i].noiseSettings.simpleNoiseSettings.baseRoughness = Random.Range(Control.MinBaseRoughness, Control.MaxBaseRoughness);
noiseLayers[i].noiseSettings.simpleNoiseSettings.roughness = Random.Range(Control.MinRoughness, Control.MaxRoughness);
noiseLayers[i].noiseSettings.simpleNoiseSettings.persistence = Random.Range(Control.MinPersistence, Control.MaxPersistence);
// Generate Values for Ridgid Noise
noiseLayers[i].noiseSettings.ridgidNoiseSettings.strength = Random.Range(Control.MinStrength, Control.MaxStrength);
noiseLayers[i].noiseSettings.ridgidNoiseSettings.numLayers = Random.Range(Control.MinNumLayers, Control.MaxNumLayers);
noiseLayers[i].noiseSettings.ridgidNoiseSettings.baseRoughness = Random.Range(Control.MinBaseRoughness, Control.MaxBaseRoughness);
noiseLayers[i].noiseSettings.ridgidNoiseSettings.roughness = Random.Range(Control.MinRoughness, Control.MaxRoughness);
noiseLayers[i].noiseSettings.ridgidNoiseSettings.persistence = Random.Range(Control.MinPersistence, Control.MaxPersistence);
noiseLayers[i].noiseSettings.ridgidNoiseSettings.weightMultiplier = Random.Range(Control.MinWeightMultiplier, Control.MaxWeightMultiplier);
}
}
void GenerateMap()
{
int tileset = Random.Range(0, tilesets.Length);
int xOffset = width / 2;
int yOffset = height / 2;
//randomness
int layercount = noiseLayers.Length;
for (int c = 0; c < layercount; c++)
{
noiseLayers[c].Randomize();
}
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Tile settile;
bool hasTile = false;
//base shapes
for (int c = 0; c < layercount; c++)
{
NoiseLayer layer = noiseLayers[c];
if (layer.enabled)
{
float noiseValue = Mathf.PerlinNoise(layer.randomoffset + x * layer.freq, y * layer.freq);
//transformations
noiseValue = Mathf.Pow(noiseValue, layer.coeff);
if (noiseValue >= layer.threshholdlower && noiseValue <= layer.threshholdupper)
{
if (layer.negative)
{
hasTile = false;
}
else
{
hasTile = true;
}
}
}
}
if (hasTile)
{
settile = GetRandomTile(tileset);
}
else
{
settile = null;
}
tileMap.SetTile(new Vector3Int(x - xOffset, y - yOffset, 0), settile);
}
}
//places portal, makes sure within range
Vector3Int portalPos = new Vector3Int(Random.Range(-xOffset + portalMargin, xOffset - portalMargin), Random.Range(-yOffset + portalMargin, yOffset - portalMargin), 0);
if (Mathf.Abs(portalPos.x) <= minDist)
{
portalPos.x = minDist * (int)Mathf.Sign(portalPos.x);
}
if (Mathf.Abs(portalPos.y) <= minDist)
{
portalPos.y = minDist * (int)Mathf.Sign(portalPos.y);
}
portal.transform.position = tileMap.CellToWorld(portalPos);
//clears area around spawn and portal
for (int x = -4; x <= 4; x++)
{
for (int y = -4; y <= 4; y++)
{
tileMap.SetTile(new Vector3Int(x, y, 0), null);
tileMap.SetTile(new Vector3Int(x + portalPos.x, y + portalPos.y, 0), null);
}
}
}
public float GetNoiseValue(NoiseLayer layer, double latitude, double longitude)
{
return(GetNoiseValue(layer.GetConfiguration(), layer.Zoom, latitude, longitude));
}
void OnGUI()
{
GUILayout.BeginArea(new Rect(0, 0, position.width, position.height)); {
worldName = EditorGUILayout.TextField("World Name", worldName);
EditorGUILayout.Space();
detail = EditorGUILayout.IntField("Cloud detail", detail);
EditorGUILayout.Space();
int noiseLevels = EditorGUILayout.IntField("Noise levels", noiseLayers.Length);
if (noiseLayers.Length != noiseLevels) {
NoiseLayer[] newNoiseLayers = new NoiseLayer[noiseLevels];
for (int i = 0; i < Mathf.Min(noiseLayers.Length, noiseLevels); ++i)
newNoiseLayers[i] = noiseLayers[i];
noiseLayers = newNoiseLayers;
}
for (int i = 0; i < noiseLayers.Length; ++i) {
EditorGUILayout.LabelField("Noise layer " + i);
noiseLayers[i].Samples = EditorGUILayout.IntField("Samples", noiseLayers[i].Samples);
noiseLayers[i].Amplitude = EditorGUILayout.FloatField("Amplitude", noiseLayers[i].Amplitude);
noiseLayers[i].Radius = EditorGUILayout.FloatField("Radius", noiseLayers[i].Radius);
}
EditorGUILayout.Space();
if (GUILayout.Button("Create"))
Create();
} GUILayout.EndArea();
}
