Skip to main content

quick_noise/api/
configs.rs

1/// Comprehensive config for noise parameters, including lacunarity
2/// octave generation.
3#[derive(Copy, Clone, Debug, PartialEq)]
4#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5pub struct NoiseConfig<const D: usize> {
6    pub seed: u64,
7    pub octaves: usize,
8    pub frequency: f32,
9    pub amplitude: f32,
10    pub lacunarity: f32,
11    pub persistence: f32,
12    pub normalization: bool,
13    pub initialize: bool,
14    pub finalize: bool,
15    pub magnification: f32,
16    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
17    pub scaling: [f32; D],
18}
19
20/// Comprehensive config for noise parameters without lacunarity
21/// octave generation.
22#[derive(Copy, Clone, Debug, PartialEq)]
23#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24pub struct OctaveNoiseConfig<const D: usize> {
25    pub seed: u64,
26    pub amplitude: f32,
27    pub normalization: bool,
28    pub initialize: bool,
29    pub finalize: bool,
30    pub magnification: f32,
31    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
32    pub scaling: [f32; D],
33}
34
35/// Config specifying parameters of a grid.
36#[derive(Copy, Clone, Debug, PartialEq)]
37#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
38pub struct GridConfig<const D: usize> {
39    pub grid_seed: u64,
40    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
41    pub grid_size: [usize; D],
42    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
43    pub position: [f64; D],
44    #[cfg_attr(feature = "serde", serde(with = "serde_arrays"))]
45    pub tiling: [Option<u32>; D],
46}
47
48impl<const D: usize> NoiseConfig<D> {
49    pub(crate) fn num_grid_octaves(&self) -> usize {
50        let max_scaling = self.scaling.iter().fold(0.0, |max, x| x.max(max));
51
52        let mut cur_freq = self.frequency * max_scaling;
53        if cur_freq >= 1.0 || self.lacunarity >= 1.0 {
54            for i in 0..self.octaves {
55                if cur_freq >= 1.0 {
56                    return i;
57                }
58                cur_freq *= self.lacunarity;
59            }
60        }
61
62        self.octaves
63    }
64
65    pub(crate) fn normalize_amplitude(&self, amplitude: f32) -> f32 {
66        let mut sum = 0.0;
67        let mut cur = 1.0;
68        for _ in 0..self.octaves {
69            sum += cur;
70            cur *= self.persistence;
71        }
72        amplitude / sum
73    }
74}