Ridge.cs

namespace RedOwl;

public static partial class Noise
{
    public class Ridge : FractalBase
    {
        private float _exponent;
        private float[] _spectralWeights = [];

        public float Offset { get; set; }

        public float Gain { get; set; }

        public float Exponent
        {
            get => _exponent;
            set
            {
                _exponent = value;
                OnParamsChanged();
            }
        }

        public Ridge(int seed) : base(seed)
        {
            Offset = 1f;
            Gain = 2f;
            Exponent = 1f;
        }

        public Ridge(Generator source) : base(source)
        {
            Offset = 1f;
            Gain = 2f;
            Exponent = 1f;
        }

        protected override float InitializeState() => 1f;

        protected override float CombineOctave(int octave, float signal, float value, ref float state)
        {
            if (octave == 0) state = 1f;

            // Ridge noise: Offset - abs(signal), then squared
            signal = Offset - MathF.Abs(signal);
            signal *= signal;

            // Weight by current state (weight from previous octave)
            signal *= state;

            // Accumulate into value with spectral weight
            value += signal * _spectralWeights[octave];

            // Update state (weight) for next octave: clamp(signal * Gain, 0, 1)
            state = signal * Gain;
            if (state > 1f) state = 1f;
            if (state < 0f) state = 0f;

            return value;
        }

        protected override void OnParamsChanged() => PrecalculateWeights();

        private void PrecalculateWeights()
        {
            var freq = 1f;
            _spectralWeights = new float[OctaveCount];
            for (var index = 0; index < OctaveCount; ++index)
            {
                _spectralWeights[index] = MathF.Pow(freq, -Exponent);
                freq *= Lacunarity;
            }
        }
    }
}