public float GetNoiseFactor(Vector3 pointOnUnitSphere, int index)
{
EarthNoise earthNoise = noiseArray[index];
float factor = 0;
var layerFreq = earthNoise.noiseFrequency;
var layerStrenth = 1.0f;
var lastLayerV = 1.0f; //only used in ridge generation
for (int i = 0; i < earthNoise.noiseMultiLayer; i++)
{
var layerFactor = 0.0f;
if (index == 0)
{
layerFactor = (noise.Evaluate(pointOnUnitSphere * layerFreq + earthNoise.noiseOffset) + 1) * 0.5f * layerStrenth;
}
else
{
var decimalValue = 1 - Mathf.Abs(noise.Evaluate(pointOnUnitSphere * layerFreq + earthNoise.noiseOffset));
var powed = Mathf.Pow(decimalValue, 2);
var multiplyByLastLayerV = powed * lastLayerV;
lastLayerV = multiplyByLastLayerV;
layerFactor = multiplyByLastLayerV * layerStrenth;
}
factor += layerFactor;
layerFreq *= earthNoise.noiseFrequencyMulti;
layerStrenth *= earthNoise.noiseStrenthMulti;
}
// Make a threshould so that only value > threshould get shown
// Others all keep 0
factor = Mathf.Max(0, factor - earthNoise.noiseThreshould);
return(factor * earthNoise.noiseStrength);
}
//#endif
public float Evaluate(Vector3 point, float mountainRadiu, int seed)
{
float noiseValue = 0;
float frequency = settings.baseRoughness;
float amplitude = 1;
for (int i = 0; i < settings.numLayers; i++)
{
float v = noise.Evaluate(point * frequency + settings.centre); //Generate noise
noiseValue += (v + 1) * .5f * amplitude; //Set layer value
//Increase based when greater than 1 and decrease when less that 1 for each layer
frequency *= settings.roughness;
amplitude *= settings.persistence;
}
if (point.y > -0.1f || point.y < -0.3f)
{
noiseValue = Mathf.Max(0, noiseValue - settings.minValue);
}
else
{
noiseValue = 0;
}
return(noiseValue * settings.strength);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = settings.baseRoughness;
float amplitude = 1;
float weight = 1;
// Generate noise layers
for (int i = 0; i < settings.numLayers; i++)
{
float v = 1 - Mathf.Abs(noise.Evaluate(point * frequency + settings.centre));
v *= v;
v *= weight;
weight = Mathf.Clamp01(v * settings.weightMultiplier); // propagate into weight to get clearly defined ridges and crevaces across multiple superimposed layers // Clamp01 clamps the value between 0 and 1
noiseValue += v * amplitude;
frequency *= settings.roughness; // increment (increase) layer frequency
amplitude *= settings.persistence; // increment (decrease) layer amplitude
}
noiseValue = noiseValue - settings.minValue; //Mathf.Max(0, noiseValue - settings.minValue); // minimum altitude is base sphere
return(noiseValue * settings.strength);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = noiseSettings.baseRoughness;
float amplitude = 1;
float weight = 1;
for (int i = 0; i < noiseSettings.noiseLayers; ++i)
{
float noiseIteration = 1 - Mathf.Abs(noise.Evaluate(point * frequency + noiseSettings.center));
noiseIteration *= noiseIteration;
// In each layer, we multiply the weight and set it for the next layer.
// Regions that start out lower down remain undetailed in comparison to higher regions.
noiseIteration *= weight;
weight = Mathf.Clamp01(noiseIteration * noiseSettings.weightMultiplier);
noiseValue += noiseIteration * amplitude;
frequency *= noiseSettings.roughness;
amplitude *= noiseSettings.persistence;
}
noiseValue = Mathf.Max(0, noiseValue - noiseSettings.minimum);
return(noiseValue * noiseSettings.strength);
}
public float EvaluateVertexPoint(Vector3 a_pointOnMesh, int a_vertexCount, int a_vertexDivisions)
{
//Use this layers noise function to evaluate where vertex should sit on mesh.
float noiseValue = (m_noise.Evaluate(a_pointOnMesh, a_vertexCount, a_vertexDivisions) + 1) * 0.5f;
return(noiseValue);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = settings.baseRoughness;
float amplitude = 1;
float weight = 1;
for (int i = 0; i < settings.numberLayers; i++)
{
float v = noise.Evaluate(point * frequency + settings.center);
v = 1 - Mathf.Abs(v);
v *= v;
v *= weight;
weight = Mathf.Clamp01(v * settings.weightMultiplier);
noiseValue += v * amplitude;
frequency *= settings.roughness;
amplitude *= settings.persistence;
}
noiseValue = Mathf.Max(settings.minValue, noiseValue);
return(noiseValue * settings.strength);
}
public float Evaluate(Vector3 point)
{
//float noiseValue = noise.Evaluate(point);
float noiseValue = 0;
float frequency = noiseSettings.baseRoughness;
float amplitude = 1;
float weight = 1;
for (int i = 0; i < noiseSettings.layerCount; i++)
{
float v = 1 - Mathf.Abs(noise.Evaluate(point * frequency + noiseSettings.center));
v *= v;
v *= weight;
weight = Mathf.Clamp01(v * noiseSettings.weightMultiplier);
noiseValue += v * amplitude;
frequency *= noiseSettings.roughness;
amplitude *= noiseSettings.persistance;
}
noiseValue = Mathf.Max(0, noiseValue - noiseSettings.minValue);
return(noiseValue * noiseSettings.strenght);
}
public float GetDensity(float x, float y, float z)
{
Vector3 toCenter = new Vector3(x, y, z);
float radius = noise.Evaluate(toCenter.normalized * 1000f / 40f) * 9f + 1000f;
return(toCenter.magnitude - radius);
}
public float Evaluate(Vector3 _point)
{
float noiseValue = noise.Evaluate((_point + offset) * frequency);
noiseValue = (noiseValue + 1) * 0.5f;
return(noiseValue);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = settings.baseRoughness;
float amplitude = 1;
float weight = 1;
float noiseIn = 0;
float spike = 0;
float layer;
/*for (int i = 0; i < settings.numLayers; i++)
* {
* float v = 1-Mathf.Abs(noise.Evaluate(point * frequency + settings.centre));
* v *= v;
* v *= weight;
* weight = Mathf.Clamp01(v * settings.weightMultiplier);
*
* noiseValue += v * amplitude;
* frequency *= settings.roughness;
* amplitude *= settings.persistence;
* }*/
noiseValue += (Mathf.Clamp01(noise.Evaluate(point * 50 + settings.centre)) * 0.1f + 0.9f) * 0.15f;
//Mountain Filter
noiseIn = noise.Evaluate(point * 10 + settings.centre);
layer = Mathf.Pow(Mathf.Clamp01(noiseIn + 0.1f), 2) * 1f;
//noiseValue += layer;
//Mountains
noiseIn = 1 - Mathf.Abs(noise.Evaluate(point * 30 + settings.centre));
layer = Mathf.Pow(noiseIn, 2) * layer * 2;
noiseValue += layer;
//noiseIn = 1 - Mathf.Abs(noise.Evaluate(point * 40 + settings.centre));
//layer = Mathf.Pow(noiseIn, 2)*5 * layer;
//noiseValue += layer;
float layer2 = layer;
noiseIn = 1 - Mathf.Abs(noise.Evaluate(point * 200 + settings.centre));
layer = Mathf.Pow(noiseIn, 2) * 0.5f * Mathf.Pow(Mathf.Clamp01(layer + 0.5f) - 0.5f, 2);
noiseValue += layer;
noiseIn = 1 - Mathf.Abs(noise.Evaluate(point * 210 + settings.centre));
layer = -Mathf.Pow(noiseIn, 2) * 0.5f * Mathf.Pow(Mathf.Clamp01(layer2 + 0.5f) - 0.5f, 2);
noiseValue += layer;
noiseIn = 1 - Mathf.Abs(noise.Evaluate(point * 500 + settings.centre));
layer = Mathf.Pow(noiseIn, 2) / 10 * layer;
noiseValue += layer;
//noiseValue *= spike;
noiseIn = noise.Evaluate(point * 400 + settings.centre);
layer = Mathf.Clamp01(Mathf.Pow((noiseIn - 0.0f), 2)) * 0.05f;
noiseValue += layer;
//noiseValue = noiseValue - settings.minValue;
//noiseValue += spike;
return(noiseValue * settings.strength);
}
public static float[,] GenerateHeightmap(NoiseSettings noiseSettings, int size, bool normalize = true)
{
var map = new float[size, size];
var prng = new Random(noiseSettings.seed);
var noise = new Noise(noiseSettings.seed);
// Generate random offset for each layer
var offsets = new Vector2[noiseSettings.numLayers];
for (var layer = 0; layer < noiseSettings.numLayers; layer++)
{
offsets[layer] = new Vector2((float)prng.NextDouble() * 2 - 1, (float)prng.NextDouble() * 2 - 1) *
10000;
}
// offsets[layer] += noiseSettings.offset;
var minHeight = float.MaxValue;
var maxHeight = float.MinValue;
for (var y = 0; y < size; y++)
{
for (var x = 0; x < size; x++)
{
var frequency = noiseSettings.scale;
float amplitude = 1;
float height = 0;
// Sum layers of noise
for (var layer = 0; layer < noiseSettings.numLayers; layer++)
{
var sampleX = (double)x / size * frequency + offsets[layer].x + noiseSettings.offset.x;
var sampleY = (double)y / size * frequency + offsets[layer].y + noiseSettings.offset.y;
height += (float)noise.Evaluate(sampleX, sampleY) * amplitude;
frequency *= noiseSettings.lacunarity;
amplitude *= noiseSettings.persistence;
}
map[x, y] = height;
minHeight = Mathf.Min(minHeight, height);
maxHeight = Mathf.Max(maxHeight, height);
}
}
// Normalize values to range 0-1
if (normalize)
{
for (var y = 0; y < size; y++)
{
for (var x = 0; x < size; x++)
{
map[x, y] = Mathf.InverseLerp(minHeight, maxHeight, map[x, y]);
}
}
}
return(map);
}
private void MapElevation()
{
Noise noise = new Noise();
noise.SetParameters(8, 0.5f, 0.25f, 1f, 2f);
foreach (ErosionRegion region in erosionRegions.Values)
{
region.Elevation = (noise.Evaluate(region.Center) + 1f) / 2f;
}
}
public float Evaluate(Vector3 point)
{
float to = perlin.Evaluate(point);
float from = oldPerlin.Evaluate(point);
float evaluation = Mathf.Lerp(from, to, passedTime / settings.duration);
evaluation = noiseFilter.Evaluate(evaluation);
return(evaluation);
}
public static float[,] Generate(NoiseSettings noiseSettings, int width, int length, bool normalize = true)
{
float[,] map = new float[width, length];
System.Random prng = new System.Random(noiseSettings.seed);
Noise noise = new Noise(noiseSettings.seed);
Vector2[] offsets = new Vector2[noiseSettings.numLayers];
for (int layer = 0; layer < noiseSettings.numLayers; layer++)
{
// use settings
offsets[layer] = new Vector2((float)prng.NextDouble() * 2 - 1, (float)prng.NextDouble() * 2 - 1) * 10000;
}
float minHeight = float.MaxValue;
float maxHeight = float.MinValue;
for (int l = 0; l < length; l++)
{
for (int w = 0; w < width; w++)
{
float frequency = noiseSettings.scale;
float amplitude = 1;
float height = 0;
// Sum layers of noise
for (int layer = 0; layer < noiseSettings.numLayers; layer++)
{
double sampleX = (double)w / width * frequency + offsets[layer].x + noiseSettings.offset.x;
double sampleY = (double)l / length * frequency + offsets[layer].y + noiseSettings.offset.y;
height += (float)noise.Evaluate(sampleX, sampleY) * amplitude;
frequency *= noiseSettings.lacunarity;
amplitude *= noiseSettings.persistence;
}
map[w, l] = height;
minHeight = Mathf.Min(minHeight, height);
maxHeight = Mathf.Max(maxHeight, height);
}
}
if (normalize)
{
for (int y = 0; y < length; y++)
{
for (int x = 0; x < width; x++)
{
map[x, y] = Mathf.InverseLerp(minHeight, maxHeight, map[x, y]);
}
}
}
return(map);
}
void Generate(int width, int height)
{
Vector2 planetCentre = new Vector2(width / 2f, height / 2f);
float planetRadius = Mathf.Max(width, height) / 2f;
for (int y = 0; y *yOffset <= height / 2 + 2 *border *yOffset; y++)
{
for (int x = 0; x *xOffset <= width / 2 + 2 *border *xOffset; x++)
{
Vector3 position = new Vector3(x * xOffset + y * yOffset * .5f + (y % 2) * 0.079f - (y / 2) * yOffset, y * yOffset, 0);
if (position.magnitude <= planetRadius)
{
float noiseValue = (noise.Evaluate(position * noiseScale) + 1) * .5f;
if (noiseValue >= noiseThreshhold)
{
CreatePlanetNode(x - y / 2, y, position);
}
else
{
CreateBlankNode(x - y / 2, y, position);
}
}
else
{
CreateBlankNode(x - y / 2, y, position);
}
if (x != 0)
{
x *= -1;
if (x < 0)
{
x--;
}
}
}
if (y != 0)
{
y *= -1;
if (y < 0)
{
y--;
}
}
}
ProcessMap();
StaticBatchingUtility.Combine(nodeHolder.gameObject);
}
private void SetMaterialSettings()
{
var sphereSettings = Resources.Load <SphereSettings>("SphereSettings");
var texture2D = new Texture2D(sphereSettings.textureSize, sphereSettings.textureSize, TextureFormat.RG16, false)
{
filterMode = FilterMode.Point, wrapMode = TextureWrapMode.Clamp
};
var noiseR = new Noise(DateTime.Now.Millisecond);
var noiseG = new Noise(DateTime.Now.Millisecond / 2);
for (int i = 0; i < sphereSettings.textureSize; i++)
{
for (int j = 0; j < sphereSettings.textureSize; j++)
{
var rValue = noiseR.Evaluate(new Vector3(i, j) * sphereSettings.frequency) * sphereSettings.power;
var gValue = noiseG.Evaluate(new Vector3(i, j) * sphereSettings.frequency) * sphereSettings.power;
texture2D.SetPixel(i, j, new Color(rValue, gValue, 0f));
}
}
texture2D.Apply();
sphereSettings.SphereMaterial.SetTexture("_Noise", texture2D);
sphereSettings.SphereMaterial.SetFloat("Speed", sphereSettings.speed);
MaterialPropertyBlock props = new MaterialPropertyBlock();
foreach (var sphere in _spheres)
{
var color = Random.ColorHSV(0,
1,
1,
1,
1,
1,
0.7f,
0.9f);
Vector3 lightVector = (Vector3.up * Random.Range(-10f, 10f) +
Vector3.right * Random.Range(-10f, 10f) +
Vector3.back * 20).normalized;
props.SetColor("_Color", color);
props.SetVector("_LightVector", lightVector);
sphere.SphereMeshRenderer.SetPropertyBlock(props);
}
}
public float evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = settings.baseRoughness;
float amplitude = 1;
for (int i = 0; i < settings.nLayers; i++)
{
float v = noise.Evaluate(point * frequency + settings.centre);
noiseValue += (v + 1) * .5f * amplitude;
frequency *= settings.roughness; //roughness > 1 -> frequency of noise increases with each layer
amplitude *= settings.persistence; //persistence < 1 -> amplitude decreases with each layer
}
noiseValue = noiseValue - settings.minValue;
return(noiseValue * settings.strength);
}
public double SimpleNoiseFilterProcess(double3 point, ref Noise noise)
{
double noiseValue = 0;
double frequency = baseRoughness;
double amplitude = 1;
for (int i = 0; i < numLayers; i++)
{
double v = noise.Evaluate(point * frequency + center);
noiseValue += (v + 1) * .5f * amplitude;
frequency *= roughness;
amplitude *= persistence;
}
return((noiseValue - 1) * strength);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = settings.BaseRoughness;
float amplitude = 1;
for (int i = 0; i < settings.NumLayers; i++)
{
float v = noise.Evaluate(point * frequency + settings.Centre);
noiseValue += (v + 1) * .5f * amplitude;
frequency *= settings.Roughness;
amplitude *= settings.Persistence;
}
noiseValue = Mathf.Max(0, noiseValue - settings.MinValue);
return(noiseValue * settings.Strength);
}
public float Evaluate(Vector3 _point)
{
float noiseValue = 0;
float roughness = settings.baseRoughness;
float persistence = 1;
for (var i = 0; i < settings.octaves; i++)
{
float v = noise.Evaluate(_point * roughness + settings.centre);
noiseValue += v * persistence;
roughness *= settings.roughness;
persistence *= settings.persistence;
}
return(noiseValue * settings.scale);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = settings.baseRoughness;
float amplitude = 1;
for (int i = 0; i < settings.numLayers; i++)
{
float v = noise.Evaluate(point * frequency + settings.center);
noiseValue += (v + 1) * 0.5f * amplitude;
frequency *= settings.roughness;
amplitude *= settings.persistance;
}
noiseValue = Mathf.Max(0, noiseValue - settings.minValue);
return(noiseValue * settings.strength);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = baseRoughness;
float amplitude = 1;
for (int i = 0; i < numLayers; i++)
{
float v = noise.Evaluate(point * frequency + centre);
noiseValue += (v + 1) * .5f * amplitude;
frequency *= roughness;
amplitude *= persistence;
}
noiseValue = Mathf.Max(0, noiseValue - minValue);
return(noiseValue * strength);
}
public float Evaluate(Vector3 point)
{
float value = 0;
float frequency = settings.baseRoughness;
float amplitude = settings.strength;
for (int i = 0; i < settings.layersCount; ++i)
{
float t = noise.Evaluate(point * frequency + settings.center);
value += (t + 1) * 0.5f * amplitude;
frequency *= settings.roughness;
amplitude *= settings.persistence;
}
return(value);
}
public float Eval(Vector3 point)
{
float value = 0;
float freq = noiseSettings.startRough;
float amp = 1;
for (int i = 0; i < noiseSettings.layerCount; i++)
{
float j = noise.Evaluate(point * freq + noiseSettings.center);
value += ((1 + j) / 2) * amp;
freq *= noiseSettings.rough;
amp *= noiseSettings.persist;
}
value = Mathf.Max(0, value - noiseSettings.min);
return(value * noiseSettings.strength);
}
public float Evaluate(Vector3 position, NoiseSettings settings, bool limit)
{
float noiseValue = 0;
float frequency = settings.baseRoughness;
float amplitude = 1;
for (int i = 0; i < settings.numberLayers; i++)
{
float v = noise.Evaluate(position * frequency + settings.noiseCenter);
noiseValue += (v + 1) / 2 * amplitude;
frequency *= settings.roughness;
amplitude *= settings.persistence;
}
// if (limit)
// noiseValue = Mathf.Max(0, noiseValue - settings.minValue);
return(noiseValue * settings.strength);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;//(noise.Evaluate(point * settings.roughtness + settings.center) + 1) * 0.5f;
float frequency = settings.baseRoughtness;
float amplitude = 1;
for (int i = 0; i < settings.octaves; i++)
{
float v = noise.Evaluate(point * frequency + settings.center);
noiseValue += (v + 1) * 0.5f * amplitude;
frequency *= settings.roughtness;
amplitude *= settings.persistence;
}
noiseValue = noiseValue - settings.minValue;
return(noiseValue * settings.strenght);
}
public float Evaluate(Vector3 pos)
{
float noiseValue = 0;
float frequency = settings.baseFrequency;
float amplitude = 1;
for (int i = 0; i < settings.octaves; ++i)
{
float v = noise.Evaluate(pos * frequency + settings.center);
noiseValue += (v + 1) * .5f * amplitude;
frequency *= settings.frequency;
amplitude *= settings.persistence;
}
noiseValue = noiseValue - settings.minValue;
return(noiseValue * settings.strength);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = settings.baseRoughness;
float amplitude = 1;
for (int i = 0; i < settings.numLays; i++)
{
float v = noise.Evaluate(point * frequency + settings.center);
noiseValue += amplitude * (v + 1) * 1 / 2;
frequency *= settings.roughness;
amplitude *= settings.persistence;
//when roughness > 1 the frequency will increase with each layer, and when persistence < 1 amplitude will decrease
}
noiseValue = Mathf.Max(0, noiseValue - settings.minValue); // we do not want negative noise
return(noiseValue * settings.strength);
}
public float Evaluate(Vector3 point)
{
float noiseValue = 0;
float frequency = _settings.baseRoughness;
float amplitude = 1;
for (int i = 0; i < _settings.numLayers; i++)
{
float v = _noise.Evaluate(point * frequency + _settings.center);
noiseValue += (v + 1) * .5f * amplitude;
frequency *= _settings.roughness;
amplitude *= _settings.persistence;
}
noiseValue = noiseValue - _settings.minValue;
return(noiseValue * _settings.strength);
}
public float Eval(Vector3 point)
{
float noiseVal = 0f;
float freq = settings.baseRoughness;
float amp = 1f;
for (int i = 0; i < settings.numLayers; i++)
{
float v = noise.Evaluate(point * freq + settings.centre);
noiseVal += (v + 1) * .5f * amp;
amp *= settings.persistence;
freq *= settings.roughness;
}
noiseVal = Mathf.Max(0, noiseVal - settings.minValue);
return(noiseVal * settings.strength);
}
