public void GetNoise2DValueWithAccumulation(ref double[] result, int FromX, int ToX, int SamplingStepsCountX, int FromZ, int ToZ, int SamplingStepsCountZ, int octaves, double persistence, out NoiseResult Range) { SamplingStepsCountX++; SamplingStepsCountZ++; Range = new NoiseResult() { isSet = false }; if (result == null) { result = new double[(SamplingStepsCountX) * (SamplingStepsCountZ)]; } int samplingStepX = (ToX - FromX) / (SamplingStepsCountX - 1); int samplingStepZ = (ToZ - FromZ) / (SamplingStepsCountZ - 1); int generatedNoise = 0; for (int X = 0; X < SamplingStepsCountX; X++) { for (int Z = 0; Z < SamplingStepsCountZ; Z++) { result[generatedNoise] = SimpleNoise2DValue((X * samplingStepX) + FromX, (Z * samplingStepZ) + FromZ, octaves, persistence, ref Range); generatedNoise++; } } }
public static NoiseResult Min(NoiseResult NoiseResult1, NoiseResult NoiseResult2) { return(new NoiseResult() { Value = NoiseResult1.Value < NoiseResult2.Value ? NoiseResult1.Value : NoiseResult2.Value, MinValue = NoiseResult1.MinValue < NoiseResult2.MinValue ? NoiseResult1.MinValue : NoiseResult2.MinValue, MaxValue = NoiseResult1.MaxValue < NoiseResult2.MaxValue ? NoiseResult2.MaxValue : NoiseResult1.MaxValue }); }
public static NoiseResult Multiply(NoiseResult NoiseResult1, double WeightNoiseResult1, NoiseResult NoiseResult2, double WeightNoiseResult2) { return(new NoiseResult() { Value = (NoiseResult1.Value * WeightNoiseResult1) * (NoiseResult2.Value * WeightNoiseResult2), MinValue = (NoiseResult1.MinValue * WeightNoiseResult1) * (NoiseResult2.MinValue * WeightNoiseResult2), MaxValue = (NoiseResult1.MaxValue * WeightNoiseResult1) * (NoiseResult2.MaxValue * WeightNoiseResult2) }); }
private double SimpleNoise2DValue(double X, double Z, int octaves, double persistence, ref NoiseResult Range) { X += _offsetX; Z += _offsetZ; double value = 0.0f; double frequence; double amplitude; for (int i = 0; i < octaves; i++) { frequence = System.Math.Pow(2, i); // Changer la fréquence des vagues ! plus i est grand plus les vagues sont serées ! amplitude = System.Math.Pow(persistence, i); //==> Pour changer la douceur des changements par la valeur persistence (<0.5 doux, >0.5 abrupte) switch (_inflection) { case InflectionMode.NoInflections: value += noise(X * frequence * _zoom, Z * frequence * _zoom, _scale) * amplitude; if (Range.isSet) { break; } if (_scale == ResultScale.MinOneToOne) { Range.MinValue += -1 * amplitude; Range.MaxValue += 1 * amplitude; } else { Range.MinValue += 0 * amplitude; Range.MaxValue += 1 * amplitude; } break; case InflectionMode.ABSFct: value += System.Math.Abs(noise(X * frequence * _zoom, Z * frequence * _zoom, ResultScale.MinOneToOne)) * amplitude; if (Range.isSet) { break; } Range.MinValue += 0 * amplitude; Range.MaxValue += 1 * amplitude; break; case InflectionMode.InvABSFct: value += (1 - System.Math.Abs(noise(X * frequence * _zoom, Z * frequence * _zoom, ResultScale.MinOneToOne))) * amplitude; if (Range.isSet) { break; } Range.MinValue += 0 * amplitude; Range.MaxValue += 1 * amplitude; break; case InflectionMode.InvFct: value += (1 - noise(X * frequence * _zoom, Z * frequence * _zoom, ResultScale.ZeroToOne)) * amplitude; if (Range.isSet) { break; } Range.MinValue += 0 * amplitude; Range.MaxValue += 1 * amplitude; break; } } Range.isSet = true; return(value); }