use std::marker::PhantomData;
use crate::Combiner;
use crate::api::configs::GridConfig;
use crate::api::grid::builder::GridNoiseBuilder;
use crate::api::grid::octaves_builder::OctaveGridNoiseBuilder;
use crate::api::octave::Octave;
use crate::math::random::Random;
use crate::simd::{Arch, StaticArch};
#[derive(Copy, Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GridNoiseParams<const D: usize> {
pub seed: u32,
#[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
pub grid_size: [usize; D],
#[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
pub position: [f64; D],
#[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
pub frequency: [f32; D],
pub weight: f32,
pub magnification: f32,
#[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
pub tiling: [Option<u32>; D],
}
pub trait GridGenerator<const D: usize>: Default + Copy + Clone + PartialEq {
fn sample_grid<A: Arch, C: Combiner, const INIT: bool, const FINAL: bool>(
params: GridNoiseParams<D>,
combiner_config: C::Config,
state: &mut [f32],
dst: &mut [f32],
);
}
pub struct GridNoise<const D: usize, C: Combiner, G: GridGenerator<D>> {
_fractal: PhantomData<C>,
_sampler: PhantomData<G>,
}
#[derive(Default, Clone, Copy, Debug, PartialEq)]
pub struct Grid<const D: usize, A: Arch = StaticArch> {
pub(crate) config: GridConfig<D>,
pub(crate) _arch: PhantomData<A>,
}
impl<const D: usize, A: Arch> Grid<D, A> {
pub fn seed(mut self, seed: i64) -> Self {
self.config.grid_seed = Random::mix_u64(seed as u64);
self
}
}
impl<A: Arch> Grid<2, A> {
pub fn new(x: usize, y: usize) -> Self {
let config = GridConfig {
grid_size: [x, y],
..Default::default()
};
Self {
config,
_arch: PhantomData::<A>,
}
}
pub fn grid_position(mut self, x: f64, y: f64) -> Self {
self.config.position = [
x * self.config.grid_size[0] as f64,
y * self.config.grid_size[1] as f64,
];
self
}
pub fn sample_position(mut self, x: f64, y: f64) -> Self {
self.config.position = [x, y];
self
}
pub fn tiling(mut self, x: Option<u32>, y: Option<u32>) -> Self {
self.config.tiling = [x, y];
self
}
}
impl<A: Arch> Grid<3, A> {
pub fn new(x: usize, y: usize, z: usize) -> Self {
let config = GridConfig {
grid_size: [x, y, z],
..Default::default()
};
Self {
config,
_arch: PhantomData::<A>,
}
}
pub fn grid_position(mut self, x: f64, y: f64, z: f64) -> Self {
self.config.position = [
x * self.config.grid_size[0] as f64,
y * self.config.grid_size[1] as f64,
z * self.config.grid_size[2] as f64,
];
self
}
pub fn sample_position(mut self, x: f64, y: f64, z: f64) -> Self {
self.config.position = [x, y, z];
self
}
pub fn tiling(mut self, x: Option<u32>, y: Option<u32>, z: Option<u32>) -> Self {
self.config.tiling = [x, y, z];
self
}
}
impl<const D: usize, A: Arch> Grid<D, A> {
pub fn from_config(config: GridConfig<D>) -> Self {
Self {
config,
_arch: PhantomData::<A>,
}
}
pub fn builder<C: Combiner, G: GridGenerator<D>>(&self) -> GridNoiseBuilder<D, C, G, A> {
GridNoiseBuilder::from_config(self.config)
}
pub fn builder_with_octaves<'a, C: Combiner, G: GridGenerator<D>>(
&self,
octave_list: &'a [Octave<D>],
) -> OctaveGridNoiseBuilder<'a, D, C, G, A> {
OctaveGridNoiseBuilder::new(self.config, octave_list)
}
}