2 * Mesa 3-D graphics library
5 * Copyright (C) 2006 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * Copyright (c) 2003-2005, Stefan Gustavson
29 * Contact: stegu@itn.liu.se
33 \brief C implementation of Perlin Simplex Noise over 1,2,3, and 4 dimensions.
34 \author Stefan Gustavson (stegu@itn.liu.se)
38 * This implementation is "Simplex Noise" as presented by
39 * Ken Perlin at a relatively obscure and not often cited course
40 * session "Real-Time Shading" at Siggraph 2001 (before real
41 * time shading actually took on), under the title "hardware noise".
42 * The 3D function is numerically equivalent to his Java reference
43 * code available in the PDF course notes, although I re-implemented
44 * it from scratch to get more readable code. The 1D, 2D and 4D cases
45 * were implemented from scratch by me from Ken Perlin's text.
47 * This file has no dependencies on any other file, not even its own
48 * header file. The header file is made for use by external code only.
53 #include "slang_library_noise.h"
55 #define FASTFLOOR(x) ( ((x)>0) ? ((int)x) : (((int)x)-1) )
58 * ---------------------------------------------------------------------
63 * Permutation table. This is just a random jumble of all numbers 0-255,
64 * repeated twice to avoid wrapping the index at 255 for each lookup.
65 * This needs to be exactly the same for all instances on all platforms,
66 * so it's easiest to just keep it as static explicit data.
67 * This also removes the need for any initialisation of this class.
69 * Note that making this an int[] instead of a char[] might make the
70 * code run faster on platforms with a high penalty for unaligned single
71 * byte addressing. Intel x86 is generally single-byte-friendly, but
72 * some other CPUs are faster with 4-aligned reads.
73 * However, a char[] is smaller, which avoids cache trashing, and that
74 * is probably the most important aspect on most architectures.
75 * This array is accessed a *lot* by the noise functions.
76 * A vector-valued noise over 3D accesses it 96 times, and a
77 * float-valued 4D noise 64 times. We want this to fit in the cache!
79 unsigned char perm
[512] = {151,160,137,91,90,15,
80 131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
81 190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
82 88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
83 77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
84 102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
85 135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
86 5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
87 223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
88 129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
89 251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
90 49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
91 138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,
93 131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
94 190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
95 88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
96 77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
97 102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
98 135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
99 5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
100 223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
101 129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
102 251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
103 49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
104 138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
108 * ---------------------------------------------------------------------
112 * Helper functions to compute gradients-dot-residualvectors (1D to 4D)
113 * Note that these generate gradients of more than unit length. To make
114 * a close match with the value range of classic Perlin noise, the final
115 * noise values need to be rescaled to fit nicely within [-1,1].
116 * (The simplex noise functions as such also have different scaling.)
117 * Note also that these noise functions are the most practical and useful
118 * signed version of Perlin noise. To return values according to the
119 * RenderMan specification from the SL noise() and pnoise() functions,
120 * the noise values need to be scaled and offset to [0,1], like this:
121 * float SLnoise = (SimplexNoise1234::noise(x,y,z) + 1.0) * 0.5;
124 static float grad1( int hash
, float x
) {
126 float grad
= 1.0f
+ (h
& 7); /* Gradient value 1.0, 2.0, ..., 8.0 */
127 if (h
&8) grad
= -grad
; /* Set a random sign for the gradient */
128 return ( grad
* x
); /* Multiply the gradient with the distance */
131 static float grad2( int hash
, float x
, float y
) {
132 int h
= hash
& 7; /* Convert low 3 bits of hash code */
133 float u
= h
<4 ? x
: y
; /* into 8 simple gradient directions, */
134 float v
= h
<4 ? y
: x
; /* and compute the dot product with (x,y). */
135 return ((h
&1)? -u
: u
) + ((h
&2)? -2.0f
*v
: 2.0f
*v
);
138 static float grad3( int hash
, float x
, float y
, float z
) {
139 int h
= hash
& 15; /* Convert low 4 bits of hash code into 12 simple */
140 float u
= h
<8 ? x
: y
; /* gradient directions, and compute dot product. */
141 float v
= h
<4 ? y
: h
==12||h
==14 ? x
: z
; /* Fix repeats at h = 12 to 15 */
142 return ((h
&1)? -u
: u
) + ((h
&2)? -v
: v
);
145 static float grad4( int hash
, float x
, float y
, float z
, float t
) {
146 int h
= hash
& 31; /* Convert low 5 bits of hash code into 32 simple */
147 float u
= h
<24 ? x
: y
; /* gradient directions, and compute dot product. */
148 float v
= h
<16 ? y
: z
;
149 float w
= h
<8 ? z
: t
;
150 return ((h
&1)? -u
: u
) + ((h
&2)? -v
: v
) + ((h
&4)? -w
: w
);
153 /* A lookup table to traverse the simplex around a given point in 4D. */
154 /* Details can be found where this table is used, in the 4D noise method. */
155 /* TODO: This should not be required, backport it from Bill's GLSL code! */
156 static unsigned char simplex
[64][4] = {
157 {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},
158 {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},
159 {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},
160 {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},
161 {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},
162 {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},
163 {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},
164 {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}};
166 /* 1D simplex noise */
167 GLfloat
_slang_library_noise1 (GLfloat x
)
169 int i0
= FASTFLOOR(x
);
172 float x1
= x0
- 1.0f
;
173 float t1
= 1.0f
- x1
*x1
;
176 float t0
= 1.0f
- x0
*x0
;
177 /* if(t0 < 0.0f) t0 = 0.0f; // this never happens for the 1D case */
179 n0
= t0
* t0
* grad1(perm
[i0
& 0xff], x0
);
181 /* if(t1 < 0.0f) t1 = 0.0f; // this never happens for the 1D case */
183 n1
= t1
* t1
* grad1(perm
[i1
& 0xff], x1
);
184 /* The maximum value of this noise is 8*(3/4)^4 = 2.53125 */
185 /* A factor of 0.395 would scale to fit exactly within [-1,1], but */
186 /* we want to match PRMan's 1D noise, so we scale it down some more. */
187 return 0.25f
* (n0
+ n1
);
190 /* 2D simplex noise */
191 GLfloat
_slang_library_noise2 (GLfloat x
, GLfloat y
)
193 #define F2 0.366025403f /* F2 = 0.5*(sqrt(3.0)-1.0) */
194 #define G2 0.211324865f /* G2 = (3.0-Math.sqrt(3.0))/6.0 */
196 float n0
, n1
, n2
; /* Noise contributions from the three corners */
198 /* Skew the input space to determine which simplex cell we're in */
199 float s
= (x
+y
)*F2
; /* Hairy factor for 2D */
202 int i
= FASTFLOOR(xs
);
203 int j
= FASTFLOOR(ys
);
205 float t
= (float)(i
+j
)*G2
;
206 float X0
= i
-t
; /* Unskew the cell origin back to (x,y) space */
208 float x0
= x
-X0
; /* The x,y distances from the cell origin */
211 float x1
, y1
, x2
, y2
;
215 /* For the 2D case, the simplex shape is an equilateral triangle. */
216 /* Determine which simplex we are in. */
217 int i1
, j1
; /* Offsets for second (middle) corner of simplex in (i,j) coords */
218 if(x0
>y0
) {i1
=1; j1
=0;} /* lower triangle, XY order: (0,0)->(1,0)->(1,1) */
219 else {i1
=0; j1
=1;} /* upper triangle, YX order: (0,0)->(0,1)->(1,1) */
221 /* A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and */
222 /* a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where */
223 /* c = (3-sqrt(3))/6 */
225 x1
= x0
- i1
+ G2
; /* Offsets for middle corner in (x,y) unskewed coords */
227 x2
= x0
- 1.0f
+ 2.0f
* G2
; /* Offsets for last corner in (x,y) unskewed coords */
228 y2
= y0
- 1.0f
+ 2.0f
* G2
;
230 /* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
234 /* Calculate the contribution from the three corners */
235 t0
= 0.5f
- x0
*x0
-y0
*y0
;
236 if(t0
< 0.0f
) n0
= 0.0f
;
239 n0
= t0
* t0
* grad2(perm
[ii
+perm
[jj
]], x0
, y0
);
242 t1
= 0.5f
- x1
*x1
-y1
*y1
;
243 if(t1
< 0.0f
) n1
= 0.0f
;
246 n1
= t1
* t1
* grad2(perm
[ii
+i1
+perm
[jj
+j1
]], x1
, y1
);
249 t2
= 0.5f
- x2
*x2
-y2
*y2
;
250 if(t2
< 0.0f
) n2
= 0.0f
;
253 n2
= t2
* t2
* grad2(perm
[ii
+1+perm
[jj
+1]], x2
, y2
);
256 /* Add contributions from each corner to get the final noise value. */
257 /* The result is scaled to return values in the interval [-1,1]. */
258 return 40.0f
* (n0
+ n1
+ n2
); /* TODO: The scale factor is preliminary! */
261 /* 3D simplex noise */
262 GLfloat
_slang_library_noise3 (GLfloat x
, GLfloat y
, GLfloat z
)
264 /* Simple skewing factors for the 3D case */
265 #define F3 0.333333333f
266 #define G3 0.166666667f
268 float n0
, n1
, n2
, n3
; /* Noise contributions from the four corners */
270 /* Skew the input space to determine which simplex cell we're in */
271 float s
= (x
+y
+z
)*F3
; /* Very nice and simple skew factor for 3D */
275 int i
= FASTFLOOR(xs
);
276 int j
= FASTFLOOR(ys
);
277 int k
= FASTFLOOR(zs
);
279 float t
= (float)(i
+j
+k
)*G3
;
280 float X0
= i
-t
; /* Unskew the cell origin back to (x,y,z) space */
283 float x0
= x
-X0
; /* The x,y,z distances from the cell origin */
287 float x1
, y1
, z1
, x2
, y2
, z2
, x3
, y3
, z3
;
289 float t0
, t1
, t2
, t3
;
291 /* For the 3D case, the simplex shape is a slightly irregular tetrahedron. */
292 /* Determine which simplex we are in. */
293 int i1
, j1
, k1
; /* Offsets for second corner of simplex in (i,j,k) coords */
294 int i2
, j2
, k2
; /* Offsets for third corner of simplex in (i,j,k) coords */
296 /* This code would benefit from a backport from the GLSL version! */
299 { i1
=1; j1
=0; k1
=0; i2
=1; j2
=1; k2
=0; } /* X Y Z order */
300 else if(x0
>=z0
) { i1
=1; j1
=0; k1
=0; i2
=1; j2
=0; k2
=1; } /* X Z Y order */
301 else { i1
=0; j1
=0; k1
=1; i2
=1; j2
=0; k2
=1; } /* Z X Y order */
304 if(y0
<z0
) { i1
=0; j1
=0; k1
=1; i2
=0; j2
=1; k2
=1; } /* Z Y X order */
305 else if(x0
<z0
) { i1
=0; j1
=1; k1
=0; i2
=0; j2
=1; k2
=1; } /* Y Z X order */
306 else { i1
=0; j1
=1; k1
=0; i2
=1; j2
=1; k2
=0; } /* Y X Z order */
309 /* A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z), */
310 /* a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and */
311 /* a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where */
314 x1
= x0
- i1
+ G3
; /* Offsets for second corner in (x,y,z) coords */
317 x2
= x0
- i2
+ 2.0f
*G3
; /* Offsets for third corner in (x,y,z) coords */
318 y2
= y0
- j2
+ 2.0f
*G3
;
319 z2
= z0
- k2
+ 2.0f
*G3
;
320 x3
= x0
- 1.0f
+ 3.0f
*G3
; /* Offsets for last corner in (x,y,z) coords */
321 y3
= y0
- 1.0f
+ 3.0f
*G3
;
322 z3
= z0
- 1.0f
+ 3.0f
*G3
;
324 /* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
329 /* Calculate the contribution from the four corners */
330 t0
= 0.6f
- x0
*x0
- y0
*y0
- z0
*z0
;
331 if(t0
< 0.0f
) n0
= 0.0f
;
334 n0
= t0
* t0
* grad3(perm
[ii
+perm
[jj
+perm
[kk
]]], x0
, y0
, z0
);
337 t1
= 0.6f
- x1
*x1
- y1
*y1
- z1
*z1
;
338 if(t1
< 0.0f
) n1
= 0.0f
;
341 n1
= t1
* t1
* grad3(perm
[ii
+i1
+perm
[jj
+j1
+perm
[kk
+k1
]]], x1
, y1
, z1
);
344 t2
= 0.6f
- x2
*x2
- y2
*y2
- z2
*z2
;
345 if(t2
< 0.0f
) n2
= 0.0f
;
348 n2
= t2
* t2
* grad3(perm
[ii
+i2
+perm
[jj
+j2
+perm
[kk
+k2
]]], x2
, y2
, z2
);
351 t3
= 0.6f
- x3
*x3
- y3
*y3
- z3
*z3
;
352 if(t3
<0.0f
) n3
= 0.0f
;
355 n3
= t3
* t3
* grad3(perm
[ii
+1+perm
[jj
+1+perm
[kk
+1]]], x3
, y3
, z3
);
358 /* Add contributions from each corner to get the final noise value. */
359 /* The result is scaled to stay just inside [-1,1] */
360 return 32.0f
* (n0
+ n1
+ n2
+ n3
); /* TODO: The scale factor is preliminary! */
363 /* 4D simplex noise */
364 GLfloat
_slang_library_noise4 (GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
366 /* The skewing and unskewing factors are hairy again for the 4D case */
367 #define F4 0.309016994f /* F4 = (Math.sqrt(5.0)-1.0)/4.0 */
368 #define G4 0.138196601f /* G4 = (5.0-Math.sqrt(5.0))/20.0 */
370 float n0
, n1
, n2
, n3
, n4
; /* Noise contributions from the five corners */
372 /* Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in */
373 float s
= (x
+ y
+ z
+ w
) * F4
; /* Factor for 4D skewing */
378 int i
= FASTFLOOR(xs
);
379 int j
= FASTFLOOR(ys
);
380 int k
= FASTFLOOR(zs
);
381 int l
= FASTFLOOR(ws
);
383 float t
= (i
+ j
+ k
+ l
) * G4
; /* Factor for 4D unskewing */
384 float X0
= i
- t
; /* Unskew the cell origin back to (x,y,z,w) space */
389 float x0
= x
- X0
; /* The x,y,z,w distances from the cell origin */
394 /* For the 4D case, the simplex is a 4D shape I won't even try to describe. */
395 /* To find out which of the 24 possible simplices we're in, we need to */
396 /* determine the magnitude ordering of x0, y0, z0 and w0. */
397 /* The method below is a good way of finding the ordering of x,y,z,w and */
398 /* then find the correct traversal order for the simplex we're in. */
399 /* First, six pair-wise comparisons are performed between each possible pair */
400 /* of the four coordinates, and the results are used to add up binary bits */
401 /* for an integer index. */
402 int c1
= (x0
> y0
) ? 32 : 0;
403 int c2
= (x0
> z0
) ? 16 : 0;
404 int c3
= (y0
> z0
) ? 8 : 0;
405 int c4
= (x0
> w0
) ? 4 : 0;
406 int c5
= (y0
> w0
) ? 2 : 0;
407 int c6
= (z0
> w0
) ? 1 : 0;
408 int c
= c1
+ c2
+ c3
+ c4
+ c5
+ c6
;
410 int i1
, j1
, k1
, l1
; /* The integer offsets for the second simplex corner */
411 int i2
, j2
, k2
, l2
; /* The integer offsets for the third simplex corner */
412 int i3
, j3
, k3
, l3
; /* The integer offsets for the fourth simplex corner */
414 float x1
, y1
, z1
, w1
, x2
, y2
, z2
, w2
, x3
, y3
, z3
, w3
, x4
, y4
, z4
, w4
;
416 float t0
, t1
, t2
, t3
, t4
;
418 /* simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order. */
419 /* Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w */
420 /* impossible. Only the 24 indices which have non-zero entries make any sense. */
421 /* We use a thresholding to set the coordinates in turn from the largest magnitude. */
422 /* The number 3 in the "simplex" array is at the position of the largest coordinate. */
423 i1
= simplex
[c
][0]>=3 ? 1 : 0;
424 j1
= simplex
[c
][1]>=3 ? 1 : 0;
425 k1
= simplex
[c
][2]>=3 ? 1 : 0;
426 l1
= simplex
[c
][3]>=3 ? 1 : 0;
427 /* The number 2 in the "simplex" array is at the second largest coordinate. */
428 i2
= simplex
[c
][0]>=2 ? 1 : 0;
429 j2
= simplex
[c
][1]>=2 ? 1 : 0;
430 k2
= simplex
[c
][2]>=2 ? 1 : 0;
431 l2
= simplex
[c
][3]>=2 ? 1 : 0;
432 /* The number 1 in the "simplex" array is at the second smallest coordinate. */
433 i3
= simplex
[c
][0]>=1 ? 1 : 0;
434 j3
= simplex
[c
][1]>=1 ? 1 : 0;
435 k3
= simplex
[c
][2]>=1 ? 1 : 0;
436 l3
= simplex
[c
][3]>=1 ? 1 : 0;
437 /* The fifth corner has all coordinate offsets = 1, so no need to look that up. */
439 x1
= x0
- i1
+ G4
; /* Offsets for second corner in (x,y,z,w) coords */
443 x2
= x0
- i2
+ 2.0f
*G4
; /* Offsets for third corner in (x,y,z,w) coords */
444 y2
= y0
- j2
+ 2.0f
*G4
;
445 z2
= z0
- k2
+ 2.0f
*G4
;
446 w2
= w0
- l2
+ 2.0f
*G4
;
447 x3
= x0
- i3
+ 3.0f
*G4
; /* Offsets for fourth corner in (x,y,z,w) coords */
448 y3
= y0
- j3
+ 3.0f
*G4
;
449 z3
= z0
- k3
+ 3.0f
*G4
;
450 w3
= w0
- l3
+ 3.0f
*G4
;
451 x4
= x0
- 1.0f
+ 4.0f
*G4
; /* Offsets for last corner in (x,y,z,w) coords */
452 y4
= y0
- 1.0f
+ 4.0f
*G4
;
453 z4
= z0
- 1.0f
+ 4.0f
*G4
;
454 w4
= w0
- 1.0f
+ 4.0f
*G4
;
456 /* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
462 /* Calculate the contribution from the five corners */
463 t0
= 0.6f
- x0
*x0
- y0
*y0
- z0
*z0
- w0
*w0
;
464 if(t0
< 0.0f
) n0
= 0.0f
;
467 n0
= t0
* t0
* grad4(perm
[ii
+perm
[jj
+perm
[kk
+perm
[ll
]]]], x0
, y0
, z0
, w0
);
470 t1
= 0.6f
- x1
*x1
- y1
*y1
- z1
*z1
- w1
*w1
;
471 if(t1
< 0.0f
) n1
= 0.0f
;
474 n1
= t1
* t1
* grad4(perm
[ii
+i1
+perm
[jj
+j1
+perm
[kk
+k1
+perm
[ll
+l1
]]]], x1
, y1
, z1
, w1
);
477 t2
= 0.6f
- x2
*x2
- y2
*y2
- z2
*z2
- w2
*w2
;
478 if(t2
< 0.0f
) n2
= 0.0f
;
481 n2
= t2
* t2
* grad4(perm
[ii
+i2
+perm
[jj
+j2
+perm
[kk
+k2
+perm
[ll
+l2
]]]], x2
, y2
, z2
, w2
);
484 t3
= 0.6f
- x3
*x3
- y3
*y3
- z3
*z3
- w3
*w3
;
485 if(t3
< 0.0f
) n3
= 0.0f
;
488 n3
= t3
* t3
* grad4(perm
[ii
+i3
+perm
[jj
+j3
+perm
[kk
+k3
+perm
[ll
+l3
]]]], x3
, y3
, z3
, w3
);
491 t4
= 0.6f
- x4
*x4
- y4
*y4
- z4
*z4
- w4
*w4
;
492 if(t4
< 0.0f
) n4
= 0.0f
;
495 n4
= t4
* t4
* grad4(perm
[ii
+1+perm
[jj
+1+perm
[kk
+1+perm
[ll
+1]]]], x4
, y4
, z4
, w4
);
498 /* Sum up and scale the result to cover the range [-1,1] */
499 return 27.0f
* (n0
+ n1
+ n2
+ n3
+ n4
); /* TODO: The scale factor is preliminary! */