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