noise 0.9.0

Procedural noise generation library.
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
131
132
133
134
135
136
137
138
139

use crate::{
    math::{interpolate::linear, s_curve::quintic::Quintic, vectors::*},
    permutationtable::NoiseHasher,
};

pub fn value_2d<NH>(point: Vector2<f64>, hasher: &NH) -> f64
where
    NH: NoiseHasher + ?Sized,
{
    let corner = point.floor_to_isize();
    let weight = (point - corner.numcast().unwrap()).map_quintic();

    macro_rules! get(
        ($offset:expr) => {
            {
               hasher.hash(&(corner + $offset).into_array()) as f64 / 255.0
            }
        }
    );

    let f00 = get!(Vector2::new(0, 0));
    let f10 = get!(Vector2::new(1, 0));
    let f01 = get!(Vector2::new(0, 1));
    let f11 = get!(Vector2::new(1, 1));

    let result = linear(
        linear(f00, f10, weight.x),
        linear(f01, f11, weight.x),
        weight.y,
    );

    result * 2.0 - 1.0
}

pub fn value_3d<NH>(point: Vector3<f64>, hasher: &NH) -> f64
where
    NH: NoiseHasher + ?Sized,
{
    let corner = point.floor_to_isize();
    let weight = (point - corner.numcast().unwrap()).map_quintic();

    macro_rules! get(
        ($offset:expr) => {
            {
               hasher.hash(&(corner + $offset).into_array()) as f64 / 255.0
            }
        }
    );

    let f000 = get!(Vector3::new(0, 0, 0));
    let f100 = get!(Vector3::new(1, 0, 0));
    let f010 = get!(Vector3::new(0, 1, 0));
    let f110 = get!(Vector3::new(1, 1, 0));
    let f001 = get!(Vector3::new(0, 0, 1));
    let f101 = get!(Vector3::new(1, 0, 1));
    let f011 = get!(Vector3::new(0, 1, 1));
    let f111 = get!(Vector3::new(1, 1, 1));

    let result = linear(
        linear(
            linear(f000, f100, weight.x),
            linear(f010, f110, weight.x),
            weight.y,
        ),
        linear(
            linear(f001, f101, weight.x),
            linear(f011, f111, weight.x),
            weight.y,
        ),
        weight.z,
    );

    result * 2.0 - 1.0
}

pub fn value_4d<NH>(point: Vector4<f64>, hasher: &NH) -> f64
where
    NH: NoiseHasher + ?Sized,
{
    let corner = point.floor_to_isize();
    let weight = (point - corner.numcast().unwrap()).map_quintic();

    macro_rules! get(
        ($offset:expr) => {
            {
               hasher.hash(&(corner + $offset).into_array()) as f64 / 255.0
            }
        }
    );

    let f0000 = get!(Vector4::new(0, 0, 0, 0));
    let f1000 = get!(Vector4::new(1, 0, 0, 0));
    let f0100 = get!(Vector4::new(0, 1, 0, 0));
    let f1100 = get!(Vector4::new(1, 1, 0, 0));
    let f0010 = get!(Vector4::new(0, 0, 1, 0));
    let f1010 = get!(Vector4::new(1, 0, 1, 0));
    let f0110 = get!(Vector4::new(0, 1, 1, 0));
    let f1110 = get!(Vector4::new(1, 1, 1, 0));
    let f0001 = get!(Vector4::new(0, 0, 0, 1));
    let f1001 = get!(Vector4::new(1, 0, 0, 1));
    let f0101 = get!(Vector4::new(0, 1, 0, 1));
    let f1101 = get!(Vector4::new(1, 1, 0, 1));
    let f0011 = get!(Vector4::new(0, 0, 1, 1));
    let f1011 = get!(Vector4::new(1, 0, 1, 1));
    let f0111 = get!(Vector4::new(0, 1, 1, 1));
    let f1111 = get!(Vector4::new(1, 1, 1, 1));

    let result = linear(
        linear(
            linear(
                linear(f0000, f1000, weight.x),
                linear(f0100, f1100, weight.x),
                weight.y,
            ),
            linear(
                linear(f0010, f1010, weight.x),
                linear(f0110, f1110, weight.x),
                weight.y,
            ),
            weight.z,
        ),
        linear(
            linear(
                linear(f0001, f1001, weight.x),
                linear(f0101, f1101, weight.x),
                weight.y,
            ),
            linear(
                linear(f0011, f1011, weight.x),
                linear(f0111, f1111, weight.x),
                weight.y,
            ),
            weight.z,
        ),
        weight.w,
    );

    result * 2.0 - 1.0
}