1 #pragma once
2 /* Copyright (c) 2007-2012 Eliot Eshelman
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
16  *
17  */
18 
19 #ifndef CATA_SRC_SIMPLEXNOISE_H
20 #define CATA_SRC_SIMPLEXNOISE_H
21 
22 /* 2D, 3D and 4D Simplex Noise functions return 'random' values in (-1, 1).
23 
24 This algorithm was originally designed by Ken Perlin, but my code has been
25 adapted from the implementation written by Stefan Gustavson (stegu@itn.liu.se)
26 
27 Raw Simplex noise functions return the value generated by Ken's algorithm.
28 
29 Scaled Raw Simplex noise functions adjust the range of values returned from the
30 traditional (-1, 1) to whichever bounds are passed to the function.
31 
32 Multi-Octave Simplex noise functions combine multiple noise values to create a
33 more complex result. Each successive layer of noise is adjusted and scaled.
34 
35 Scaled Multi-Octave Simplex noise functions scale the values returned from the
36 traditional (-1,1) range to whichever range is passed to the function.
37 
38 In many cases, you may think you only need a 1D noise function, but in practice
39 2D  is almost always better.  For instance, if you're using the current frame
40 number  as the parameter for the noise, all objects will end up with the same
41 noise value  at each frame. By adding a second parameter on the second
42 dimension, you can ensure that each gets a unique noise value and they don't
43 all look identical.
44 */
45 
46 // Multi-octave Simplex noise
47 // For each octave, a higher frequency/lower amplitude function will be added to the original.
48 // The higher the persistence [0-1], the more of each succeeding octave will be added.
49 float octave_noise_2d( float octaves,
50                        float persistence,
51                        float scale,
52                        float x,
53                        float y );
54 float octave_noise_3d( float octaves,
55                        float persistence,
56                        float scale,
57                        float x,
58                        float y,
59                        float z );
60 float octave_noise_4d( float octaves,
61                        float persistence,
62                        float scale,
63                        float x,
64                        float y,
65                        float z,
66                        float w );
67 
68 // Scaled Multi-octave Simplex noise
69 // The result will be between the two parameters passed.
70 float scaled_octave_noise_2d( float octaves,
71                               float persistence,
72                               float scale,
73                               float loBound,
74                               float hiBound,
75                               float x,
76                               float y );
77 float scaled_octave_noise_3d( float octaves,
78                               float persistence,
79                               float scale,
80                               float loBound,
81                               float hiBound,
82                               float x,
83                               float y,
84                               float z );
85 float scaled_octave_noise_4d( float octaves,
86                               float persistence,
87                               float scale,
88                               float loBound,
89                               float hiBound,
90                               float x,
91                               float y,
92                               float z,
93                               float w );
94 
95 // Scaled Raw Simplex noise
96 // The result will be between the two parameters passed.
97 float scaled_raw_noise_2d( float loBound,
98                            float hiBound,
99                            float x,
100                            float y );
101 float scaled_raw_noise_3d( float loBound,
102                            float hiBound,
103                            float x,
104                            float y,
105                            float z );
106 float scaled_raw_noise_4d( float loBound,
107                            float hiBound,
108                            float x,
109                            float y,
110                            float z,
111                            float w );
112 
113 // Raw Simplex noise - a single noise value.
114 float raw_noise_2d( float x, float y );
115 float raw_noise_3d( float x, float y, float z );
116 float raw_noise_4d( float x, float y, float, float w );
117 
118 int fastfloor( float x );
119 
120 float dot( const int *g, float x, float y );
121 float dot( const int *g, float x, float y, float z );
122 float dot( const int *g, float x, float y, float z, float w );
123 
124 // The gradients are the midpoints of the vertices of a cube.
125 static const int grad3[12][3] = {
126     {1, 1, 0}, {-1, 1, 0}, {1, -1, 0}, {-1, -1, 0},
127     {1, 0, 1}, {-1, 0, 1}, {1, 0, -1}, {-1, 0, -1},
128     {0, 1, 1}, {0, -1, 1}, {0, 1, -1}, {0, -1, -1}
129 };
130 
131 // The gradients are the midpoints of the vertices of a hypercube.
132 static const int grad4[32][4] = {
133     {0, 1, 1, 1},  {0, 1, 1, -1},  {0, 1, -1, 1},  {0, 1, -1, -1},
134     {0, -1, 1, 1}, {0, -1, 1, -1}, {0, -1, -1, 1}, {0, -1, -1, -1},
135     {1, 0, 1, 1},  {1, 0, 1, -1},  {1, 0, -1, 1},  {1, 0, -1, -1},
136     {-1, 0, 1, 1}, {-1, 0, 1, -1}, {-1, 0, -1, 1}, {-1, 0, -1, -1},
137     {1, 1, 0, 1},  {1, 1, 0, -1},  {1, -1, 0, 1},  {1, -1, 0, -1},
138     {-1, 1, 0, 1}, {-1, 1, 0, -1}, {-1, -1, 0, 1}, {-1, -1, 0, -1},
139     {1, 1, 1, 0},  {1, 1, -1, 0},  {1, -1, 1, 0},  {1, -1, -1, 0},
140     {-1, 1, 1, 0}, {-1, 1, -1, 0}, {-1, -1, 1, 0}, {-1, -1, -1, 0}
141 };
142 
143 // Permutation table.  The same list is repeated twice.
144 static const int perm[512] = {
145     151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142,
146     8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117,
147     35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71,
148     134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41,
149     55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89,
150     18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226,
151     250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182,
152     189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43,
153     172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97,
154     228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239,
155     107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
156     138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180,
157 
158     151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142,
159     8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117,
160     35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71,
161     134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41,
162     55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89,
163     18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226,
164     250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182,
165     189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43,
166     172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97,
167     228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239,
168     107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
169     138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180
170 };
171 
172 // A lookup table to traverse the simplex around a given point in 4D.
173 static const int simplex[64][4] = {
174     {0, 1, 2, 3}, {0, 1, 3, 2}, {0, 0, 0, 0}, {0, 2, 3, 1}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {1, 2, 3, 0},
175     {0, 2, 1, 3}, {0, 0, 0, 0}, {0, 3, 1, 2}, {0, 3, 2, 1}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {1, 3, 2, 0},
176     {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0},
177     {1, 2, 0, 3}, {0, 0, 0, 0}, {1, 3, 0, 2}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {2, 3, 0, 1}, {2, 3, 1, 0},
178     {1, 0, 2, 3}, {1, 0, 3, 2}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {2, 0, 3, 1}, {0, 0, 0, 0}, {2, 1, 3, 0},
179     {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0},
180     {2, 0, 1, 3}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {3, 0, 1, 2}, {3, 0, 2, 1}, {0, 0, 0, 0}, {3, 1, 2, 0},
181     {2, 1, 0, 3}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {3, 1, 0, 2}, {0, 0, 0, 0}, {3, 2, 0, 1}, {3, 2, 1, 0}
182 };
183 
184 #endif // CATA_SRC_SIMPLEXNOISE_H
185