public void PlayNoise(NoiseType Noise)
{
//try Make A noise
try
{
if (Noise == NoiseType.NewIncident)
{
System.Media.SoundPlayer sp = new System.Media.SoundPlayer("newjob.wav");
sp.Play();
sp.Dispose();
}
if (Noise == NoiseType.NewAutowatch)
{
System.Media.SoundPlayer sp = new System.Media.SoundPlayer("autowatch.wav");
sp.Play();
sp.Dispose();
}
}
catch
{
//Ahwell, no sound
}
}
public Texture2D GetCloudBase(UnityEngine.Gradient cloudGradient, int size, NoiseType type)
{
ModuleBase Generator = GetModule(type);
//Billow Generator = new Billow(
// 1f,
// 2f,
// 0.5f,
// 6,
// Random.Range(0, int.MaxValue),
// QualityMode.Low);
Noise2D map = new Noise2D(size, size / 2, Generator);
map.GenerateSpherical(
south,
north,
west,
east);
var tex = map.GetTexture(cloudGradient);
tex.Apply();
return(tex);
}
/// <summary>
/// Generates a 2D Fractional Brownian Motion noise on top of Simplex noise generated
/// </summary>
/// <param name="type">Carmody or Gustavson Noise</param>
/// <param name="height">Height of the grid being generated</param>
/// <param name="x">X position</param>
/// <param name="y">Y position</param>
/// <param name="octaves">Number of layers</param>
/// <param name="frequency">Level of detail</param>
/// <param name="amplitude">How tall we want stuff</param>
/// <param name="gain">Persistence, makes amplitude shrink or not shrink (0.5f is standard with Lacunarity of 2.0f)</param>
/// <param name="lacunarity">Multiplied with frequency every octave (2.0f is standard)</param>
/// <returns>Noise value for input parameters</returns>
static float FractionalBrownianMotion(NoiseType type, int height, float x, float y, int octaves, float frequency, float amplitude, float gain = 0.5f, float lacunarity = 2.0f)
{
// For each grid point, get the value
float total = 0.0f;
frequency = 1.0f / height;
amplitude = gain;
// For each octave generate noise and add it towards the total
for (i = 0; i < octaves; ++i)
{
if (type == NoiseType.Carmody)
{
total += CarmodyNoise(x * frequency, 0, y * frequency) * amplitude;
}
else
{
total += GustavsonNoise(x * frequency, y * frequency) * amplitude;
}
frequency *= lacunarity;
amplitude *= gain;
}
//now that we have the value, put it in
return(total);
}
public static void AddNoise(string path, List <NoiseType> noiseTypes, double attenMin, double attenMax, bool monoChrome)
{
if (noiseTypes.Count < 1)
{
return;
}
MagickImage img = IOUtils.ReadImage(path);
if (img == null)
{
return;
}
NoiseType chosenNoiseType = GetRandomNoiseType(noiseTypes);
PreProcessing(path, "- Noise Type: " + chosenNoiseType.ToString());
Random rand = new Random();
double att = (double)rand.Next((int)attenMin, (int)attenMax + 1);
Program.Print("-> Using attenuate factor " + att);
if (monoChrome)
{
MagickImage noiseImg = new MagickImage(MagickColors.White, img.Width, img.Height);
noiseImg.AddNoise(chosenNoiseType, att);
noiseImg.ColorSpace = ColorSpace.LinearGray;
noiseImg.Write(Path.Combine(IOUtils.GetAppDataDir(), "lastnoiseimg.png"));
img.Composite(noiseImg, CompositeOperator.Multiply);
}
else
{
img.AddNoise(chosenNoiseType, att);
}
img.Write(path);
PostProcessing(img, path, path);
}
public void PlaySound(NoiseType type, float range)
{
Observer[] allObs = FindObjectsOfType <Observer>();
foreach (Observer o in allObs)
{
Vector3 otherPos = o.transform.position;
Vector3 myPos = transform.position;
float cDist = Vector3.Distance(otherPos, myPos);
if (o.gameObject != gameObject && cDist < range)
{
RaycastHit[] hits = Physics.RaycastAll(myPos, otherPos - myPos, cDist);
float minDist = float.MaxValue;
foreach (RaycastHit h in hits)
{
GameObject oObj = h.collider.gameObject;
if (oObj != gameObject && oObj.GetComponent <NoiseProofing>() != null)
{
minDist = Mathf.Min(minDist, Vector3.Distance(transform.position, h.point));
}
}
float diff = Mathf.Abs(cDist - minDist);
if (cDist - 0.3f < minDist)
{
Debug.DrawRay(myPos, otherPos - myPos, Color.blue);
o.ListenToNoise(toNoise(type, range - cDist, cDist));
}
}
}
}
public void GetSeedValues(Planet planet, int index)
{
System.Random generator;
if (GlobalVariables.rand == null)
{
generator = new System.Random();
}
else
{
generator = GlobalVariables.rand;
}
noiseType = NoiseType.Simple;
if (index > 0)
{
int genNum = generator.Next(System.Enum.GetNames(typeof(NoiseType)).Length);
noiseType = (NoiseType)genNum;
}
Vector2 vec = GetMinMaxForVariable(NoiseSettingsVariables.Strength, index);
strength = Mathf.Lerp(vec.x, vec.y, (float)generator.NextDouble());
vec = GetMinMaxForVariable(NoiseSettingsVariables.NumberOfLayers, index);
numberOfLayers = generator.Next((int)vec.x, (int)vec.y);
vec = GetMinMaxForVariable(NoiseSettingsVariables.BaseRoughness, index);
baseRoughness = Mathf.Lerp(vec.x, vec.y, (float)generator.NextDouble());
vec = GetMinMaxForVariable(NoiseSettingsVariables.Roughness, index);
roughness = Mathf.Lerp(vec.x, vec.y, (float)generator.NextDouble());
vec = GetMinMaxForVariable(NoiseSettingsVariables.Persistence, index);
persistence = Mathf.Lerp(vec.x, vec.y, (float)generator.NextDouble());
centre = planet.transform.position + new Vector3(generator.Next(1000), generator.Next(1000), generator.Next(1000));
vec = GetMinMaxForVariable(NoiseSettingsVariables.MinValue, index);
minValue = Mathf.Lerp((strength + persistence) * 0.7f, strength + persistence, (float)generator.NextDouble());
useFirstLayerAsMask = index == 0 ? false : generator.Next(2) != 0;
}
public void SetNoiseType(NoiseType noiseType)
{
switch (noiseType) {
case NoiseType.None:
renderer.enabled = false;
break;
case NoiseType.Uniform:
renderer.enabled = true;
renderer.sprite = uniformSpreadSprite;
indicator.transform.localScale = Vector2.one;
break;
case NoiseType.WindLeft:
renderer.enabled = true;
renderer.sprite = windSpreadSprite;
indicator.transform.localScale = new Vector2 (-1, 1);
break;
case NoiseType.WindRight:
renderer.enabled = true;
renderer.sprite = windSpreadSprite;
indicator.transform.localScale = Vector2.one;
break;
default:
break;
}
}
public void Draw()
{
noiseType = (NoiseType)EditorGUILayout.EnumPopup("Fill", noiseType);
if (noiseType == NoiseType.PERLIN)
{
gradient = EditorGUILayout.GradientField("Color", gradient);
octaves = EditorGUILayout.IntSlider("Octaves", octaves, 1, 10);
perlinNoiseScale = EditorGUILayout.Slider("Scale", perlinNoiseScale, 0.01f, 1000f);
perlinNoisePersistence = EditorGUILayout.Slider("Persistence", perlinNoisePersistence, 0f, 1f);
seed = EditorGUILayout.IntSlider("Seed", seed, 1, 100000);
perlinNoiseOffset = EditorGUILayout.Vector2Field("Offset", perlinNoiseOffset);
flip = EditorGUILayout.Toggle("Flip", flip);
}
else if (noiseType == NoiseType.RANDOM)
{
seed = EditorGUILayout.IntSlider("Seed", seed, 1, 100000);
useColors = EditorGUILayout.Toggle("Use colors", useColors);
}
else if (noiseType == NoiseType.VORONOI)
{
voronoiDstType = (VoronoiDistanceMetric)EditorGUILayout.EnumPopup("Distance type", voronoiDstType);
sites = EditorGUILayout.IntField("Sites", sites);
seed = EditorGUILayout.IntSlider("Seed", seed, 1, 100000);
useColors = EditorGUILayout.Toggle("Use colors", useColors);
renderFlat = EditorGUILayout.Toggle("Render flat", renderFlat);
flip = EditorGUILayout.Toggle("Flip", flip);
}
}
private void OnGUI()
{
_noiseType = (NoiseType)EditorGUILayout.EnumPopup("NoiseType", _noiseType);
if (_texOutputOptions == null)
{
_texOutputOptions = new NoiseTextureOutputOptions();
}
_texOutputOptions.OnGUI();
if (!_noiseOptions.ContainsKey(_noiseType))
{
_noiseOptions.Add(_noiseType, NoiseEditorUtil.CreateNoiseOptionsByType(_noiseType));
}
_noiseOptions[_noiseType].OnGUI();
if (GUILayout.Button("Generate"))
{
var noiseOptions = _noiseOptions[_noiseType];
INoise2D noise = noiseOptions.CreateNoise(_texOutputOptions);
_generatedTexture = _texOutputOptions.ExportNoiseTo(noise);
}
if (_generatedTexture != null)
{
var rect = EditorGUILayout.GetControlRect(GUILayout.Width(256), GUILayout.Height(256));
GUI.DrawTexture(rect, _generatedTexture);
}
}
/// <summary>
/// Get a perlin noise for use with biomes
/// </summary>
/// <param name="position">Position to take noise from</param>
/// <returns>The float of the position in the noise map</returns>
private float GetPerlinNoise(Vector2 position, NoiseType noiseType)
{
Vector2 perlPos = Vector2.zero;
switch (noiseType)
{
case NoiseType.height:
perlPos = new Vector2(position.x / heightScale + seed, position.y / heightScale + seed);
break;
case NoiseType.humidity:
perlPos = new Vector2(position.x / humidityScale + seed, position.y / humidityScale + seed);
break;
case NoiseType.flora:
perlPos = new Vector2(position.x / floraScale + seed, position.y / floraScale + seed);
break;
case NoiseType.tile:
perlPos = new Vector2(position.x / tileScale + seed, position.y / tileScale + seed);
break;
default:
break;
}
return(Mathf.Clamp01(Mathf.PerlinNoise(perlPos.x, perlPos.y)));
}
public void SelectNoiseType(NoiseType noiseType) =>
ExecuteAction(() =>
{
_model.SelectedNoiseType = noiseType;
View.SelectedNoise = noiseType;
View.ShowOptionsTabFor(noiseType);
});
public PerlinNoise(Vector2 octave, float scale, NoiseType type)
{
mSeed = new Vector2(Random.Range(-HALF_SEED_RANGE, HALF_SEED_RANGE), Random.Range(-HALF_SEED_RANGE, HALF_SEED_RANGE));
mOctave = octave;
mScale = scale;
mType = type;
}
/// <summary>
///
/// </summary>
public CreateNoiseField()
: base("Create Noise Field", "NoiseField",
"Creates a procedural noise field",
"SpatialSlur", "Field")
{
NoiseType = NoiseType.Perlin;
}
public void SelectOptionsTab(NoiseType noiseType) =>
ExecuteAction(() =>
{
_model.SelectedNoiseType = noiseType;
View.SelectedNoise = noiseType;
});
public void SetNoiseType(NoiseType noiseType)
{
switch (noiseType)
{
case NoiseType.None:
renderer.enabled = false;
break;
case NoiseType.Uniform:
renderer.enabled = true;
renderer.sprite = uniformSpreadSprite;
indicator.transform.localScale = Vector2.one;
break;
case NoiseType.WindLeft:
renderer.enabled = true;
renderer.sprite = windSpreadSprite;
indicator.transform.localScale = new Vector2(-1, 1);
break;
case NoiseType.WindRight:
renderer.enabled = true;
renderer.sprite = windSpreadSprite;
indicator.transform.localScale = Vector2.one;
break;
default:
break;
}
}
public NoiseSource(NoiseType type, int duration, int maxIntensity, Point position, string message)
{
Type = type;
this.duration = duration;
MaxIntensity = maxIntensity;
Position = position;
Message = message;
}
public void Event_Noise(Position pos, NoiseType type)
{
long range = NoiseRanges[type];
foreach (Entitys.Entity e in GetEntitys_Range(pos, range))
{
e.Event_Noise(pos, 1 - pos.Distance(e.Pos) / range);
}
}
public void SetNoise(float scale, float frequency, float amplitude, int octaves, NoiseType noiseType)
{
this.scale = scale;
this.frequency = frequency;
this.amplitude = amplitude;
this.octaves = octaves;
this.noiseType = noiseType;
}
public void Clone(Noise n)
{
scale = n.scale;
frequency = n.frequency;
amplitude = n.amplitude;
octaves = n.octaves;
noiseType = n.noiseType;
}
public Bitmap CreateNoiseBitmap(NoiseType noiseType, Size size, NoiseConfig cfg)
{
var b = _noiseProvider[noiseType];
var noiseBitmap = b.GetBitmap(size, cfg);
Info = $"Density: {b.Density:P}, Coverage: {b.Coverage:P}";
return(noiseBitmap);
}
FractalNoiseBase GetGeneratorForNoiseType(NoiseType type)
{
switch (type) {
case NoiseType.Billow: return new BillowNoise(seed);
case NoiseType.Pink: return new PinkNoise(seed);
case NoiseType.Ridge: return new RidgeNoise(seed);
default: return new PinkNoise(seed);
}
}
public Window(NoiseType Type, int Seed)
: base(1080, 720, GraphicsMode.Default, "Fractal Algorithm Sandbox",
GameWindowFlags.Default, DisplayDevice.Default,
3, 2, GraphicsContextFlags.ForwardCompatible)
{
CamRot = Quaternion.Identity;
CamPos = new Vector3(0, 0.2f, 1.5f);
Noise = GetNoiseType(Type, Seed);
}
public static Bitmap CreateNoise(NoiseType noise, int width, int height, float frequency) {
switch (noise) {
case NoiseType.White:
return new WhiteNoise(width, height).NoiseMap;
case NoiseType.Perlin:
return new PerlinNoise(width, height).NoiseMap;
case NoiseType.Simple:
return new SimpleNoise(width, height).NoiseMap;
}
return null;
}
void OnGUI()
{
var dirty = false;
var noiseType = (NoiseType)EditorGUILayout.EnumPopup("Noise", _noiseType);
if (_noiseType != noiseType)
{
_noiseType = noiseType;
dirty = true;
}
dirty |= UpdateValueFloat("Frequency", ref _frequency);
dirty |= UpdateValueFloat("Lancuraity", ref _lancuraity);
dirty |= UpdateValueFloat("Persistence", ref _persistence);
dirty |= UpdateValueFloat("Size", ref _size);
dirty |= UpdateValueInt("Octaves", ref _octaves);
dirty |= UpdateValueInt("Resolution", ref _res);
dirty |= UpdateValueBool("Seamless", ref _seamless);
dirty |= UpdateValueBool("Normal Map", ref _normalMap);
_zCurve = EditorGUILayout.CurveField("zCurve", _zCurve);
if (dirty)
{
GeneratePreview();
}
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal();
GUI.DrawTexture(GUILayoutUtility.GetRect(128, 128), _previewTexture, ScaleMode.ScaleToFit, false);
GUI.DrawTexture(GUILayoutUtility.GetRect(128, 128), _previewTexture, ScaleMode.ScaleToFit, false);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUI.DrawTexture(GUILayoutUtility.GetRect(128, 128), _previewTexture, ScaleMode.ScaleToFit, false);
GUI.DrawTexture(GUILayoutUtility.GetRect(128, 128), _previewTexture, ScaleMode.ScaleToFit, false);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
if (_normalMap)
{
GUILayout.BeginHorizontal();
GUI.DrawTexture(GUILayoutUtility.GetRect(128, 128), _previewTextureNM, ScaleMode.ScaleToFit, false);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
GUILayout.FlexibleSpace();
if (GUILayout.Button("Create", GUILayout.Width(100)))
{
GenerateTexture();
}
}
public static float[,] GenerateNoiseMap(NoiseType noiseType, int mapWidth, int mapHeight, int seed, float scale, int octaves, float persistance, float lacunarity, Vector2 offset, AnimationCurve noiseFactorCurve = null)
{
switch (noiseType)
{
case NoiseType.Vasarely:
return(GenerateVasarelyNoiseMap(mapWidth, mapHeight, seed, scale, octaves, persistance, lacunarity, offset, noiseFactorCurve));
default:
return(GenerateTerrainNoiseMap(mapWidth, mapHeight, seed, scale, octaves, persistance, lacunarity, offset));
}
}
public NoiseForTrigger toNoise(NoiseType nt, float rangeLeft, float distanceFromSource)
{
NoiseForTrigger newNoise = new NoiseForTrigger();
newNoise.noiseType = nt;
newNoise.NoiseOrigin = gameObject;
newNoise.originPosition = transform;
newNoise.distanceFromSource = distanceFromSource;
newNoise.rangeLeft = rangeLeft;
return(newNoise);
}
public static int GetNoise1D(Vector3 point, NoiseOptions options, NoiseType method)
{
return(Mathf.FloorToInt(
(NoiseGenerator.Sum(
NoiseGenerator.noiseMethods[(int)method][0],
new Vector3(point.x, 0, 0),
options.frequency.value,
options.octaves,
options.lacunarity,
options.persistance) + 1f).value * (options.scale / 2f)));
}
public void UpdateData(CameraShakeData data)
{
if (data != null)
{
mShakeType = data.mShakeType;
mNoiseType = data.mNoiseType;
MoveExtents = data.MoveExtents;
RotateExtents = data.RotateExtents;
Speed = data.Speed;
Duration = data.Duration;
}
}
/// <summary>
/// Creates a new Noise.
/// </summary>
/// <param name="source">Source of the noise. Taken as the origin of the noise.</param>
/// <param name="intensity">Intensity of the sound. Diameter in which the sound will be diffused.</param>
/// <param name="floor">Floor of the sound emited</param>
/// <param name="emiter">Emiter type</param>
/// <param name="duration">Duration of the sound. The noise will be destroyed when the duration hits 0. Precision of .1</param>
public Noise(SoundEmiter source, float intensity, int floor, NoiseType emiter, float duration)
{
_source = source;
_intensity = intensity;
_floor = floor;
_emiter = emiter;
_duration = duration;
if (duration != _oneFrame)
{
source.StartCoroutine(UpdateDuration());
}
}
public static CustomRenderTexture GenerateNoiseRT(NoiseType type, float scale, int width, int height, int depth = 128)
{
CustomRenderTexture noiseRT = new CustomRenderTexture(width, height);
noiseRT.format = RenderTextureFormat.ARGB32;
noiseRT.wrapMode = TextureWrapMode.Repeat;
noiseRT.filterMode = FilterMode.Bilinear;
noiseRT.updateMode = CustomRenderTextureUpdateMode.Realtime;
noiseRT.initializationMode = CustomRenderTextureUpdateMode.Realtime;
noiseRT.initializationSource = CustomRenderTextureInitializationSource.Material;
noiseRT.enableRandomWrite = true;
switch (type)
{
case NoiseType.PerilinNoise2D:
noiseRT.dimension = UnityEngine.Rendering.TextureDimension.Tex2D;
noiseRT.material = m_perlin2D;
noiseRT.initializationMaterial = m_perlin2D;
noiseRT.shaderPass = 0;
noiseRT.material.SetFloat("_Scale", scale);
break;
case NoiseType.PerilinNoise2D_Tileable:
noiseRT.dimension = UnityEngine.Rendering.TextureDimension.Tex2D;
noiseRT.material = m_perlin2D_Tile;
noiseRT.initializationMaterial = m_perlin2D_Tile;
noiseRT.shaderPass = 0;
noiseRT.material.SetFloat("_Scale", scale);
break;
case NoiseType.PerilinNoise3D:
noiseRT.dimension = UnityEngine.Rendering.TextureDimension.Tex3D;
noiseRT.volumeDepth = depth;
noiseRT.material = m_perlin3D;
noiseRT.initializationMaterial = m_perlin3D;
noiseRT.shaderPass = 0;
noiseRT.material.SetFloat("_Scale", scale);
break;
case NoiseType.PerilinNoise3D_ZLoop:
noiseRT.dimension = UnityEngine.Rendering.TextureDimension.Tex3D;
noiseRT.volumeDepth = depth;
noiseRT.material = m_perlin3D_ZLoop;
noiseRT.initializationMaterial = m_perlin3D_ZLoop;
noiseRT.shaderPass = 0;
noiseRT.material.SetFloat("_Scale", scale);
break;
}
noiseRT.Initialize();
noiseRT.Update();
noiseRT.Create();
return(noiseRT);
}
private INoise1D CreateNoise(NoiseType type){
switch(type){
case NoiseType.None:
return new NoneNoise1D();
case NoiseType.Value1D:
return new ValueNoise1D();
case NoiseType.Perlin1D:
return new PerlinNoise1D();
case NoiseType.Factal1D:
return new FractalNoise1D(new PerlinNoise1D(),new PerlinNoise1D());
}
return null;
}
public void GetDefault()
{
type = NoiseType.Perlin;
enabled = true;
frequency = 1.1;
lacunarity = 2.2;
persistence = 0.6;
octaves = 7;
qualityMode = QualityMode.Low;
displacement = 1;
distance = true;
blendMode = BlendMode.Add;
}
public NoiseFunction()
{
type = NoiseType.None;
enabled = true;
frequency = 1;
lacunarity = 2.2;
persistence = 0.5;
octaves = 1;
qualityMode = QualityMode.Low;
displacement = 1;
distance = true;
blendMode = BlendMode.Add;
}
public NoiseConfiguration(string title, NoiseType type, int seed, ObservableCollection <NoiseColorRange> colors, float zoom)
{
Title = title;
Type = (int)type;
Seed = seed;
Colors = colors ?? new ObservableCollection <NoiseColorRange>();
Zoom = zoom;
if (Zoom == 0)
{
Zoom = 10000;
}
}
public void Start()
{
seed = UnityEngine.Random.Range(0, 100);
if (randomNoiseType == true)
{
noise = (NoiseType)UnityEngine.Random.Range(0, 6);
}
Generate();
// Debug.Log("Noise Type: " + noise);
}
public static float[,] AddNoise(float[,] data, NoiseType noiseType, double f = 0.1, int rndSize = 5)
{
if (noiseType == NoiseType.none)
{
return(data);
}
int w = data.GetLength(0);
int h = data.GetLength(1);
var newData = new float[w, h];
Random rnd = new Random();
double min = Double.PositiveInfinity;
double max = Double.NegativeInfinity;
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
min = Math.Min(min, data[i, j]);
max = Math.Max(max, data[i, j]);
}
}
float swipe = (float)(max - min);
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
float val = data[i, j];
if (rnd.NextDouble() <= f)
{
switch (noiseType)
{
case NoiseType.rnd:
val += rnd.Next(-1, 2) * rnd.Next(1, rndSize) / 10 * swipe;
break;
case NoiseType.sp:
val = (float)rnd.NextDouble() / 10 * swipe;
break;
}
}
newData[i, j] = val;
}
}
return(newData);
}
public void OnGUI ()
{
int y = 0;
foreach (string i in System.Enum.GetNames(typeof(NoiseType))) {
if (GUI.Button (new Rect (0, y, 100, 20), i)) {
noise = (NoiseType)Enum.Parse (typeof(NoiseType), i);
Generate ();
}
y += 20;
}
frequency = double.Parse (GUI.TextField (new Rect (0, 120, 100, 20), frequency.ToString ()));
displacement = double.Parse (GUI.TextField (new Rect (0, 140, 100, 20), displacement.ToString ()));
resolution = int.Parse (GUI.TextField (new Rect (0, 160, 100, 20), resolution.ToString ()));
perlinOctaves = int.Parse (GUI.TextField (new Rect (0, 180, 100, 20), perlinOctaves.ToString ()));
turbulence = float.Parse (GUI.TextField (new Rect (0, 200, 100, 20), turbulence.ToString ()));
zoom = float.Parse (GUI.TextField (new Rect (0, 220, 100, 20), zoom.ToString ()));
}
public void OnGUI()
{
int y = 0;
foreach ( string i in System.Enum.GetNames(typeof(NoiseType)) ) {
if (GUI.Button(new Rect(0,y,100,20), i) ) {
noise = (NoiseType) Enum.Parse(typeof(NoiseType), i);
Generate();
}
y+=20;
}
}
public Noise(NoiseType _type)
{
type = _type;
}
public static System.Func<int, int, int, uint> GenerateHeight(int cx, int cy, int cz, int width, int depth, NoiseType noise = NoiseType.Perlin, int sealevel = 8)
{
//IModule3D moduleBase;
//switch (noise)
//{
// case NoiseType.Billow:
// moduleBase = new Billow();
// break;
// case NoiseType.RidgedMultiFractal:
// moduleBase = new RidgedMultiFractal();
// break;
// case NoiseType.Voronoi:
// moduleBase = new Voronoi();
// break;
// case NoiseType.Mix:
// SimplexPerlin perlin = new SimplexPerlin();
// RidgedMultiFractal rigged = new RidgedMultiFractal();
// moduleBase = new Add(perlin, rigged);
// break;
// default:
// moduleBase = new SimplexPerlin();
// break;
//}
var data = new uint[width, depth];
//for (var x = 0; x < width; ++x)
//{
// for (var z = 0; z < depth; ++z)
// {
// var wx = cx * width + x;
// var wz = cz * depth + z;
// data[x, z] = (uint)(moduleBase.GetValue(wx * 0.035f, wz * 0.035f, 0.95f) * 2 + 8);
// data[x, z] += (uint)(moduleBase.GetValue(wx * 0.015f, wz * 0.015f, 0.15f) * moduleBase.GetValue(wx * 0.025f, wz * 0.025f, 0.45f) * 7 + 2);
// }
//}
var random = new Random(1234);
return (i, j, k) =>
{
if (data[i, k] > j)
{
if (sealevel > j)
return 0xD6D68Eu;
var terrainNoise = random.NextDouble();
if (terrainNoise < 0.005f)
return 0x88A552u;
else if (terrainNoise < 0.01f)
return 0x9CCB6Bu;
return 0x5F9E35u;
}
else if (sealevel > j)
return 0x177B0E5u;
return 0;
};
}
private void init(NoiseType type, ushort numChannels, int lengthSamples, uint sampleRate, double gain, bool mono)
{
_type = type;
_lengthSamples = lengthSamples;
NumChannels = numChannels;
SampleRate = sampleRate;
_gain = gain;
_mono = mono;
if (_gain == 0) _gain = 1;
_random = new Random();
}
public NoiseGenerator(NoiseType type, ushort numChannels, double lengthSecs, uint sampleRate, double gain, bool mono)
{
init(type, numChannels, (int)(sampleRate * lengthSecs), sampleRate, gain, mono);
}
public NoiseGenerator(NoiseType type, ushort numChannels, int lengthSamples, uint sampleRate, double gain, bool mono)
{
init(type, numChannels, lengthSamples, sampleRate, gain, mono);
}
public void AddNoise(NoiseType noiseType, double attenuate, Channels channels)
{
IntPtr exception = IntPtr.Zero;
IntPtr result;
#if ANYCPU
if (NativeLibrary.Is64Bit)
#endif
#if WIN64 || ANYCPU
result = NativeMethods.X64.MagickImage_AddNoise(Instance, (UIntPtr)noiseType, attenuate, (UIntPtr)channels, out exception);
#endif
#if ANYCPU
else
#endif
#if !WIN64 || ANYCPU
result = NativeMethods.X86.MagickImage_AddNoise(Instance, (UIntPtr)noiseType, attenuate, (UIntPtr)channels, out exception);
#endif
CheckException(exception, result);
Instance = result;
}
public static Bitmap CreateNoise(NoiseType noise) {
return CreateNoise(noise, 600, 600);
}
public static Bitmap CreateNoise(NoiseType noise, int width, int height) {
return CreateNoise(noise, width, height, 1f);
}
private static INoiseModule GetNoiseType(NoiseType Type, int seed)
{
switch (Type)
{
case NoiseType.Custom:
//Feel free to test new modules here
///If you merge them into the repository
///please add the algorithm to the <see cref="NoiseType"/> enum
return null;
default:
///Get type module by calling the corresponding method
///in <see cref="NoiseModules"> using reflection
string ModuleName = Enum.GetName(typeof(NoiseType), Type);
MethodInfo TargetMethod = typeof(NoiseModules).GetMethod("Get" + ModuleName + "Module", new Type[]{typeof(int)});
return (INoiseModule)TargetMethod.Invoke(null, new object[]{seed});
}
}
