/// <summary> /// Generates a gradient-coherent-noise value from the coordinates of a /// three-dimensional input value. /// </summary> /// <remarks> /// <para> /// The return value ranges from -1.0 to +1.0. /// </para> /// <para> /// For an explanation of the difference between gradient noise and /// value noise, see the comments for the <see cref="GradientNoise3D" /> function. /// </para> /// </remarks> /// <param name="x">The x coordinate of the input value.</param> /// <param name="y">The y coordinate of the input value.</param> /// <param name="z">The z coordinate of the input value.</param> /// <param name="seed">The random number seed.</param> /// <param name="noiseQuality">The quality of the coherent-noise.</param> /// <returns>The generated gradient-coherent-noise value.</returns> public static double GradientCoherentNoise1D(double x, int seed = 0, NoiseQuality noiseQuality = NoiseQuality.Standard) { // Create a unit-length cube aligned along an integer boundary. This cube // surrounds the input point. int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; // Map the difference between the coordinates of the input value and the // coordinates of the cube's outer-lower-left vertex onto an S-curve. double xs = 0, ys = 0; switch (noiseQuality) { case NoiseQuality.Fast: xs = (x - x0); break; case NoiseQuality.Standard: xs = Interp.SCurve3(x - x0); break; case NoiseQuality.Best: xs = Interp.SCurve5(x - x0); break; } // Now calculate the noise values at each vertex of the cube. To generate // the coherent-noise value at the input point, interpolate these eight // noise values using the S-curve value as the interpolant (trilinear // interpolation.) double n0 = GradientNoise1D(x, x0, seed); double n1 = GradientNoise1D(x, x1, seed); return(Interp.LinearInterp(n0, n1, xs)); }
} //end GetValue #endregion #region ValueNoise1D /// <summary> /// Generates a value-coherent-noise value from the coordinates of a /// one-dimensional input value. /// /// The return value ranges from -1.0 to +1.0. /// /// </summary> /// <param name="x">The x coordinate of the input value</param> /// <param name="seed">The random number seed</param> /// <param name="quality">The quality of the coherent-noise</param> /// <returns>The generated value-coherent-noise value</returns> public static float ValueCoherentNoise1D(float x, long seed, NoiseQuality quality) { // Create a unit-length line aligned along an integer boundary. // This line surrounds the input point. int x0 = (x > 0.0 ? (int)x: (int)x - 1); int x1 = x0 + 1; float xs = 0; switch (quality) { case NoiseQuality.Fast: xs = (x - (float)x0); break; case NoiseQuality.Standard: xs = Libnoise.SCurve3(x - (float)x0); break; case NoiseQuality.Best: xs = Libnoise.SCurve5(x - (float)x0); break; } //end switch // Now calculate the noise values at each point of the line. To generate // the coherent-noise value at the input point, interpolate these two // noise values using the S-curve value as the interpolant (trilinear // interpolation.) float n0, n1; n0 = ValueNoise1D(x0, seed); n1 = ValueNoise1D(x1, seed); return(Libnoise.Lerp(n0, n1, xs)); } //end ValueCoherentNoise1D
public double Noise1D(double x, NoiseQuality quality) { //returns a noise value between -0.5 and 0.5 int ix0, ix1; double fx0, fx1; double s, n0, n1; ix0 = NoiseHelper.FastFloor(x); // Fractional part of x & y if (quality == NoiseQuality.Low) { fx0 = x - ix0; } else if (quality == NoiseQuality.Standard) { fx0 = MathEx.SCurve3(x - ix0); } else { fx0 = MathEx.SCurve5(x - ix0); } fx1 = fx0 - 1.0f; ix1 = (ix0 + 1) & 0xff; ix0 = ix0 & 0xff; // Wrap to 0..255 s = FADE(fx0); n0 = GRAD1(m_perm[ix0], fx0); n1 = GRAD1(m_perm[ix1], fx1); return(0.188f * LERP(s, n0, n1)); }
protected bool GetNoiseQualityInput(IGH_DataAccess DA, ref NoiseQuality noiseQuality) { int q = 0; if (!DA.GetData(1, ref q)) { return(false); } switch (q) { case 0: noiseQuality = NoiseQuality.Standard; break; case 1: noiseQuality = NoiseQuality.Fast; break; case 2: noiseQuality = NoiseQuality.Best; break; default: noiseQuality = NoiseQuality.Standard; AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Quality must be between 0 and 2."); break; } return(true); }
public float getValue(Vector3 cubeWorldPosition) { this.frequency = 0.5f; this.lacunarity = 2; this.offset = 1; this.gain = 2; this.exponent = 1f; this.octaveCount = 4f; this.gradient = GradientColors.Grayscale; this.quality = PrimitiveModule.DefaultQuality; this.primitive = NoisePrimitive.ImprovedPerlin; this.filter = NoiseFilter.MultiFractal; this.pModule = new ImprovedPerlin(); this.pModule.Quality = quality; this.pModule.Seed = seed; this.fModule = new MultiFractal(); this.scale = new ScaleBias(fModule, 1f, -0.8f); this.fModule.Frequency = frequency; this.fModule.Lacunarity = lacunarity; this.fModule.OctaveCount = octaveCount; this.fModule.Offset = offset; this.fModule.Gain = gain; this.fModule.Primitive3D = (IModule3D)pModule; this.finalModule = scale; return(this.finalModule.GetValue(cubeWorldPosition.X, cubeWorldPosition.Y, cubeWorldPosition.Z)); }
/// <summary> /// Create a new ImprovedPerlin with given values /// </summary> /// <param name="seed"></param> /// <param name="quality"></param> public SimplexPerlin(int seed, NoiseQuality quality) : base(seed, quality) { this._perm = new int[1024]; this._perm2D = new int[1024]; this._perm2DSph2 = new int[1024]; this._perm3D = new int[1024]; int[] source = new int[1024]; for (int i = 0; i < 1024; i++) { source[i] = i; } for (int i = 1023; i >= 0; i--) { seed = (int)((seed * 6364136223846793005L + 1442695040888963407L) % int.MaxValue); int r = (int)((seed + 31) % (i + 1)); if (r < 0) { r += (i + 1); } _perm[i] = source[r]; _perm2D[i] = _perm[i] % 12 * 2; _perm2DSph2[i] = _perm[i] / 12 % 12 * 2; _perm3D[i] = _perm[i] % 48 * 3; source[r] = source[i]; } }
public static float ValueCoherentNoise1D(float x, long seed, NoiseQuality quality) { int num = (!((double)x > 0.0)) ? ((int)x - 1) : ((int)x); int x2 = num + 1; float a = 0f; switch (quality) { case NoiseQuality.Fast: a = x - (float)num; break; case NoiseQuality.Standard: a = Libnoise.SCurve3(x - (float)num); break; case NoiseQuality.Best: a = Libnoise.SCurve5(x - (float)num); break; } float n = ValueNoise1D(num, seed); float n2 = ValueNoise1D(x2, seed); return(Libnoise.Lerp(n, n2, a)); }
} //end ImprovedPerlin /// <summary> /// Create a new ImprovedPerlin with given values /// </summary> /// <param name="seed"></param> /// <param name="quality"></param> public ImprovedPerlin(int seed, NoiseQuality quality) { _seed = seed; _quality = quality; Randomize(_seed); } //end ImprovedPerlin
/// Generates a gradient-coherent-noise value from the coordinates of a /// three-dimensional input value. /// /// @param x The @a x coordinate of the input value. /// @param y The @a y coordinate of the input value. /// @param z The @a z coordinate of the input value. /// @param seed The random number seed. /// @param noiseQuality The quality of the coherent-noise. /// /// @returns The generated gradient-coherent-noise value. /// /// The return value ranges from -1.0 to +1.0. /// /// For an explanation of the difference between <i>gradient</i> noise and /// <i>value</i> noise, see the comments for the GradientNoise3D() function. public static double GradientCoherentNoise3D(double x, double y, double z, int seed = 0, NoiseQuality noiseQuality = NoiseQuality.QUALITY_STD) { // Create a unit-length cube aligned along an integer boundary. This cube // surrounds the input point. int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; int z0 = (z > 0.0 ? (int)z : (int)z - 1); int z1 = z0 + 1; // Map the difference between the coordinates of the input value and the // coordinates of the cube's outer-lower-left vertex onto an S-curve. double xs = 0, ys = 0, zs = 0; switch (noiseQuality) { case NoiseQuality.QUALITY_FAST: xs = (x - (double)x0); ys = (y - (double)y0); zs = (z - (double)z0); break; case NoiseQuality.QUALITY_STD: xs = Interp.SCurve3(x - (double)x0); ys = Interp.SCurve3(y - (double)y0); zs = Interp.SCurve3(z - (double)z0); break; case NoiseQuality.QUALITY_BEST: xs = Interp.SCurve5(x - (double)x0); ys = Interp.SCurve5(y - (double)y0); zs = Interp.SCurve5(z - (double)z0); break; } // Now calculate the noise values at each vertex of the cube. To generate // the coherent-noise value at the input point, interpolate these eight // noise values using the S-curve value as the interpolant (trilinear // interpolation.) double n0, n1, ix0, ix1, iy0, iy1; n0 = GradientNoise3D(x, y, z, x0, y0, z0, seed); n1 = GradientNoise3D(x, y, z, x1, y0, z0, seed); ix0 = Interp.LinearInterp(n0, n1, xs); n0 = GradientNoise3D(x, y, z, x0, y1, z0, seed); n1 = GradientNoise3D(x, y, z, x1, y1, z0, seed); ix1 = Interp.LinearInterp(n0, n1, xs); iy0 = Interp.LinearInterp(ix0, ix1, ys); n0 = GradientNoise3D(x, y, z, x0, y0, z1, seed); n1 = GradientNoise3D(x, y, z, x1, y0, z1, seed); ix0 = Interp.LinearInterp(n0, n1, xs); n0 = GradientNoise3D(x, y, z, x0, y1, z1, seed); n1 = GradientNoise3D(x, y, z, x1, y1, z1, seed); ix1 = Interp.LinearInterp(n0, n1, xs); iy1 = Interp.LinearInterp(ix0, ix1, ys); return(Interp.LinearInterp(iy0, iy1, zs)); }
public FastRidgedMultifractal(int seed) : base(seed) { Frequency = 1.0; Lacunarity = 2.0; OctaveCount = 6; NoiseQuality = NoiseQuality.Standard; }
public HybridMultiFractal3DPrimitive(double frequency, double scale, int seed, NoiseQuality quality) { this.frequency = frequency; this.scale = scale; noise = new HybridMultiFractal { Primitive3D = new SimplexPerlin(seed, quality) }; }
public FastRidgedMultifractal(int seed) : base(seed) { Frequency = 1.0; Lacunarity = 2.0; OctaveCount = 6; NoiseQuality = NoiseQuality.Standard; }
public RidgedMultifractal() { Frequency = 1.0f; Lacunarity = 2.0f; OctaveCount = 6; NoiseQuality = NoiseQuality.Standard; Seed = 0; }
public RidgedMulti(double frequency, double lacunaruity, int octaves, NoiseQuality quality, int seed) { Frequency = frequency; OctaveCount = octaves; Quality = quality; Seed = seed; Lacunaruty = lacunaruity; }
public Perlin() { Frequency = DefaultPerlinFrequency; OctaveCount = DefaultPerlinOctaveCount; Persistence = DefaultPerlinPersistence; Lacunarity = DefaultPerlinLacunarity; Quality = DefaultPerlinQuality; Seed = DefaultPerlinSeed; }
public Billow() : base(4) { // Frequency = 1.0; // Lacunarity = 2.0; // mOctaveCount = 6; // Persistence = 0.5; NoiseQuality = NoiseQuality.Standard; Seed = 0; }
public override void OnEditorGUI(UltimateTerrain uTerrain, IReadOnlyFlowGraph graph) { #if UNITY_EDITOR frequency = EditorGUILayout.FloatField("Frequency:", frequency); scale = EditorGUILayout.FloatField("Scale:", scale); seed = EditorGUILayout.IntField("Seed:", seed); quality = (NoiseQuality)EditorGUILayout.EnumPopup("Quality:", quality); #endif }
public RidgedMultifractal() : base(5) { //Frequency = 1.0; //Lacunarity = 2.0; // OctaveCount = 6; // Gain = 2; NoiseQuality = NoiseQuality.Standard; Seed = 0; }
public Perlin(double frequency, double lacunarity, NoiseQuality quality, uint octaveCount, double persistence, int seed) { Frequency = frequency; Lacunarity = lacunarity; Quality = quality; OctaveCount = octaveCount; Persistence = persistence; Seed = seed; }
public static double GradientCoherentNoise(double x, double y, double z, int seed, NoiseQuality noiseQuality) { int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; int z0 = (z > 0.0 ? (int)z : (int)z - 1); int z1 = z0 + 1; double xs = 0, ys = 0, zs = 0; switch (noiseQuality) { case NoiseQuality.Low: xs = (x - x0); ys = (y - y0); zs = (z - z0); break; case NoiseQuality.Standard: xs = Loonim.Math.SCurve3(x - x0); ys = Loonim.Math.SCurve3(y - y0); zs = Loonim.Math.SCurve3(z - z0); break; case NoiseQuality.High: xs = Loonim.Math.SCurve5(x - x0); ys = Loonim.Math.SCurve5(y - y0); zs = Loonim.Math.SCurve5(z - z0); break; } // Now calculate the noise values at each vertex of the cube. To generate // the coherent-noise value at the input point, interpolate these eight // noise values using the S-curve value as the interpolant (trilinear // interpolation.) double n0, n1, ix0, ix1, iy0, iy1; n0 = Gradient(x, y, z, x0, y0, z0, seed); n1 = Gradient(x, y, z, x1, y0, z0, seed); ix0 = Loonim.Math.LinearInterpolate(n0, n1, xs); n0 = Gradient(x, y, z, x0, y1, z0, seed); n1 = Gradient(x, y, z, x1, y1, z0, seed); ix1 = Loonim.Math.LinearInterpolate(n0, n1, xs); iy0 = Loonim.Math.LinearInterpolate(ix0, ix1, ys); n0 = Gradient(x, y, z, x0, y0, z1, seed); n1 = Gradient(x, y, z, x1, y0, z1, seed); ix0 = Loonim.Math.LinearInterpolate(n0, n1, xs); n0 = Gradient(x, y, z, x0, y1, z1, seed); n1 = Gradient(x, y, z, x1, y1, z1, seed); ix1 = Loonim.Math.LinearInterpolate(n0, n1, xs); iy1 = Loonim.Math.LinearInterpolate(ix0, ix1, ys); return(Loonim.Math.LinearInterpolate(iy0, iy1, zs)); }
public ExDistPerlin(Double frequency, Double lacunarity, Double persistence, Double mu, Int32 octaves, Int32 seed, NoiseQuality quality) { Frequency = frequency; Lacunarity = lacunarity; Persistence = persistence; Mu = mu; OctaveCount = octaves; Seed = seed; Quality = quality; }
public override void OnEditorGUI(UltimateTerrain uTerrain, IReadOnlyFlowGraph graph) { #if UNITY_EDITOR Frequency = EditorGUILayout.FloatField("Frequency:", Frequency); Scale = EditorGUILayout.FloatField("Scale:", Scale); offset = EditorGUILayout.Vector3Field("Offset:", offset); Seed = EditorGUILayout.IntField("Seed:", Seed); Quality = (NoiseQuality)EditorGUILayout.EnumPopup("Quality:", Quality); #endif }
public static double GradientCoherentNoise3D(double x, double y, double z, int seed, NoiseQuality noiseQuality) { // Create a unit-length cube aligned along an integer boundary. This cube // surrounds the input point. int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; int z0 = (z > 0.0 ? (int)z : (int)z - 1); int z1 = z0 + 1; // Map the difference between the coordinates of the input value and the // coordinates of the cube's outer-lower-left vertex onto an S-curve. double xs = 0, ys = 0, zs = 0; switch (noiseQuality) { case NoiseQuality.Fast: xs = (x - (double)x0); ys = (y - (double)y0); zs = (z - (double)z0); break; case NoiseQuality.Standard: xs = Interpolation.SCurve3(x - (double)x0); ys = Interpolation.SCurve3(y - (double)y0); zs = Interpolation.SCurve3(z - (double)z0); break; case NoiseQuality.Best: xs = Interpolation.SCurve5(x - (double)x0); ys = Interpolation.SCurve5(y - (double)y0); zs = Interpolation.SCurve5(z - (double)z0); break; } // Now calculate the noise values at each vertex of the cube. To generate // the coherent-noise value at the input point, interpolate these eight // noise values using the S-curve value as the interpolant (trilinear // interpolation.) double n0, n1, ix0, ix1, iy0, iy1; n0 = GradientNoise3D(x, y, z, x0, y0, z0, seed); n1 = GradientNoise3D(x, y, z, x1, y0, z0, seed); ix0 = Interpolation.LinearInterpolate(n0, n1, xs); n0 = GradientNoise3D(x, y, z, x0, y1, z0, seed); n1 = GradientNoise3D(x, y, z, x1, y1, z0, seed); ix1 = Interpolation.LinearInterpolate(n0, n1, xs); iy0 = Interpolation.LinearInterpolate(ix0, ix1, ys); n0 = GradientNoise3D(x, y, z, x0, y0, z1, seed); n1 = GradientNoise3D(x, y, z, x1, y0, z1, seed); ix0 = Interpolation.LinearInterpolate(n0, n1, xs); n0 = GradientNoise3D(x, y, z, x0, y1, z1, seed); n1 = GradientNoise3D(x, y, z, x1, y1, z1, seed); ix1 = Interpolation.LinearInterpolate(n0, n1, xs); iy1 = Interpolation.LinearInterpolate(ix0, ix1, ys); return Interpolation.LinearInterpolate(iy0, iy1, zs); }
/// <summary> /// Code original : libnoise. /// Portage vers C# par l'équipe du projet. /// </summary> public float ValueCoherentNoise3D(float x, float y, float z, int seed, NoiseQuality noiseQuality) { // Create a unit-length cube aligned along an integer boundary. This cube // surrounds the input point. int x0 = (x > (float)0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > (float)0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; int z0 = (z > (float)0.0 ? (int)z : (int)z - 1); int z1 = z0 + 1; // Map the difference between the coordinates of the input value and the // coordinates of the cube's outer-lower-left vertex onto an S-curve. float xs = 0, ys = 0, zs = 0; switch (noiseQuality) { case NoiseQuality.QUALITY_FAST: xs = (x - (float)x0); ys = (y - (float)y0); zs = (z - (float)z0); break; case NoiseQuality.QUALITY_STD: xs = SCurve3(x - (float)x0); ys = SCurve3(y - (float)y0); zs = SCurve3(z - (float)z0); break; case NoiseQuality.QUALITY_BEST: xs = SCurve5(x - (float)x0); ys = SCurve5(y - (float)y0); zs = SCurve5(z - (float)z0); break; } // Now calculate the noise values at each vertex of the cube. To generate // the coherent-noise value at the input point, interpolate these eight // noise values using the S-curve value as the interpolant (trilinear // interpolation.) float n0, n1, ix0, ix1, iy0, iy1; n0 = ValueNoise3D(x0, y0, z0, seed); n1 = ValueNoise3D(x1, y0, z0, seed); ix0 = LinearInterp(n0, n1, xs); n0 = ValueNoise3D(x0, y1, z0, seed); n1 = ValueNoise3D(x1, y1, z0, seed); ix1 = LinearInterp(n0, n1, xs); iy0 = LinearInterp(ix0, ix1, ys); n0 = ValueNoise3D(x0, y0, z1, seed); n1 = ValueNoise3D(x1, y0, z1, seed); ix0 = LinearInterp(n0, n1, xs); n0 = ValueNoise3D(x0, y1, z1, seed); n1 = ValueNoise3D(x1, y1, z1, seed); ix1 = LinearInterp(n0, n1, xs); iy1 = LinearInterp(ix0, ix1, ys); return LinearInterp(iy0, iy1, zs); }
public PerlinConfig(float lacunarity, float frequency, float persistance, int octaves, NoiseQuality quality, NoiseConfig cfg ) : base(cfg) { Lacunarity = lacunarity; Frequency = frequency; Persistance = persistance; Octaves = octaves; Quality = quality; }
public double ValueCoherentNoise3D(double x, double y, double z, int seed, NoiseQuality noiseQuality) { //Create unit-length cube aligned along an integer boundary int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; int z0 = (z > 0.0 ? (int)z : (int)z - 1); int z1 = z0 + 1; //Map the difference between the coordinates of input value double xs = 0, ys = 0, zs = 0; switch (noiseQuality) { case NoiseQuality.Fast: xs = (x - (double)x0); ys = (y - (double)y0); zs = (z - (double)z0); break; case NoiseQuality.Standard: xs = MathUtils.SCurve3(x - (double)x0); ys = MathUtils.SCurve3(y - (double)y0); zs = MathUtils.SCurve3(z - (double)z0); break; case NoiseQuality.Best: xs = MathUtils.SCurve5(x - (double)x0); ys = MathUtils.SCurve5(y - (double)y0); zs = MathUtils.SCurve5(z - (double)z0); break; } //Now calculate noise values at each vertex of the cube. double n0, n1, ix0, ix1, iy0, iy1; n0 = ValueNoise3D(x0, y0, z0, seed); n1 = ValueNoise3D(x1, y0, z0, seed); ix0 = MathUtils.LinearInterp(n0, n1, xs); n0 = ValueNoise3D(x0, y1, z0, seed); n1 = ValueNoise3D(x1, y1, z0, seed); ix1 = MathUtils.LinearInterp(n0, n1, xs); iy0 = MathUtils.LinearInterp(ix0, ix1, ys); n0 = ValueNoise3D(x0, y0, z1, seed); n1 = ValueNoise3D(x1, y0, z1, seed); ix0 = MathUtils.LinearInterp(n0, n1, xs); n0 = ValueNoise3D(x0, y1, z1, seed); n1 = ValueNoise3D(x1, y1, z1, seed); ix1 = MathUtils.LinearInterp(n0, n1, xs); iy1 = MathUtils.LinearInterp(ix0, ix1, ys); return(MathUtils.LinearInterp(iy0, iy1, zs)); }
public double GradientCoherentNoise(double x, double y, double z, int seed, NoiseQuality noiseQuality) { int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; int z0 = (z > 0.0 ? (int)z : (int)z - 1); int z1 = z0 + 1; double xs = 0, ys = 0, zs = 0; switch (noiseQuality) { case NoiseQuality.Low: xs = (x - x0); ys = (y - y0); zs = (z - z0); break; case NoiseQuality.Standard: xs = SCurve3(x - x0); ys = SCurve3(y - y0); zs = SCurve3(z - z0); break; case NoiseQuality.High: xs = SCurve5(x - x0); ys = SCurve5(y - y0); zs = SCurve5(z - z0); break; } double n0, n1, ix0, ix1, iy0, iy1; n0 = GradientNoise(x, y, z, x0, y0, z0, seed); n1 = GradientNoise(x, y, z, x1, y0, z0, seed); ix0 = LinearInterpolate(n0, n1, xs); n0 = GradientNoise(x, y, z, x0, y1, z0, seed); n1 = GradientNoise(x, y, z, x1, y1, z0, seed); ix1 = LinearInterpolate(n0, n1, xs); iy0 = LinearInterpolate(ix0, ix1, ys); n0 = GradientNoise(x, y, z, x0, y0, z1, seed); n1 = GradientNoise(x, y, z, x1, y0, z1, seed); ix0 = LinearInterpolate(n0, n1, xs); n0 = GradientNoise(x, y, z, x0, y1, z1, seed); n1 = GradientNoise(x, y, z, x1, y1, z1, seed); ix1 = LinearInterpolate(n0, n1, xs); iy1 = LinearInterpolate(ix0, ix1, ys); return(LinearInterpolate(iy0, iy1, zs)); }
public Perlin(double frequency, double lacunarity, NoiseQuality noiseQuality, int octaveCount, double persistence, int seed) { if(octaveCount < 1 || octaveCount > PerlinMaxOctave) { throw new ArgumentException("Count was too high, above " + PerlinMaxOctave, "octaveCount"); } Seed = seed; Persistence = persistence; OctaveCount = octaveCount; NoiseQuality = noiseQuality; Lacunarity = lacunarity; Frequency = frequency; }
public Perlin(double frequency, double lacunarity, NoiseQuality noiseQuality, int octaveCount, double persistence, int seed) { if (octaveCount < 1 || octaveCount > PerlinMaxOctave) { throw new ArgumentException("Count was too high, above " + PerlinMaxOctave, "octaveCount"); } Seed = seed; Persistence = persistence; OctaveCount = octaveCount; NoiseQuality = noiseQuality; Lacunarity = lacunarity; Frequency = frequency; }
public float GradientCoherentNoise3D(float x, float y, float z, long seed, NoiseQuality quality) { int num = (!((double)x > 0.0)) ? ((int)x - 1) : ((int)x); int ix = num + 1; int num2 = (!((double)y > 0.0)) ? ((int)y - 1) : ((int)y); int iy = num2 + 1; int num3 = (!((double)z > 0.0)) ? ((int)z - 1) : ((int)z); int iz = num3 + 1; float a = 0f; float a2 = 0f; float a3 = 0f; switch (quality) { case NoiseQuality.Fast: a = x - (float)num; a2 = y - (float)num2; a3 = z - (float)num3; break; case NoiseQuality.Standard: a = Libnoise.SCurve3(x - (float)num); a2 = Libnoise.SCurve3(y - (float)num2); a3 = Libnoise.SCurve3(z - (float)num3); break; case NoiseQuality.Best: a = Libnoise.SCurve5(x - (float)num); a2 = Libnoise.SCurve5(y - (float)num2); a3 = Libnoise.SCurve5(z - (float)num3); break; } float n = GradientNoise3D(x, y, z, num, num2, num3, seed); float n2 = GradientNoise3D(x, y, z, ix, num2, num3, seed); float n3 = Libnoise.Lerp(n, n2, a); n = GradientNoise3D(x, y, z, num, iy, num3, seed); n2 = GradientNoise3D(x, y, z, ix, iy, num3, seed); float n4 = Libnoise.Lerp(n, n2, a); float n5 = Libnoise.Lerp(n3, n4, a2); n = GradientNoise3D(x, y, z, num, num2, iz, seed); n2 = GradientNoise3D(x, y, z, ix, num2, iz, seed); n3 = Libnoise.Lerp(n, n2, a); n = GradientNoise3D(x, y, z, num, iy, iz, seed); n2 = GradientNoise3D(x, y, z, ix, iy, iz, seed); n4 = Libnoise.Lerp(n, n2, a); float n6 = Libnoise.Lerp(n3, n4, a2); return(Libnoise.Lerp(n5, n6, a3)); }
public RidgedMulti(double lacunarity, double frequency, NoiseQuality noiseQuality, int octaveCount, int seed) { if(octaveCount < 1 || octaveCount > RidgedMaxOctave) { throw new ArgumentException("Count was too high, above " + RidgedMaxOctave, "octaveCount"); } Seed = seed; OctaveCount = octaveCount; spectralWeights = new double[RidgedMaxOctave]; NoiseQuality = noiseQuality; Frequency = frequency; Lacunarity = lacunarity; }
public RidgedMulti(double lacunarity, double frequency, NoiseQuality noiseQuality, int octaveCount, int seed) { if (octaveCount < 1 || octaveCount > RidgedMaxOctave) { throw new ArgumentException("Count was too high, above " + RidgedMaxOctave, "octaveCount"); } Seed = seed; OctaveCount = octaveCount; spectralWeights = new double[RidgedMaxOctave]; NoiseQuality = noiseQuality; Frequency = frequency; Lacunarity = lacunarity; }
} //end GetValue #endregion #region ValueCoherentNoise2D /// <summary> /// Generates a value-coherent-noise value from the coordinates of a /// two-dimensional input value. /// /// The return value ranges from -1.0 to +1.0. /// /// </summary> /// <param name="x">The x coordinate of the input value</param> /// <param name="y">The y coordinate of the input value</param> /// <param name="seed">The random number seed</param> /// <param name="quality">The quality of the coherent-noise</param> /// <returns>The generated value-coherent-noise value</returns> public float ValueCoherentNoise2D(float x, float y, long seed, NoiseQuality quality) { // Create a unit-length square aligned along an integer boundary. // This square surrounds the input point. int x0 = (x > 0.0 ? (int)x: (int)x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int)y: (int)y - 1); int y1 = y0 + 1; // Map the difference between the coordinates of the input value and the // coordinates of the cube's outer-lower-left vertex onto an S-curve. float xs = 0, ys = 0; switch (quality) { case NoiseQuality.Fast: xs = (x - (float)x0); ys = (y - (float)y0); break; case NoiseQuality.Standard: xs = Libnoise.SCurve3(x - (float)x0); ys = Libnoise.SCurve3(y - (float)y0); break; case NoiseQuality.Best: xs = Libnoise.SCurve5(x - (float)x0); ys = Libnoise.SCurve5(y - (float)y0); break; } //end switch // Now calculate the noise values at each point of the square. To generate // the coherent-noise value at the input point, interpolate these four // noise values using the S-curve value as the interpolant (trilinear // interpolation.) float n0, n1, ix0, ix1; n0 = ValueNoise2D(x0, y0, seed); n1 = ValueNoise2D(x1, y0, seed); ix0 = Libnoise.Lerp(n0, n1, xs); n0 = ValueNoise2D(x0, y1, seed); n1 = ValueNoise2D(x1, y1, seed); ix1 = Libnoise.Lerp(n0, n1, xs); return(Libnoise.Lerp(ix0, ix1, ys)); } //end ValueCoherentNoise2D
public double GradientCoherentNoise(double x, double y, double z, int seed, NoiseQuality noiseQuality) { int x0 = (x > 0.0 ? (int)x : (int)x - 1); int y0 = (y > 0.0 ? (int)y : (int)y - 1); int z0 = (z > 0.0 ? (int)z : (int)z - 1); int X = x0 & 255; int Y = y0 & 255; int Z = z0 & 255; double x1 = 0, y1 = 0, z1 = 0; switch (noiseQuality) { case NoiseQuality.Low: x1 = (x - x0); y1 = (y - y0); z1 = (z - z0); break; case NoiseQuality.Standard: x1 = Loonim.Math.SCurve3(x - x0); y1 = Loonim.Math.SCurve3(y - y0); z1 = Loonim.Math.SCurve3(z - z0); break; case NoiseQuality.High: x1 = Loonim.Math.SCurve5(x - x0); y1 = Loonim.Math.SCurve5(y - y0); z1 = Loonim.Math.SCurve5(z - z0); break; } int A = SelectedPermutations[X] + Y; int AA = SelectedPermutations[A] + Z; int AB = SelectedPermutations[A + 1] + Z; int B = SelectedPermutations[X + 1] + Y; int BA = SelectedPermutations[B] + Z; int BB = SelectedPermutations[B + 1] + Z; double a = Loonim.Math.LinearInterpolate(GradientTable[AA], GradientTable[BA], x1); double b = Loonim.Math.LinearInterpolate(GradientTable[AB], GradientTable[BB], x1); double c = Loonim.Math.LinearInterpolate(a, b, y1); double d = Loonim.Math.LinearInterpolate(GradientTable[AA + 1], GradientTable[BA + 1], x1); double e = Loonim.Math.LinearInterpolate(GradientTable[AB + 1], GradientTable[BB + 1], x1); double f = Loonim.Math.LinearInterpolate(d, e, y1); return(Loonim.Math.LinearInterpolate(c, f, z1)); }
public double GradientCoherentNoise(double x, double y, double z, int seed, NoiseQuality noiseQuality) { var x0 = (x > 0.0 ? (int)x : (int)x - 1); var y0 = (y > 0.0 ? (int)y : (int)y - 1); var z0 = (z > 0.0 ? (int)z : (int)z - 1); var xbit = x0 & 255; var ybit = y0 & 255; var zbit = z0 & 255; double u, v, w; switch (noiseQuality) { case NoiseQuality.Low: { u = (x - x0); v = (y - y0); w = (z - z0); break; } case NoiseQuality.Standard: { u = SCurve3(x - x0); v = SCurve3(y - y0); w = SCurve3(z - z0); break; } case NoiseQuality.High: { u = SCurve5(x - x0); v = SCurve5(y - y0); w = SCurve5(z - z0); break; } default: { throw new Exception("Invalid noise quality!"); } } int abit = SelectedPermutations[xbit] + ybit, abitabit = SelectedPermutations[abit] + zbit, abitbbit = SelectedPermutations[abit + 1] + zbit; int bbit = SelectedPermutations[xbit + 1] + ybit, bbitabit = SelectedPermutations[bbit] + zbit, bbitbbit = SelectedPermutations[bbit + 1] + zbit; var a = LinearInterpolate(GradientTable[abitabit], GradientTable[bbitabit], u); var b = LinearInterpolate(GradientTable[abitbbit], GradientTable[bbitbbit], u); var c = LinearInterpolate(a, b, v); var d = LinearInterpolate(GradientTable[abitabit + 1], GradientTable[bbitabit + 1], u); var e = LinearInterpolate(GradientTable[abitbbit + 1], GradientTable[bbitbbit + 1], u); var f = LinearInterpolate(d, e, v); return LinearInterpolate(c, f, w); }
public double Noise2D(double x, double y, NoiseQuality quality) { //returns a noise value between -0.75 and 0.75 int ix0, iy0, ix1, iy1; double fx0, fy0, fx1, fy1, s, t, nx0, nx1, n0, n1; ix0 = NoiseHelper.FastFloor(x); // Integer part of x iy0 = NoiseHelper.FastFloor(y); // Integer part of y // Fractional part of x & y if (quality == NoiseQuality.Low) { fx0 = x - ix0; fy0 = y - iy0; } else if (quality == NoiseQuality.Standard) { fx0 = MathEx.SCurve3(x - ix0); fy0 = MathEx.SCurve3(y - iy0); } else { fx0 = MathEx.SCurve5(x - ix0); fy0 = MathEx.SCurve5(y - iy0); } fx1 = fx0 - 1.0f; fy1 = fy0 - 1.0f; ix1 = (ix0 + 1) & 0xff; // Wrap to 0..255 iy1 = (iy0 + 1) & 0xff; ix0 = ix0 & 0xff; iy0 = iy0 & 0xff; t = FADE(fy0); s = FADE(fx0); nx0 = GRAD2(m_perm[ix0 + m_perm[iy0]], fx0, fy0); nx1 = GRAD2(m_perm[ix0 + m_perm[iy1]], fx0, fy1); n0 = LERP(t, nx0, nx1); nx0 = GRAD2(m_perm[ix1 + m_perm[iy0]], fx1, fy0); nx1 = GRAD2(m_perm[ix1 + m_perm[iy1]], fx1, fy1); n1 = LERP(t, nx0, nx1); return(0.507f * LERP(s, n0, n1)); }
public double GradientCoherentNoise(double x, double y, double z, int seed, NoiseQuality noiseQuality) { int x0 = (x > 0.0 ? (int)x : (int)x - 1); int y0 = (y > 0.0 ? (int)y : (int)y - 1); int z0 = (z > 0.0 ? (int)z : (int)z - 1); int X = x0 & 255; int Y = y0 & 255; int Z = z0 & 255; double u = 0, v = 0, w = 0; switch (noiseQuality) { case NoiseQuality.Low: u = (x - x0); v = (y - y0); w = (z - z0); break; case NoiseQuality.Standard: u = SCurve3(x - x0); v = SCurve3(y - y0); w = SCurve3(z - z0); break; case NoiseQuality.High: u = SCurve5(x - x0); v = SCurve5(y - y0); w = SCurve5(z - z0); break; } int A = SelectedPermutations[X] + Y, AA = SelectedPermutations[A] + Z, AB = SelectedPermutations[A + 1] + Z, B = SelectedPermutations[X + 1] + Y, BA = SelectedPermutations[B] + Z, BB = SelectedPermutations[B + 1] + Z; double a = LinearInterpolate(GradientTable[AA], GradientTable[BA], u); double b = LinearInterpolate(GradientTable[AB], GradientTable[BB], u); double c = LinearInterpolate(a, b, v); double d = LinearInterpolate(GradientTable[AA + 1], GradientTable[BA + 1], u); double e = LinearInterpolate(GradientTable[AB + 1], GradientTable[BB + 1], u); double f = LinearInterpolate(d, e, v); return(LinearInterpolate(c, f, w)); }
public double GradientCoherentNoise(double x, double y, double z, int seed, NoiseQuality noiseQuality) { int x0 = (x > 0.0 ? (int)x : (int)x - 1); int y0 = (y > 0.0 ? (int)y : (int)y - 1); int z0 = (z > 0.0 ? (int)z : (int)z - 1); int X = x0 & 255; int Y = y0 & 255; int Z = z0 & 255; double u = 0, v = 0, w = 0; switch (noiseQuality) { case NoiseQuality.Low: u = (x - x0); v = (y - y0); w = (z - z0); break; case NoiseQuality.Standard: u = SCurve3(x - x0); v = SCurve3(y - y0); w = SCurve3(z - z0); break; case NoiseQuality.High: u = SCurve5(x - x0); v = SCurve5(y - y0); w = SCurve5(z - z0); break; } int A = SelectedPermutations[X] + Y, AA = SelectedPermutations[A] + Z, AB = SelectedPermutations[A + 1] + Z, B = SelectedPermutations[X + 1] + Y, BA = SelectedPermutations[B] + Z, BB = SelectedPermutations[B + 1] + Z; double a = LinearInterpolate(GradientTable[AA], GradientTable[BA], u); double b = LinearInterpolate(GradientTable[AB], GradientTable[BB], u); double c = LinearInterpolate(a, b, v); double d = LinearInterpolate(GradientTable[AA + 1], GradientTable[BA + 1], u); double e = LinearInterpolate(GradientTable[AB + 1], GradientTable[BB + 1], u); double f = LinearInterpolate(d, e, v); return LinearInterpolate(c, f, w); }
public HeightmapGenerator(int size) { this.size = size; seed = 0; octaves = 2; frequency = 0.01f; lacunarity = 2.0f; quality = NoiseQuality.Standard; primitive = new ImprovedPerlin(); primitive.Quality = quality; primitive.Seed = seed; filter = new RidgedMultiFractal(); filter.Frequency = frequency; filter.Lacunarity = lacunarity; filter.OctaveCount = octaves; filter.Primitive3D = (IModule3D)primitive; scale = new ScaleBias(filter, 1f, 0); }
/// <summary> /// A basic connstrucutor /// </summary> /// <param name="seed"></param> /// <param name="quality"></param> public PrimitiveModule(int seed, NoiseQuality quality) { _seed = seed; _quality = quality; }
/// <summary> /// Create a new BevinsValueNoise with given values. /// </summary> /// <param name="seed">Seed.</param> /// <param name="quality">Quality.</param> public BevinsValue(int seed, NoiseQuality quality) { Seed = seed; Quality = quality; }
/// <summary> /// Generates a value-coherent-noise value from the coordinates of a /// one-dimensional input value. /// /// The return value ranges from -1.0 to +1.0. /// /// </summary> /// <param name="x">The x coordinate of the input value</param> /// <param name="seed">The random number seed</param> /// <param name="quality">The quality of the coherent-noise</param> /// <returns>The generated value-coherent-noise value</returns> public static float ValueCoherentNoise1D(float x, long seed, NoiseQuality quality) { // Create a unit-length line aligned along an integer boundary. // This line surrounds the input point. int x0 = (x > 0.0 ? (int) x : (int) x - 1); int x1 = x0 + 1; float xs = 0; switch (quality) { case NoiseQuality.Fast: xs = (x - x0); break; case NoiseQuality.Standard: xs = Libnoise.SCurve3(x - x0); break; case NoiseQuality.Best: xs = Libnoise.SCurve5(x - x0); break; } // Now calculate the noise values at each point of the line. To generate // the coherent-noise value at the input point, interpolate these two // noise values using the S-curve value as the interpolant (trilinear // interpolation.) float n0, n1; n0 = ValueNoise1D(x0, seed); n1 = ValueNoise1D(x1, seed); return Libnoise.Lerp(n0, n1, xs); }
/// <summary> /// Generates a value-coherent-noise value from the coordinates of a /// two-dimensional input value. /// /// The return value ranges from -1.0 to +1.0. /// /// </summary> /// <param name="x">The x coordinate of the input value</param> /// <param name="y">The y coordinate of the input value</param> /// <param name="seed">The random number seed</param> /// <param name="quality">The quality of the coherent-noise</param> /// <returns>The generated value-coherent-noise value</returns> public float ValueCoherentNoise2D(float x, float y, long seed, NoiseQuality quality) { // Create a unit-length square aligned along an integer boundary. // This square surrounds the input point. int x0 = (x > 0.0 ? (int) x : (int) x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int) y : (int) y - 1); int y1 = y0 + 1; // Map the difference between the coordinates of the input value and the // coordinates of the cube's outer-lower-left vertex onto an S-curve. float xs = 0, ys = 0; switch (quality) { case NoiseQuality.Fast: xs = (x - x0); ys = (y - y0); break; case NoiseQuality.Standard: xs = Libnoise.SCurve3(x - x0); ys = Libnoise.SCurve3(y - y0); break; case NoiseQuality.Best: xs = Libnoise.SCurve5(x - x0); ys = Libnoise.SCurve5(y - y0); break; } // Now calculate the noise values at each point of the square. To generate // the coherent-noise value at the input point, interpolate these four // noise values using the S-curve value as the interpolant (trilinear // interpolation.) float n0, n1, ix0, ix1; n0 = ValueNoise2D(x0, y0, seed); n1 = ValueNoise2D(x1, y0, seed); ix0 = Libnoise.Lerp(n0, n1, xs); n0 = ValueNoise2D(x0, y1, seed); n1 = ValueNoise2D(x1, y1, seed); ix1 = Libnoise.Lerp(n0, n1, xs); return Libnoise.Lerp(ix0, ix1, ys); }
/// <summary> /// Create a new ImprovedPerlin with given values /// </summary> /// <param name="seed"></param> /// <param name="quality"></param> public ImprovedPerlin(int seed, NoiseQuality quality) { _seed = seed; _quality = quality; Randomize(_seed); }
/// <summary> /// Create a new BevinsGradientNoise with given values /// </summary> /// <param name="seed"></param> /// <param name="quality"></param> public BevinsGradient(int seed, NoiseQuality quality) { Seed = seed; Quality = quality; }
/// <summary> /// Create a new ImprovedPerlin with given values /// </summary> /// <param name="seed"></param> /// <param name="quality"></param> public SimplexPerlin(int seed, NoiseQuality quality) : base(seed, quality) { }
}//end BevinsGradient /// <summary> /// Create a new BevinsGradientNoise with given values /// </summary> /// <param name="seed"></param> /// <param name="quality"></param> public BevinsGradient(int seed, NoiseQuality quality) { _seed = seed; _quality = quality; }//end BevinsGradient
/// <summary> /// Code original : libnoise. /// Portage vers C# par l'équipe du projet. /// </summary> public float ValueCoherentNoise3D(float x, float y, float z, int seed, NoiseQuality noiseQuality) { // Create a unit-length cube aligned along an integer boundary. This cube // surrounds the input point. int x0 = (x > (float)0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > (float)0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; int z0 = (z > (float)0.0 ? (int)z : (int)z - 1); int z1 = z0 + 1; // Map the difference between the coordinates of the input value and the // coordinates of the cube's outer-lower-left vertex onto an S-curve. float xs = 0, ys = 0, zs = 0; switch (noiseQuality) { case NoiseQuality.QUALITY_FAST: xs = (x - (float)x0); ys = (y - (float)y0); zs = (z - (float)z0); break; case NoiseQuality.QUALITY_STD: xs = SCurve3(x - (float)x0); ys = SCurve3(y - (float)y0); zs = SCurve3(z - (float)z0); break; case NoiseQuality.QUALITY_BEST: xs = SCurve5(x - (float)x0); ys = SCurve5(y - (float)y0); zs = SCurve5(z - (float)z0); break; } // Now calculate the noise values at each vertex of the cube. To generate // the coherent-noise value at the input point, interpolate these eight // noise values using the S-curve value as the interpolant (trilinear // interpolation.) float n0, n1, ix0, ix1, iy0, iy1; n0 = ValueNoise3D(x0, y0, z0, seed); n1 = ValueNoise3D(x1, y0, z0, seed); ix0 = LinearInterp(n0, n1, xs); n0 = ValueNoise3D(x0, y1, z0, seed); n1 = ValueNoise3D(x1, y1, z0, seed); ix1 = LinearInterp(n0, n1, xs); iy0 = LinearInterp(ix0, ix1, ys); n0 = ValueNoise3D(x0, y0, z1, seed); n1 = ValueNoise3D(x1, y0, z1, seed); ix0 = LinearInterp(n0, n1, xs); n0 = ValueNoise3D(x0, y1, z1, seed); n1 = ValueNoise3D(x1, y1, z1, seed); ix1 = LinearInterp(n0, n1, xs); iy1 = LinearInterp(ix0, ix1, ys); return LinearInterp(iy0, iy1, zs); }
/// <summary> /// Generates a gradient-coherent-noise value from the coordinates of a /// three-dimensional input value. /// </summary> /// <remarks> /// <para> /// The return value ranges from -1.0 to +1.0. /// </para> /// <para> /// For an explanation of the difference between gradient noise and /// value noise, see the comments for the <see cref="GradientNoise3D" /> function. /// </para> /// </remarks> /// <param name="x">The x coordinate of the input value.</param> /// <param name="y">The y coordinate of the input value.</param> /// <param name="z">The z coordinate of the input value.</param> /// <param name="seed">The random number seed.</param> /// <param name="noiseQuality">The quality of the coherent-noise.</param> /// <returns>The generated gradient-coherent-noise value.</returns> public static double GradientCoherentNoise1D(double x, int seed = 0, NoiseQuality noiseQuality = NoiseQuality.Standard) { // Create a unit-length cube aligned along an integer boundary. This cube // surrounds the input point. int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; // Map the difference between the coordinates of the input value and the // coordinates of the cube's outer-lower-left vertex onto an S-curve. double xs = 0, ys = 0; switch(noiseQuality) { case NoiseQuality.Fast: xs = (x - x0); break; case NoiseQuality.Standard: xs = Interp.SCurve3(x - x0); break; case NoiseQuality.Best: xs = Interp.SCurve5(x - x0); break; } // Now calculate the noise values at each vertex of the cube. To generate // the coherent-noise value at the input point, interpolate these eight // noise values using the S-curve value as the interpolant (trilinear // interpolation.) double n0 = GradientNoise1D(x, x0, seed); double n1 = GradientNoise1D(x, x1, seed); return Interp.LinearInterp(n0, n1, xs); }
public double GradientCoherentNoise(double x, double y, double z, int seed, NoiseQuality noiseQuality) { int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; int z0 = (z > 0.0 ? (int)z : (int)z - 1); int z1 = z0 + 1; double xs = 0, ys = 0, zs = 0; switch (noiseQuality) { case NoiseQuality.Low: xs = (x - x0); ys = (y - y0); zs = (z - z0); break; case NoiseQuality.Standard: xs = SCurve3(x - x0); ys = SCurve3(y - y0); zs = SCurve3(z - z0); break; case NoiseQuality.High: xs = SCurve5(x - x0); ys = SCurve5(y - y0); zs = SCurve5(z - z0); break; } double n0, n1, ix0, ix1, iy0, iy1; n0 = GradientNoise(x, y, z, x0, y0, z0, seed); n1 = GradientNoise(x, y, z, x1, y0, z0, seed); ix0 = LinearInterpolate(n0, n1, xs); n0 = GradientNoise(x, y, z, x0, y1, z0, seed); n1 = GradientNoise(x, y, z, x1, y1, z0, seed); ix1 = LinearInterpolate(n0, n1, xs); iy0 = LinearInterpolate(ix0, ix1, ys); n0 = GradientNoise(x, y, z, x0, y0, z1, seed); n1 = GradientNoise(x, y, z, x1, y0, z1, seed); ix0 = LinearInterpolate(n0, n1, xs); n0 = GradientNoise(x, y, z, x0, y1, z1, seed); n1 = GradientNoise(x, y, z, x1, y1, z1, seed); ix1 = LinearInterpolate(n0, n1, xs); iy1 = LinearInterpolate(ix0, ix1, ys); return LinearInterpolate(iy0, iy1, zs); }
/// <summary> /// Create a new ImprovedPerlin with given values /// </summary> /// <param name="seed"></param> /// <param name="quality"></param> public ImprovedPerlin(int seed, NoiseQuality quality) : base(seed, quality) { Randomize(Seed); }
public double ValueCoherentNoise3D(double x, double y, double z, int seed, NoiseQuality noiseQuality) { //Create unit-length cube aligned along an integer boundary int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; int z0 = (z > 0.0 ? (int)z : (int)z - 1); int z1 = z0 + 1; //Map the difference between the coordinates of input value double xs = 0, ys = 0, zs = 0; switch (noiseQuality) { case NoiseQuality.Fast: xs = (x - (double)x0); ys = (y - (double)y0); zs = (z - (double)z0); break; case NoiseQuality.Standard: xs = MathUtils.SCurve3(x - (double)x0); ys = MathUtils.SCurve3(y - (double)y0); zs = MathUtils.SCurve3(z - (double)z0); break; case NoiseQuality.Best: xs = MathUtils.SCurve5(x - (double)x0); ys = MathUtils.SCurve5(y - (double)y0); zs = MathUtils.SCurve5(z - (double)z0); break; } //Now calculate noise values at each vertex of the cube. double n0, n1, ix0, ix1, iy0, iy1; n0 = ValueNoise3D(x0, y0, z0, seed); n1 = ValueNoise3D(x1, y0, z0, seed); ix0 = MathUtils.LinearInterp(n0, n1, xs); n0 = ValueNoise3D(x0, y1, z0, seed); n1 = ValueNoise3D(x1, y1, z0, seed); ix1 = MathUtils.LinearInterp(n0, n1, xs); iy0 = MathUtils.LinearInterp(ix0, ix1, ys); n0 = ValueNoise3D(x0, y0, z1, seed); n1 = ValueNoise3D(x1, y0, z1, seed); ix0 = MathUtils.LinearInterp(n0, n1, xs); n0 = ValueNoise3D(x0, y1, z1, seed); n1 = ValueNoise3D(x1, y1, z1, seed); ix1 = MathUtils.LinearInterp(n0, n1, xs); iy1 = MathUtils.LinearInterp(ix0, ix1, ys); return MathUtils.LinearInterp(iy0, iy1, zs); }
/// <summary> /// Generates a gradient-coherent-noise value from the coordinates of a /// three-dimensional input value. /// /// The return value ranges from -1.0 to +1.0. /// /// For an explanation of the difference between <i>gradient</i> noise and /// <i>value</i> noise, see the comments for the GradientNoise3D() function. /// </summary> /// <param name="x">The x coordinate of the input value</param> /// <param name="y">The y coordinate of the input value</param> /// <param name="z">The z coordinate of the input value</param> /// <param name="seed">seed The random number seed</param> /// <param name="quality">The quality of the coherent-noise</param> /// <returns>The generated gradient-coherent-noise value</returns> public float GradientCoherentNoise3D(float x, float y, float z, long seed, NoiseQuality quality) { // Create a unit-length cube aligned along an integer boundary. // This cube surrounds the input point. int x0 = (x > 0.0 ? (int) x : (int) x - 1); // FastFloor() int x1 = x0 + 1; int y0 = (y > 0.0 ? (int) y : (int) y - 1); int y1 = y0 + 1; int z0 = (z > 0.0 ? (int) z : (int) z - 1); int z1 = z0 + 1; // Map the difference between the coordinates of the input value and the // coordinates of the cube's outer-lower-left vertex onto an S-curve. float xs = 0, ys = 0, zs = 0; switch (quality) { case NoiseQuality.Fast: xs = (x - x0); ys = (y - y0); zs = (z - z0); break; case NoiseQuality.Standard: xs = Libnoise.SCurve3(x - x0); ys = Libnoise.SCurve3(y - y0); zs = Libnoise.SCurve3(z - z0); break; case NoiseQuality.Best: xs = Libnoise.SCurve5(x - x0); ys = Libnoise.SCurve5(y - y0); zs = Libnoise.SCurve5(z - z0); break; } // Now calculate the noise values at each vertex of the cube. To generate // the coherent-noise value at the input point, interpolate these eight // noise values using the S-curve value as the interpolant (trilinear // interpolation.) float n0, n1, ix0, ix1, iy0, iy1; n0 = GradientNoise3D(x, y, z, x0, y0, z0, seed); n1 = GradientNoise3D(x, y, z, x1, y0, z0, seed); ix0 = Libnoise.Lerp(n0, n1, xs); n0 = GradientNoise3D(x, y, z, x0, y1, z0, seed); n1 = GradientNoise3D(x, y, z, x1, y1, z0, seed); ix1 = Libnoise.Lerp(n0, n1, xs); iy0 = Libnoise.Lerp(ix0, ix1, ys); n0 = GradientNoise3D(x, y, z, x0, y0, z1, seed); n1 = GradientNoise3D(x, y, z, x1, y0, z1, seed); ix0 = Libnoise.Lerp(n0, n1, xs); n0 = GradientNoise3D(x, y, z, x0, y1, z1, seed); n1 = GradientNoise3D(x, y, z, x1, y1, z1, seed); ix1 = Libnoise.Lerp(n0, n1, xs); iy1 = Libnoise.Lerp(ix0, ix1, ys); return Libnoise.Lerp(iy0, iy1, zs); }
/// <summary> /// A basic connstrucutor /// </summary> /// <param name="seed"></param> /// <param name="quality"></param> protected PrimitiveModule(int seed, NoiseQuality quality) { _seed = seed; _quality = quality; }
public double GradientCoherentNoise(double x, double y, double z, int seed, NoiseQuality noiseQuality) { var x0 = (x > 0.0 ? (int)x : (int)x - 1); var x1 = x0 + 1; var y0 = (y > 0.0 ? (int)y : (int)y - 1); var y1 = y0 + 1; var z0 = (z > 0.0 ? (int)z : (int)z - 1); var z1 = z0 + 1; double xs, ys, zs; switch (noiseQuality) { case NoiseQuality.Low: { xs = (x - x0); ys = (y - y0); zs = (z - z0); break; } case NoiseQuality.Standard: { xs = SCurve3(x - x0); ys = SCurve3(y - y0); zs = SCurve3(z - z0); break; } case NoiseQuality.High: { xs = SCurve5(x - x0); ys = SCurve5(y - y0); zs = SCurve5(z - z0); break; } default: { throw new ArgumentOutOfRangeException(nameof(noiseQuality), noiseQuality, null); } } var n0 = GradientNoise(x, y, z, x0, y0, z0, seed); var n1 = GradientNoise(x, y, z, x1, y0, z0, seed); var ix0 = LinearInterpolate(n0, n1, xs); n0 = GradientNoise(x, y, z, x0, y1, z0, seed); n1 = GradientNoise(x, y, z, x1, y1, z0, seed); var ix1 = LinearInterpolate(n0, n1, xs); var iy0 = LinearInterpolate(ix0, ix1, ys); n0 = GradientNoise(x, y, z, x0, y0, z1, seed); n1 = GradientNoise(x, y, z, x1, y0, z1, seed); ix0 = LinearInterpolate(n0, n1, xs); n0 = GradientNoise(x, y, z, x0, y1, z1, seed); n1 = GradientNoise(x, y, z, x1, y1, z1, seed); ix1 = LinearInterpolate(n0, n1, xs); var iy1 = LinearInterpolate(ix0, ix1, ys); return LinearInterpolate(iy0, iy1, zs); }