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);
}
