quick-noise 0.2.0

Blazingly fast SIMD procedural noise library for batch and uniform grid sampling with runtime feature detection on stable Rust
Documentation
use std::array::from_fn;

use crate::api::batch::interface::{BatchGenerator, BatchNoise, DimIter, DimTuple};
use crate::api::configs::*;
use crate::api::seed::gen_octave_seed;
use crate::noise::combiners::Combiner;
use crate::simd::{Arch, Simd, enable_targets};

const MAX_FBM_OCTAVES: usize = 32;

impl<const D: usize, C: Combiner, G: BatchGenerator<D>> BatchNoise<D, C, G> {
    #[inline(always)]
    pub fn sample<A: Arch, I: DimIter<A, D>>(
        noise_config: NoiseConfig<D>,
        combiner_config: C::Config,
        iters: I,
    ) -> impl Iterator<Item = Simd<f32, A>> {
        let octaves = noise_config.octaves;

        let frequency: [_; D] = from_fn(|i| noise_config.scaling[i] * noise_config.frequency);
        let weight = if noise_config.normalization && octaves > 0 {
            noise_config.normalize_amplitude(noise_config.amplitude)
        } else {
            noise_config.amplitude
        };

        let mut seeds = [0u32; MAX_FBM_OCTAVES];
        let mut temp_freq = frequency;
        for seed in seeds.iter_mut().take(octaves) {
            *seed = gen_octave_seed(temp_freq, noise_config.seed);
            temp_freq
                .iter_mut()
                .for_each(|x| *x *= noise_config.lacunarity);
        }

        let lacunarity = Simd::splat(noise_config.lacunarity);
        let persistence = Simd::splat(noise_config.persistence);

        #[allow(clippy::too_many_arguments)]
        #[enable_targets(A)]
        fn process_batch<
            const D: usize,
            C: Combiner,
            G: BatchGenerator<D>,
            A: Arch,
        >(
            inputs: [Simd<f32, A>; D],
            octaves: usize,
            seeds: &[u32; 32],
            weight: f32,
            frequency: [f32; D],
            combiner_config: &C::Config,
            noise_config: &NoiseConfig<D>,
            persistence: Simd<f32, A>,
            lacunarity: Simd<f32, A>,
        ) -> Simd<f32, A> {
            if octaves == 0 {
                return Simd::zero();
            }
            let (mut state, mut sample): (C::State<A>, Simd<f32, A>) = Default::default();

            let seed = seeds[0];
            let mut weight = Simd::splat(weight);
            let mut freq = from_fn(|i| Simd::splat(frequency[i]));
            let new_sample = G::sample_batch(seed, inputs, freq) * weight;

            if noise_config.initialize {
                (state, sample) = C::initialize_sample(combiner_config, new_sample);
            } else {
                (state, sample) = C::apply_sample(combiner_config, state, sample, new_sample);
            }

            for seed in seeds.iter().take(octaves).skip(1) {
                freq.iter_mut().for_each(|x| *x *= lacunarity);
                if C::WEIGHT_DECAY {
                    weight *= persistence;
                }

                let new_sample = G::sample_batch(*seed, inputs, freq) * weight;
                (state, sample) = C::apply_sample(combiner_config, state, sample, new_sample);
            }

            if noise_config.finalize {
                C::finalize_sample(combiner_config, state, sample)
            } else {
                sample
            }
        }

        iters.map(move |x| {
            process_batch::<D, C, G, A>(
                x.into_array(),
                octaves,
                &seeds,
                weight,
                frequency,
                &combiner_config,
                &noise_config,
                persistence,
                lacunarity,
            )
        })
    }
}