plottery_lib 0.11.0

Core geometry library of Plottery, a creative coding framework for generative vector graphics and pen plotting.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::fmt;

use fastnoise_lite::{FastNoiseLite, FractalType};
use rand::Rng;

use crate::V2;

use super::thread_local::{PERLIN, RNG, SIMPLEX, WORLEY};

pub fn perlin_2d(location: V2) -> f32 {
    let val = PERLIN.with_borrow(|noise| noise.get_noise_2d(location.x, location.y));
    (val + 1.0) / 2.0
}

pub fn perlin_3d(x: f32, y: f32, z: f32) -> f32 {
    let val = PERLIN.with_borrow(|noise| noise.get_noise_3d(x, y, z));
    (val + 1.0) / 2.0
}

pub fn simplex_2d(location: V2) -> f32 {
    let val = SIMPLEX.with_borrow(|noise| noise.get_noise_2d(location.x, location.y));
    (val + 1.0) / 2.0
}

pub fn simplex_3d(x: f32, y: f32, z: f32) -> f32 {
    let val = SIMPLEX.with_borrow(|noise| noise.get_noise_3d(x, y, z));
    (val + 1.0) / 2.0
}

pub fn worley_2d(location: V2) -> f32 {
    let val = WORLEY.with_borrow(|noise| noise.get_noise_2d(location.x, location.y));
    (val + 1.0) / 2.0
}

pub fn worley_3d(x: f32, y: f32, z: f32) -> f32 {
    let val = WORLEY.with_borrow(|noise| noise.get_noise_3d(x, y, z));
    (val + 1.0) / 2.0
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum NoiseType {
    Perlin,
    Simplex,
    Worley,
}

/// Noise with its own seed and frequency. The default frequency of 1.0 gives roughly one feature per unit.
pub struct Noise {
    noise_type: NoiseType,
    seed: i32,
    frequency: f32,
    octaves: u32,
    inner: FastNoiseLite,
}

impl Noise {
    /// Seeded from the global random number generator, see [`seed`](crate::seed).
    pub fn new(noise_type: NoiseType) -> Self {
        let seed = RNG.lock().expect("Failed to acquire RNG lock").gen();
        Self::build(noise_type, seed, 1.0, 1)
    }
    pub fn perlin() -> Self {
        Self::new(NoiseType::Perlin)
    }
    pub fn simplex() -> Self {
        Self::new(NoiseType::Simplex)
    }
    pub fn worley() -> Self {
        Self::new(NoiseType::Worley)
    }

    pub fn seed(self, seed: i32) -> Self {
        Self::build(self.noise_type, seed, self.frequency, self.octaves)
    }
    pub fn frequency(self, frequency: f32) -> Self {
        Self::build(self.noise_type, self.seed, frequency, self.octaves)
    }
    /// Number of fractal (FBm) octaves, 1 disables the fractal.
    pub fn octaves(self, octaves: u32) -> Self {
        Self::build(self.noise_type, self.seed, self.frequency, octaves)
    }

    /// Noise value in `0..=1`
    pub fn get(&self, location: V2) -> f32 {
        (self.inner.get_noise_2d(location.x, location.y) + 1.0) / 2.0
    }
    /// Noise value in `0..=1`
    pub fn get_3d(&self, location: V2, z: f32) -> f32 {
        (self.inner.get_noise_3d(location.x, location.y, z) + 1.0) / 2.0
    }

    fn build(noise_type: NoiseType, seed: i32, frequency: f32, octaves: u32) -> Self {
        let mut inner = FastNoiseLite::new();
        inner.set_noise_type(Some(match noise_type {
            NoiseType::Perlin => fastnoise_lite::NoiseType::Perlin,
            NoiseType::Simplex => fastnoise_lite::NoiseType::OpenSimplex2S,
            NoiseType::Worley => fastnoise_lite::NoiseType::Cellular,
        }));
        inner.set_seed(Some(seed));
        inner.set_frequency(Some(frequency));
        if octaves > 1 {
            inner.set_fractal_type(Some(FractalType::FBm));
            inner.set_fractal_octaves(Some(octaves as i32));
        }
        Self {
            noise_type,
            seed,
            frequency,
            octaves,
            inner,
        }
    }
}

impl Clone for Noise {
    fn clone(&self) -> Self {
        Self::build(self.noise_type, self.seed, self.frequency, self.octaves)
    }
}

impl fmt::Debug for Noise {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Noise")
            .field("noise_type", &self.noise_type)
            .field("seed", &self.seed)
            .field("frequency", &self.frequency)
            .field("octaves", &self.octaves)
            .finish()
    }
}