use std::marker::PhantomData;
use itertools::{Zip};
use simply_simd::{Arch, Simd};
use crate::api::batch::interface::{BatchGenerator, BatchNoise, DimIter};
use crate::api::configs::*;
use crate::api::parameters::*;
use crate::math::random::Random;
use crate::noise::combiners::Combiner;
use crate::{HybridMulti, PingPong, Ridged, Terrace};
#[inline(always)]
pub fn multizip<T, U>(t: U) -> Zip<T>
where
Zip<T>: From<U> + Iterator,
{
Zip::from(t)
}
pub struct BatchNoiseBuilder<
const D: usize,
C: Combiner,
G: BatchGenerator<D>,
A: Arch,
I: DimIter<A, D>,
> {
pub(crate) noise_config: NoiseConfig<D>,
pub(crate) combiner_config: C::Config,
pub(crate) iters: I,
pub(crate) _noise_type: PhantomData<G>,
pub(crate) _arch: PhantomData<A>,
}
params_noise_builder!(BatchNoiseBuilder, [const D: usize, C: Combiner, G: BatchGenerator<D>, A: Arch, I: DimIter<A, D>], [D, C, G, A, I]);
params_lacunarity_builder!(BatchNoiseBuilder, [const D: usize, C: Combiner, G: BatchGenerator<D>, A: Arch, I: DimIter<A, D>], [D, C, G, A, I]);
params_combiner_builder!(BatchNoiseBuilder, [const D: usize, C: Combiner<Config: Sized>, G: BatchGenerator<D>, A: Arch, I: DimIter<A, D>], [D, C, G, A, I]);
params_ridged_builder!(BatchNoiseBuilder, [const D: usize, G: BatchGenerator<D>, A: Arch, I: DimIter<A, D>], [D, Ridged, G, A, I]);
params_ping_pong_builder!(BatchNoiseBuilder, [const D: usize, G: BatchGenerator<D>, A: Arch, I: DimIter<A, D>], [D, PingPong, G, A, I]);
params_terrace_builder!(BatchNoiseBuilder, [const D: usize, G: BatchGenerator<D>, A: Arch, I: DimIter<A, D>], [D, Terrace, G, A, I]);
params_hybrid_multi_builder!(BatchNoiseBuilder, [const D: usize, G: BatchGenerator<D>, A: Arch, I: DimIter<A, D>], [D, HybridMulti, G, A, I]);
params_grid_seed_builder!(BatchNoiseBuilder, [const D: usize, C: Combiner, G: BatchGenerator<D>, A: Arch, I: DimIter<A, D>], [D, C, G, A, I]);
params_noise_scaling_2d!(BatchNoiseBuilder, [C: Combiner, G: BatchGenerator<2>, A: Arch, I: DimIter<A, 2>], [2, C, G, A, I]);
params_noise_scaling_3d!(BatchNoiseBuilder, [C: Combiner, G: BatchGenerator<3>, A: Arch, I: DimIter<A, 3>], [3, C, G, A, I]);
impl<C: Combiner, G: BatchGenerator<2>> BatchNoise<2, C, G> {
pub fn builder<A: Arch, X, Y>(x_iter: X, y_iter: Y) -> BatchNoiseBuilder<2, C, G, A, Zip<(X, Y)>>
where
X: Iterator<Item = Simd<f32, A>>,
Y: Iterator<Item = Simd<f32, A>>,
Zip<(X, Y)>: DimIter<A, 2>,
{
BatchNoiseBuilder::<2, C, G, A, _>::new(x_iter, y_iter)
}
}
impl<G, C, A, X, Y> BatchNoiseBuilder<2, C, G, A, Zip<(X, Y)>>
where
G: BatchGenerator<2>,
C: Combiner,
A: Arch,
X: Iterator<Item = Simd<f32, A>>,
Y: Iterator<Item = Simd<f32, A>>,
Zip<(X, Y)>: DimIter<A, 2>,
{
pub fn new(x_iter: X, y_iter: Y) -> Self {
Self {
noise_config: Default::default(),
combiner_config: Default::default(),
iters: multizip((x_iter, y_iter)),
_noise_type: PhantomData::<G>,
_arch: PhantomData::<A>,
}
}
pub fn from_configs(
noise_config: NoiseConfig<2>,
combiner_config: C::Config,
x_iter: X,
y_iter: Y,
) -> Self {
Self {
noise_config,
combiner_config,
iters: multizip((x_iter, y_iter)),
_noise_type: PhantomData::<G>,
_arch: PhantomData::<A>,
}
}
}
impl<F: Combiner, S: BatchGenerator<3>> BatchNoise<3, F, S> {
pub fn builder<A: Arch, X, Y, Z>(
x_iter: X,
y_iter: Y,
z_iter: Z,
) -> BatchNoiseBuilder<3, F, S, A, Zip<(X, Y, Z)>>
where
X: Iterator<Item = Simd<f32, A>>,
Y: Iterator<Item = Simd<f32, A>>,
Z: Iterator<Item = Simd<f32, A>>,
Zip<(X, Y, Z)>: DimIter<A, 3>,
{
BatchNoiseBuilder::<3, F, S, A, _>::new(x_iter, y_iter, z_iter)
}
}
impl<S, F, A, X, Y, Z> BatchNoiseBuilder<3, F, S, A, Zip<(X, Y, Z)>>
where
S: BatchGenerator<3>,
F: Combiner,
A: Arch,
X: Iterator<Item = Simd<f32, A>>,
Y: Iterator<Item = Simd<f32, A>>,
Z: Iterator<Item = Simd<f32, A>>,
Zip<(X, Y, Z)>: DimIter<A, 3>,
{
pub fn new(x_iter: X, y_iter: Y, z_iter: Z) -> Self {
Self {
noise_config: Default::default(),
combiner_config: Default::default(),
iters: multizip((x_iter, y_iter, z_iter)),
_noise_type: PhantomData::<S>,
_arch: PhantomData::<A>,
}
}
pub fn from_configs(
noise_config: NoiseConfig<3>,
combiner_config: F::Config,
x_iter: X,
y_iter: Y,
z_iter: Z,
) -> Self {
Self {
noise_config,
combiner_config,
iters: multizip((x_iter, y_iter, z_iter)),
_noise_type: PhantomData::<S>,
_arch: PhantomData::<A>,
}
}
}
impl<const D: usize, F: Combiner, S: BatchGenerator<D>, A: Arch, I: DimIter<A, D>>
BatchNoiseBuilder<D, F, S, A, I>
{
declare_fill!(self, output, {
if self.noise_config.initialize {
for (i, x) in self.into_iter().enumerate() {
x.copy_to_slice(&mut output[i * Simd::<f32, A>::LANES..]);
}
} else {
let mut i = 0;
for x in self.into_iter() {
let cur = Simd::from_slice(&output[i..]);
let x = cur + x;
x.copy_to_slice(&mut output[i..]);
i += Simd::<f32, A>::LANES;
}
}
});
declare_build!(self, { self.into_iter().collect() });
declare_into_iter!(A, self, {
BatchNoise::<D, F, S>::sample(self.noise_config, self.combiner_config, self.iters)
});
}