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};
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)]
#[inline(always)]
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,
)
})
}
}