Skip to main content

quick_noise/api/batch/
interface.rs

1use std::marker::PhantomData;
2
3use crate::noise::combiners::Combiner;
4use crate::simd::{Arch, Simd};
5
6/// Zipped iterator type used for generically handling
7/// `D` iterators.
8pub trait DimTuple<A: Arch, const D: usize> {
9    /// Converts the internal iterator representation
10    /// into a generically sized array.
11    fn into_array(self) -> [Simd<f32, A>; D];
12}
13type S<A> = Simd<f32, A>;
14
15impl<A: Arch> DimTuple<A, 1> for S<A> {
16    fn into_array(self) -> [Simd<f32, A>; 1] {
17        [self]
18    }
19}
20
21impl<A: Arch> DimTuple<A, 2> for (S<A>, S<A>) {
22    fn into_array(self) -> [Simd<f32, A>; 2] {
23        [self.0, self.1]
24    }
25}
26
27impl<A: Arch> DimTuple<A, 3> for (S<A>, S<A>, S<A>) {
28    fn into_array(self) -> [Simd<f32, A>; 3] {
29        [self.0, self.1, self.2]
30    }
31}
32
33impl<A: Arch> DimTuple<A, 4> for (S<A>, S<A>, S<A>, S<A>) {
34    fn into_array(self) -> [Simd<f32, A>; 4] {
35        [self.0, self.1, self.2, self.3]
36    }
37}
38
39impl<A: Arch> DimTuple<A, 5> for (S<A>, S<A>, S<A>, S<A>, S<A>) {
40    fn into_array(self) -> [Simd<f32, A>; 5] {
41        [self.0, self.1, self.2, self.3, self.4]
42    }
43}
44
45pub trait DimIter<A: Arch, const D: usize>: Iterator<Item: DimTuple<A, D>> {}
46
47impl<A: Arch, const D: usize, T: DimTuple<A, D>, I: Iterator<Item = T>> DimIter<A, D> for I {}
48
49pub trait BatchGenerator<const D: usize> {
50    /// Generates noise using simd registers.
51    ///
52    /// # Parameters
53    /// - `seed`: Configures the deterministic randomness of the noise
54    /// - `input`: Array of input values for each dimension
55    /// - `freq`: Array of frequency values for each dimension
56    fn sample_batch<A: Arch>(
57        seed: u32,
58        input: [Simd<f32, A>; D],
59        freq: [Simd<f32, A>; D],
60    ) -> Simd<f32, A>;
61}
62
63///  struct for sampling batch noise.
64///
65/// # Example
66/// ```
67/// use quick_noise::{Grid, BatchNoise, Fbm, Perlin};
68///
69/// let grid = Grid::<2>::new(32, 32);
70///
71/// let noise = BatchNoise::<2, Fbm, Perlin>::builder(grid.x_iter(), grid.y_iter())
72///     .octaves(1)
73///     .frequency(1.0 / 32.0)
74///     .build();
75/// ```
76#[derive(Default)]
77pub struct BatchNoise<const D: usize, C: Combiner, G: BatchGenerator<D>> {
78    _fractal: PhantomData<C>,
79    _sampler: PhantomData<G>,
80}