FractalBase.cs

using System.Numerics;

namespace RedOwl;

public static partial class Noise
{
    public abstract class FractalBase : Generator
    {
        private static readonly Quaternion Rotation = Quaternion.CreateFromYawPitchRoll(30, 30, 30);

        protected readonly Generator Source;
        private float m_Frequency;
        private float m_Lacunarity;
        private int m_OctaveCount;

        protected FractalBase(int seed)
        {
            Source = new Gradient(seed);
            Lacunarity = 2.17f;
            OctaveCount = 6;
            Frequency = 1f;
        }

        protected FractalBase(Generator source)
        {
            Source = source;
            Lacunarity = 2.17f;
            OctaveCount = 6;
            Frequency = 1f;
        }

        public float Lacunarity
        {
            get => m_Lacunarity;
            set
            {
                m_Lacunarity = value;
                OnParamsChanged();
            }
        }

        public int OctaveCount
        {
            get => m_OctaveCount;
            set
            {
                m_OctaveCount = value;
                OnParamsChanged();
            }
        }

        public float Frequency
        {
            get => m_Frequency;
            set
            {
                m_Frequency = value;
                OnParamsChanged();
            }
        }

        internal override float Sample(float x, float y, float z)
        {
            var value = 0.0f;
            var state = InitializeState();
            x *= Frequency;
            y *= Frequency;
            z *= Frequency;
            for (var octave = 0; octave < OctaveCount; ++octave)
            {
                var signal = Source.Sample(x, y, z);
                value = CombineOctave(octave, signal, value, ref state);
                var transformed = Vector3.Transform(new Vector3(x * Lacunarity, y * Lacunarity, z * Lacunarity), Rotation);
                x = transformed.X;
                y = transformed.Y;
                z = transformed.Z;
            }

            return value;
        }

        /// <summary>Initialize state for the octave loop. Default is zero, subclasses override if needed.</summary>
        protected virtual float InitializeState() => 0;

        protected abstract float CombineOctave(int octave, float signal, float value, ref float state);

        protected virtual void OnParamsChanged()
        {
        }
    }
}