UI: Avoid file browser directory change if path didn't change
[blender.git] / intern / cycles / kernel / svm / svm_noise.h
1 /*
2  * Adapted from Open Shading Language with this license:
3  *
4  * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
5  * All Rights Reserved.
6  *
7  * Modifications Copyright 2011, Blender Foundation.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions are
11  * met:
12  * * Redistributions of source code must retain the above copyright
13  *   notice, this list of conditions and the following disclaimer.
14  * * Redistributions in binary form must reproduce the above copyright
15  *   notice, this list of conditions and the following disclaimer in the
16  *   documentation and/or other materials provided with the distribution.
17  * * Neither the name of Sony Pictures Imageworks nor the names of its
18  *   contributors may be used to endorse or promote products derived from
19  *   this software without specific prior written permission.
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 CCL_NAMESPACE_BEGIN
34
35 /* **** Perlin Noise **** */
36
37 ccl_device float fade(float t)
38 {
39   return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
40 }
41
42 ccl_device_inline float negate_if(float val, int condition)
43 {
44   return (condition) ? -val : val;
45 }
46
47 ccl_device float grad1(int hash, float x)
48 {
49   int h = hash & 15;
50   float g = 1 + (h & 7);
51   return negate_if(g, h & 8) * x;
52 }
53
54 ccl_device_noinline_cpu float perlin_1d(float x)
55 {
56   int X;
57   float fx = floorfrac(x, &X);
58   float u = fade(fx);
59
60   return mix(grad1(hash_uint(X), fx), grad1(hash_uint(X + 1), fx - 1.0f), u);
61 }
62
63 /* 2D, 3D, and 4D noise can be accelerated using SSE, so we first check if
64  * SSE is supported, that is, if __KERNEL_SSE2__ is defined. If it is not
65  * supported, we do a standard implementation, but if it is supported, we
66  * do an implementation using SSE intrinsics.
67  */
68 #ifndef __KERNEL_SSE2__
69
70 /* ** Standard Implementation ** */
71
72 /* Bilinear Interpolation:
73  *
74  * v2          v3
75  *  @ + + + + @       y
76  *  +         +       ^
77  *  +         +       |
78  *  +         +       |
79  *  @ + + + + @       @------> x
80  * v0          v1
81  *
82  */
83 ccl_device float bi_mix(float v0, float v1, float v2, float v3, float x, float y)
84 {
85   float x1 = 1.0f - x;
86   return (1.0f - y) * (v0 * x1 + v1 * x) + y * (v2 * x1 + v3 * x);
87 }
88
89 /* Trilinear Interpolation:
90  *
91  *   v6               v7
92  *     @ + + + + + + @
93  *     +\            +\
94  *     + \           + \
95  *     +  \          +  \
96  *     +   \ v4      +   \ v5
97  *     +    @ + + + +++ + @          z
98  *     +    +        +    +      y   ^
99  *  v2 @ + +++ + + + @ v3 +       \  |
100  *      \   +         \   +        \ |
101  *       \  +          \  +         \|
102  *        \ +           \ +          +---------> x
103  *         \+            \+
104  *          @ + + + + + + @
105  *        v0               v1
106  */
107 ccl_device float tri_mix(float v0,
108                          float v1,
109                          float v2,
110                          float v3,
111                          float v4,
112                          float v5,
113                          float v6,
114                          float v7,
115                          float x,
116                          float y,
117                          float z)
118 {
119   float x1 = 1.0f - x;
120   float y1 = 1.0f - y;
121   float z1 = 1.0f - z;
122   return z1 * (y1 * (v0 * x1 + v1 * x) + y * (v2 * x1 + v3 * x)) +
123          z * (y1 * (v4 * x1 + v5 * x) + y * (v6 * x1 + v7 * x));
124 }
125
126 ccl_device float quad_mix(float v0,
127                           float v1,
128                           float v2,
129                           float v3,
130                           float v4,
131                           float v5,
132                           float v6,
133                           float v7,
134                           float v8,
135                           float v9,
136                           float v10,
137                           float v11,
138                           float v12,
139                           float v13,
140                           float v14,
141                           float v15,
142                           float x,
143                           float y,
144                           float z,
145                           float w)
146 {
147   return mix(tri_mix(v0, v1, v2, v3, v4, v5, v6, v7, x, y, z),
148              tri_mix(v8, v9, v10, v11, v12, v13, v14, v15, x, y, z),
149              w);
150 }
151
152 ccl_device float grad2(int hash, float x, float y)
153 {
154   int h = hash & 7;
155   float u = h < 4 ? x : y;
156   float v = 2.0f * (h < 4 ? y : x);
157   return negate_if(u, h & 1) + negate_if(v, h & 2);
158 }
159
160 ccl_device float grad3(int hash, float x, float y, float z)
161 {
162   int h = hash & 15;
163   float u = h < 8 ? x : y;
164   float vt = ((h == 12) || (h == 14)) ? x : z;
165   float v = h < 4 ? y : vt;
166   return negate_if(u, h & 1) + negate_if(v, h & 2);
167 }
168
169 ccl_device float grad4(int hash, float x, float y, float z, float w)
170 {
171   int h = hash & 31;
172   float u = h < 24 ? x : y;
173   float v = h < 16 ? y : z;
174   float s = h < 8 ? z : w;
175   return negate_if(u, h & 1) + negate_if(v, h & 2) + negate_if(s, h & 4);
176 }
177
178 ccl_device_noinline_cpu float perlin_2d(float x, float y)
179 {
180   int X;
181   int Y;
182
183   float fx = floorfrac(x, &X);
184   float fy = floorfrac(y, &Y);
185
186   float u = fade(fx);
187   float v = fade(fy);
188
189   float r = bi_mix(grad2(hash_uint2(X, Y), fx, fy),
190                    grad2(hash_uint2(X + 1, Y), fx - 1.0f, fy),
191                    grad2(hash_uint2(X, Y + 1), fx, fy - 1.0f),
192                    grad2(hash_uint2(X + 1, Y + 1), fx - 1.0f, fy - 1.0f),
193                    u,
194                    v);
195
196   return r;
197 }
198
199 ccl_device_noinline_cpu float perlin_3d(float x, float y, float z)
200 {
201   int X;
202   int Y;
203   int Z;
204
205   float fx = floorfrac(x, &X);
206   float fy = floorfrac(y, &Y);
207   float fz = floorfrac(z, &Z);
208
209   float u = fade(fx);
210   float v = fade(fy);
211   float w = fade(fz);
212
213   float r = tri_mix(grad3(hash_uint3(X, Y, Z), fx, fy, fz),
214                     grad3(hash_uint3(X + 1, Y, Z), fx - 1.0f, fy, fz),
215                     grad3(hash_uint3(X, Y + 1, Z), fx, fy - 1.0f, fz),
216                     grad3(hash_uint3(X + 1, Y + 1, Z), fx - 1.0f, fy - 1.0f, fz),
217                     grad3(hash_uint3(X, Y, Z + 1), fx, fy, fz - 1.0f),
218                     grad3(hash_uint3(X + 1, Y, Z + 1), fx - 1.0f, fy, fz - 1.0f),
219                     grad3(hash_uint3(X, Y + 1, Z + 1), fx, fy - 1.0f, fz - 1.0f),
220                     grad3(hash_uint3(X + 1, Y + 1, Z + 1), fx - 1.0f, fy - 1.0f, fz - 1.0f),
221                     u,
222                     v,
223                     w);
224   return r;
225 }
226
227 ccl_device_noinline_cpu float perlin_4d(float x, float y, float z, float w)
228 {
229   int X;
230   int Y;
231   int Z;
232   int W;
233
234   float fx = floorfrac(x, &X);
235   float fy = floorfrac(y, &Y);
236   float fz = floorfrac(z, &Z);
237   float fw = floorfrac(w, &W);
238
239   float u = fade(fx);
240   float v = fade(fy);
241   float t = fade(fz);
242   float s = fade(fw);
243
244   float r = quad_mix(
245       grad4(hash_uint4(X, Y, Z, W), fx, fy, fz, fw),
246       grad4(hash_uint4(X + 1, Y, Z, W), fx - 1.0f, fy, fz, fw),
247       grad4(hash_uint4(X, Y + 1, Z, W), fx, fy - 1.0f, fz, fw),
248       grad4(hash_uint4(X + 1, Y + 1, Z, W), fx - 1.0f, fy - 1.0f, fz, fw),
249       grad4(hash_uint4(X, Y, Z + 1, W), fx, fy, fz - 1.0f, fw),
250       grad4(hash_uint4(X + 1, Y, Z + 1, W), fx - 1.0f, fy, fz - 1.0f, fw),
251       grad4(hash_uint4(X, Y + 1, Z + 1, W), fx, fy - 1.0f, fz - 1.0f, fw),
252       grad4(hash_uint4(X + 1, Y + 1, Z + 1, W), fx - 1.0f, fy - 1.0f, fz - 1.0f, fw),
253       grad4(hash_uint4(X, Y, Z, W + 1), fx, fy, fz, fw - 1.0f),
254       grad4(hash_uint4(X + 1, Y, Z, W + 1), fx - 1.0f, fy, fz, fw - 1.0f),
255       grad4(hash_uint4(X, Y + 1, Z, W + 1), fx, fy - 1.0f, fz, fw - 1.0f),
256       grad4(hash_uint4(X + 1, Y + 1, Z, W + 1), fx - 1.0f, fy - 1.0f, fz, fw - 1.0f),
257       grad4(hash_uint4(X, Y, Z + 1, W + 1), fx, fy, fz - 1.0f, fw - 1.0f),
258       grad4(hash_uint4(X + 1, Y, Z + 1, W + 1), fx - 1.0f, fy, fz - 1.0f, fw - 1.0f),
259       grad4(hash_uint4(X, Y + 1, Z + 1, W + 1), fx, fy - 1.0f, fz - 1.0f, fw - 1.0f),
260       grad4(hash_uint4(X + 1, Y + 1, Z + 1, W + 1), fx - 1.0f, fy - 1.0f, fz - 1.0f, fw - 1.0f),
261       u,
262       v,
263       t,
264       s);
265
266   return r;
267 }
268
269 #else
270
271 /* ** SSE Implementation ** */
272
273 /* SSE Bilinear Interpolation:
274  *
275  * The function takes two ssef inputs:
276  * - p : Contains the values at the points (v0, v1, v2, v3).
277  * - f : Contains the values (x, y, _, _). The third and fourth values are unused.
278  *
279  * The interpolation is done in two steps:
280  * 1. Interpolate (v0, v1) and (v2, v3) along the x axis to get g (g0, g1).
281  *    (v2, v3) is generated by moving v2 and v3 to the first and second
282  *    places of the ssef using the shuffle mask <2, 3, 2, 3>. The third and
283  *    fourth values are unused.
284  * 2. Interpolate g0 and g1 along the y axis to get the final value.
285  *    g1 is generated by populating an ssef with the second value of g.
286  *    Only the first value is important in the final ssef.
287  *
288  * v1          v3          g1
289  *  @ + + + + @            @                    y
290  *  +         +     (1)    +    (2)             ^
291  *  +         +     --->   +    --->   final    |
292  *  +         +            +                    |
293  *  @ + + + + @            @                    @------> x
294  * v0          v2          g0
295  *
296  */
297 ccl_device_inline ssef bi_mix(ssef p, ssef f)
298 {
299   ssef g = mix(p, shuffle<2, 3, 2, 3>(p), shuffle<0>(f));
300   return mix(g, shuffle<1>(g), shuffle<1>(f));
301 }
302
303 /* SSE Trilinear Interpolation:
304  *
305  * The function takes three ssef inputs:
306  * - p : Contains the values at the points (v0, v1, v2, v3).
307  * - q : Contains the values at the points (v4, v5, v6, v7).
308  * - f : Contains the values (x, y, z, _). The fourth value is unused.
309  *
310  * The interpolation is done in three steps:
311  * 1. Interpolate p and q along the x axis to get s (s0, s1, s2, s3).
312  * 2. Interpolate (s0, s1) and (s2, s3) along the y axis to get g (g0, g1).
313  *    (s2, s3) is generated by moving v2 and v3 to the first and second
314  *    places of the ssef using the shuffle mask <2, 3, 2, 3>. The third and
315  *    fourth values are unused.
316  * 3. Interpolate g0 and g1 along the z axis to get the final value.
317  *    g1 is generated by populating an ssef with the second value of g.
318  *    Only the first value is important in the final ssef.
319  *
320  *   v3               v7
321  *     @ + + + + + + @               s3 @
322  *     +\            +\                 +\
323  *     + \           + \                + \
324  *     +  \          +  \               +  \             g1
325  *     +   \ v1      +   \ v5           +   \ s1         @
326  *     +    @ + + + +++ + @             +    @           +                     z
327  *     +    +        +    +    (1)      +    +    (2)    +   (3)           y   ^
328  *  v2 @ + +++ + + + @ v6 +    --->  s2 @    +    --->   +   --->  final    \  |
329  *      \   +         \   +              \   +           +                   \ |
330  *       \  +          \  +               \  +           +                    \|
331  *        \ +           \ +                \ +           @                     +---------> x
332  *         \+            \+                 \+           g0
333  *          @ + + + + + + @                  @
334  *        v0               v4                 s0
335  */
336 ccl_device_inline ssef tri_mix(ssef p, ssef q, ssef f)
337 {
338   ssef s = mix(p, q, shuffle<0>(f));
339   ssef g = mix(s, shuffle<2, 3, 2, 3>(s), shuffle<1>(f));
340   return mix(g, shuffle<1>(g), shuffle<2>(f));
341 }
342
343 /* SSE Quadrilinear Interpolation:
344  *
345  * Quadrilinear interpolation is as simple as a linear interpolation
346  * between two trilinear interpolations.
347  *
348  */
349 ccl_device_inline ssef quad_mix(ssef p, ssef q, ssef r, ssef s, ssef f)
350 {
351   return mix(tri_mix(p, q, f), tri_mix(r, s, f), shuffle<3>(f));
352 }
353
354 ccl_device_inline ssef fade(const ssef &t)
355 {
356   ssef a = madd(t, 6.0f, -15.0f);
357   ssef b = madd(t, a, 10.0f);
358   return (t * t) * (t * b);
359 }
360
361 /* Negate val if the nth bit of h is 1. */
362 #  define negate_if_nth_bit(val, h, n) ((val) ^ cast(((h) & (1 << (n))) << (31 - (n))))
363
364 ccl_device_inline ssef grad(const ssei &hash, const ssef &x, const ssef &y)
365 {
366   ssei h = hash & 7;
367   ssef u = select(h < 4, x, y);
368   ssef v = 2.0f * select(h < 4, y, x);
369   return negate_if_nth_bit(u, h, 0) + negate_if_nth_bit(v, h, 1);
370 }
371
372 ccl_device_inline ssef grad(const ssei &hash, const ssef &x, const ssef &y, const ssef &z)
373 {
374   ssei h = hash & 15;
375   ssef u = select(h < 8, x, y);
376   ssef vt = select((h == 12) | (h == 14), x, z);
377   ssef v = select(h < 4, y, vt);
378   return negate_if_nth_bit(u, h, 0) + negate_if_nth_bit(v, h, 1);
379 }
380
381 ccl_device_inline ssef
382 grad(const ssei &hash, const ssef &x, const ssef &y, const ssef &z, const ssef &w)
383 {
384   ssei h = hash & 31;
385   ssef u = select(h < 24, x, y);
386   ssef v = select(h < 16, y, z);
387   ssef s = select(h < 8, z, w);
388   return negate_if_nth_bit(u, h, 0) + negate_if_nth_bit(v, h, 1) + negate_if_nth_bit(s, h, 2);
389 }
390
391 /* We use SSE to compute and interpolate 4 gradients at once:
392  *
393  *    Point  Offset from v0
394  *     v0       (0, 0)
395  *     v1       (0, 1)
396  *     v2       (1, 0)    (0, 1, 0, 1) = shuffle<0, 2, 0, 2>(shuffle<1, 1, 1, 1>(V, V + 1))
397  *     v3       (1, 1)         ^
398  *               |  |__________|       (0, 0, 1, 1) = shuffle<0, 0, 0, 0>(V, V + 1)
399  *               |                          ^
400  *               |__________________________|
401  *
402  */
403 ccl_device_noinline float perlin_2d(float x, float y)
404 {
405   ssei XY;
406   ssef fxy = floorfrac(ssef(x, y, 0.0f, 0.0f), &XY);
407   ssef uv = fade(fxy);
408
409   ssei XY1 = XY + 1;
410   ssei X = shuffle<0, 0, 0, 0>(XY, XY1);
411   ssei Y = shuffle<0, 2, 0, 2>(shuffle<1, 1, 1, 1>(XY, XY1));
412
413   ssei h = hash_ssei2(X, Y);
414
415   ssef fxy1 = fxy - 1.0f;
416   ssef fx = shuffle<0, 0, 0, 0>(fxy, fxy1);
417   ssef fy = shuffle<0, 2, 0, 2>(shuffle<1, 1, 1, 1>(fxy, fxy1));
418
419   ssef g = grad(h, fx, fy);
420
421   return extract<0>(bi_mix(g, uv));
422 }
423
424 /* We use SSE to compute and interpolate 4 gradients at once. Since we have 8
425  * gradients in 3D, we need to compute two sets of gradients at the points:
426  *
427  *    Point  Offset from v0
428  *     v0      (0, 0, 0)
429  *     v1      (0, 0, 1)
430  *     v2      (0, 1, 0)    (0, 1, 0, 1) = shuffle<0, 2, 0, 2>(shuffle<2, 2, 2, 2>(V, V + 1))
431  *     v3      (0, 1, 1)         ^
432  *                 |  |__________|       (0, 0, 1, 1) = shuffle<1, 1, 1, 1>(V, V + 1)
433  *                 |                          ^
434  *                 |__________________________|
435  *
436  *    Point  Offset from v0
437  *     v4      (1, 0, 0)
438  *     v5      (1, 0, 1)
439  *     v6      (1, 1, 0)
440  *     v7      (1, 1, 1)
441  *
442  */
443 ccl_device_noinline float perlin_3d(float x, float y, float z)
444 {
445   ssei XYZ;
446   ssef fxyz = floorfrac(ssef(x, y, z, 0.0f), &XYZ);
447   ssef uvw = fade(fxyz);
448
449   ssei XYZ1 = XYZ + 1;
450   ssei Y = shuffle<1, 1, 1, 1>(XYZ, XYZ1);
451   ssei Z = shuffle<0, 2, 0, 2>(shuffle<2, 2, 2, 2>(XYZ, XYZ1));
452
453   ssei h1 = hash_ssei3(shuffle<0>(XYZ), Y, Z);
454   ssei h2 = hash_ssei3(shuffle<0>(XYZ1), Y, Z);
455
456   ssef fxyz1 = fxyz - 1.0f;
457   ssef fy = shuffle<1, 1, 1, 1>(fxyz, fxyz1);
458   ssef fz = shuffle<0, 2, 0, 2>(shuffle<2, 2, 2, 2>(fxyz, fxyz1));
459
460   ssef g1 = grad(h1, shuffle<0>(fxyz), fy, fz);
461   ssef g2 = grad(h2, shuffle<0>(fxyz1), fy, fz);
462
463   return extract<0>(tri_mix(g1, g2, uvw));
464 }
465
466 /* We use SSE to compute and interpolate 4 gradients at once. Since we have 16
467  * gradients in 4D, we need to compute four sets of gradients at the points:
468  *
469  *    Point  Offset from v0
470  *     v0     (0, 0, 0, 0)
471  *     v1     (0, 0, 1, 0)
472  *     v2     (0, 1, 0, 0)  (0, 1, 0, 1) = shuffle<0, 2, 0, 2>(shuffle<2, 2, 2, 2>(V, V + 1))
473  *     v3     (0, 1, 1, 0)    ^
474  *                |  |________|    (0, 0, 1, 1) = shuffle<1, 1, 1, 1>(V, V + 1)
475  *                |                       ^
476  *                |_______________________|
477  *
478  *    Point  Offset from v0
479  *     v4     (1, 0, 0, 0)
480  *     v5     (1, 0, 1, 0)
481  *     v6     (1, 1, 0, 0)
482  *     v7     (1, 1, 1, 0)
483  *
484  *    Point  Offset from v0
485  *     v8     (0, 0, 0, 1)
486  *     v9     (0, 0, 1, 1)
487  *     v10    (0, 1, 0, 1)
488  *     v11    (0, 1, 1, 1)
489  *
490  *    Point  Offset from v0
491  *     v12    (1, 0, 0, 1)
492  *     v13    (1, 0, 1, 1)
493  *     v14    (1, 1, 0, 1)
494  *     v15    (1, 1, 1, 1)
495  *
496  */
497 ccl_device_noinline float perlin_4d(float x, float y, float z, float w)
498 {
499   ssei XYZW;
500   ssef fxyzw = floorfrac(ssef(x, y, z, w), &XYZW);
501   ssef uvws = fade(fxyzw);
502
503   ssei XYZW1 = XYZW + 1;
504   ssei Y = shuffle<1, 1, 1, 1>(XYZW, XYZW1);
505   ssei Z = shuffle<0, 2, 0, 2>(shuffle<2, 2, 2, 2>(XYZW, XYZW1));
506
507   ssei h1 = hash_ssei4(shuffle<0>(XYZW), Y, Z, shuffle<3>(XYZW));
508   ssei h2 = hash_ssei4(shuffle<0>(XYZW1), Y, Z, shuffle<3>(XYZW));
509
510   ssei h3 = hash_ssei4(shuffle<0>(XYZW), Y, Z, shuffle<3>(XYZW1));
511   ssei h4 = hash_ssei4(shuffle<0>(XYZW1), Y, Z, shuffle<3>(XYZW1));
512
513   ssef fxyzw1 = fxyzw - 1.0f;
514   ssef fy = shuffle<1, 1, 1, 1>(fxyzw, fxyzw1);
515   ssef fz = shuffle<0, 2, 0, 2>(shuffle<2, 2, 2, 2>(fxyzw, fxyzw1));
516
517   ssef g1 = grad(h1, shuffle<0>(fxyzw), fy, fz, shuffle<3>(fxyzw));
518   ssef g2 = grad(h2, shuffle<0>(fxyzw1), fy, fz, shuffle<3>(fxyzw));
519
520   ssef g3 = grad(h3, shuffle<0>(fxyzw), fy, fz, shuffle<3>(fxyzw1));
521   ssef g4 = grad(h4, shuffle<0>(fxyzw1), fy, fz, shuffle<3>(fxyzw1));
522
523   return extract<0>(quad_mix(g1, g2, g3, g4, uvws));
524 }
525 #endif
526
527 /* Remap the output of noise to a predictable range [-1, 1].
528  * The scale values were computed experimentally by the OSL developers.
529  */
530
531 ccl_device_inline float noise_scale1(float result)
532 {
533   return 0.2500f * result;
534 }
535
536 ccl_device_inline float noise_scale2(float result)
537 {
538   return 0.6616f * result;
539 }
540
541 ccl_device_inline float noise_scale3(float result)
542 {
543   return 0.9820f * result;
544 }
545
546 ccl_device_inline float noise_scale4(float result)
547 {
548   return 0.8344f * result;
549 }
550
551 /* Safe Signed And Unsigned Noise */
552
553 ccl_device_inline float snoise_1d(float p)
554 {
555   return noise_scale1(ensure_finite(perlin_1d(p)));
556 }
557
558 ccl_device_inline float noise_1d(float p)
559 {
560   return 0.5f * snoise_1d(p) + 0.5f;
561 }
562
563 ccl_device_inline float snoise_2d(float2 p)
564 {
565   return noise_scale2(ensure_finite(perlin_2d(p.x, p.y)));
566 }
567
568 ccl_device_inline float noise_2d(float2 p)
569 {
570   return 0.5f * snoise_2d(p) + 0.5f;
571 }
572
573 ccl_device_inline float snoise_3d(float3 p)
574 {
575   return noise_scale3(ensure_finite(perlin_3d(p.x, p.y, p.z)));
576 }
577
578 ccl_device_inline float noise_3d(float3 p)
579 {
580   return 0.5f * snoise_3d(p) + 0.5f;
581 }
582
583 ccl_device_inline float snoise_4d(float4 p)
584 {
585   return noise_scale4(ensure_finite(perlin_4d(p.x, p.y, p.z, p.w)));
586 }
587
588 ccl_device_inline float noise_4d(float4 p)
589 {
590   return 0.5f * snoise_4d(p) + 0.5f;
591 }
592
593 CCL_NAMESPACE_END