1 /*
2 * This implementation of the noise functions was ported from the Java
3 * implementation by Jerry Huxtable (http://www.jhlabs.com) under
4 * Apache License 2.0 (see http://jhlabs.com/ip/filters/download.html)
5 *
6 * Original header:
7 *
8 * Copyright 2006 Jerry Huxtable
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
21 */
22
23 #include "rsNoise.h"
24
25 #include <math.h>
26 #include <stdlib.h>
27 #include <time.h>
28
29 namespace android {
30 namespace renderscript {
31
32 #define B 0x100
33 #define BM 0xff
34 #define N 0x1000
35
36 static int p[B + B + 2];
37 static float g3[B + B + 2][3];
38 static float g2[B + B + 2][2];
39 static float g1[B + B + 2];
40 static bool noise_start = true;
41
42 #define lerpf(start, stop, amount) start + (stop - start) * amount
43
noise_sCurve(float t)44 static inline float noise_sCurve(float t)
45 {
46 return t * t * (3.0f - 2.0f * t);
47 }
48
SC_normalizef2(float v[])49 inline void SC_normalizef2(float v[])
50 {
51 float s = (float)sqrtf(v[0] * v[0] + v[1] * v[1]);
52 v[0] = v[0] / s;
53 v[1] = v[1] / s;
54 }
55
SC_normalizef3(float v[])56 inline void SC_normalizef3(float v[])
57 {
58 float s = (float)sqrtf(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
59 v[0] = v[0] / s;
60 v[1] = v[1] / s;
61 v[2] = v[2] / s;
62 }
63
noise_init()64 static void noise_init()
65 {
66 int i, j, k;
67
68 for (i = 0; i < B; i++) {
69 p[i] = i;
70
71 g1[i] = (float)((rand() % (B + B)) - B) / B;
72
73 for (j = 0; j < 2; j++)
74 g2[i][j] = (float)((rand() % (B + B)) - B) / B;
75 SC_normalizef2(g2[i]);
76
77 for (j = 0; j < 3; j++)
78 g3[i][j] = (float)((rand() % (B + B)) - B) / B;
79 SC_normalizef3(g3[i]);
80 }
81
82 for (i = B-1; i >= 0; i--) {
83 k = p[i];
84 p[i] = p[j = rand() % B];
85 p[j] = k;
86 }
87
88 for (i = 0; i < B + 2; i++) {
89 p[B + i] = p[i];
90 g1[B + i] = g1[i];
91 for (j = 0; j < 2; j++)
92 g2[B + i][j] = g2[i][j];
93 for (j = 0; j < 3; j++)
94 g3[B + i][j] = g3[i][j];
95 }
96 }
97
SC_noisef(float x)98 float SC_noisef(float x)
99 {
100 srand(time(NULL));
101 int bx0, bx1;
102 float rx0, rx1, sx, t, u, v;
103
104 if (noise_start) {
105 noise_start = false;
106 noise_init();
107 }
108
109 t = x + N;
110 bx0 = ((int)t) & BM;
111 bx1 = (bx0+1) & BM;
112 rx0 = t - (int)t;
113 rx1 = rx0 - 1.0f;
114
115 sx = noise_sCurve(rx0);
116
117 u = rx0 * g1[p[bx0]];
118 v = rx1 * g1[p[bx1]];
119 return 2.3f * lerpf(u, v, sx);
120 }
121
SC_noisef2(float x,float y)122 float SC_noisef2(float x, float y)
123 {
124 srand(time(NULL));
125 int bx0, bx1, by0, by1, b00, b10, b01, b11;
126 float rx0, rx1, ry0, ry1, sx, sy, a, b, t, u, v;
127 float *q;
128 int i, j;
129
130 if (noise_start) {
131 noise_start = false;
132 noise_init();
133 }
134
135 t = x + N;
136 bx0 = ((int)t) & BM;
137 bx1 = (bx0+1) & BM;
138 rx0 = t - (int)t;
139 rx1 = rx0 - 1.0f;
140
141 t = y + N;
142 by0 = ((int)t) & BM;
143 by1 = (by0+1) & BM;
144 ry0 = t - (int)t;
145 ry1 = ry0 - 1.0f;
146
147 i = p[bx0];
148 j = p[bx1];
149
150 b00 = p[i + by0];
151 b10 = p[j + by0];
152 b01 = p[i + by1];
153 b11 = p[j + by1];
154
155 sx = noise_sCurve(rx0);
156 sy = noise_sCurve(ry0);
157
158 q = g2[b00]; u = rx0 * q[0] + ry0 * q[1];
159 q = g2[b10]; v = rx1 * q[0] + ry0 * q[1];
160 a = lerpf(u, v, sx);
161
162 q = g2[b01]; u = rx0 * q[0] + ry1 * q[1];
163 q = g2[b11]; v = rx1 * q[0] + ry1 * q[1];
164 b = lerpf(u, v, sx);
165
166 return 1.5f*lerpf(a, b, sy);
167 }
168
SC_noisef3(float x,float y,float z)169 float SC_noisef3(float x, float y, float z)
170 {
171 srand(time(NULL));
172 int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
173 float rx0, rx1, ry0, ry1, rz0, rz1, sy, sz, a, b, c, d, t, u, v;
174 float *q;
175 int i, j;
176
177 if (noise_start) {
178 noise_start = false;
179 noise_init();
180 }
181
182 t = x + N;
183 bx0 = ((int)t) & BM;
184 bx1 = (bx0+1) & BM;
185 rx0 = t - (int)t;
186 rx1 = rx0 - 1.0f;
187
188 t = y + N;
189 by0 = ((int)t) & BM;
190 by1 = (by0+1) & BM;
191 ry0 = t - (int)t;
192 ry1 = ry0 - 1.0f;
193
194 t = z + N;
195 bz0 = ((int)t) & BM;
196 bz1 = (bz0+1) & BM;
197 rz0 = t - (int)t;
198 rz1 = rz0 - 1.0f;
199
200 i = p[bx0];
201 j = p[bx1];
202
203 b00 = p[i + by0];
204 b10 = p[j + by0];
205 b01 = p[i + by1];
206 b11 = p[j + by1];
207
208 t = noise_sCurve(rx0);
209 sy = noise_sCurve(ry0);
210 sz = noise_sCurve(rz0);
211
212 q = g3[b00 + bz0]; u = rx0 * q[0] + ry0 * q[1] + rz0 * q[2];
213 q = g3[b10 + bz0]; v = rx1 * q[0] + ry0 * q[1] + rz0 * q[2];
214 a = lerpf(u, v, t);
215
216 q = g3[b01 + bz0]; u = rx0 * q[0] + ry1 * q[1] + rz0 * q[2];
217 q = g3[b11 + bz0]; v = rx1 * q[0] + ry1 * q[1] + rz0 * q[2];
218 b = lerpf(u, v, t);
219
220 c = lerpf(a, b, sy);
221
222 q = g3[b00 + bz1]; u = rx0 * q[0] + ry0 * q[1] + rz1 * q[2];
223 q = g3[b10 + bz1]; v = rx1 * q[0] + ry0 * q[1] + rz1 * q[2];
224 a = lerpf(u, v, t);
225
226 q = g3[b01 + bz1]; u = rx0 * q[0] + ry1 * q[1] + rz1 * q[2];
227 q = g3[b11 + bz1]; v = rx1 * q[0] + ry1 * q[1] + rz1 * q[2];
228 b = lerpf(u, v, t);
229
230 d = lerpf(a, b, sy);
231
232 return 1.5f*lerpf(c, d, sz);
233 }
234
SC_turbulencef2(float x,float y,float octaves)235 float SC_turbulencef2(float x, float y, float octaves)
236 {
237 srand(time(NULL));
238 float t = 0.0f;
239
240 for (float f = 1.0f; f <= octaves; f *= 2)
241 t += fabs(SC_noisef2(f * x, f * y)) / f;
242 return t;
243 }
244
SC_turbulencef3(float x,float y,float z,float octaves)245 float SC_turbulencef3(float x, float y, float z, float octaves)
246 {
247 srand(time(NULL));
248 float t = 0.0f;
249
250 for (float f = 1.0f; f <= octaves; f *= 2)
251 t += fabs(SC_noisef3(f * x, f * y, f * z)) / f;
252 return t;
253 }
254
255 }
256 }