snoise16() [3/4]

fl::u16 snoise16	(	fl::u32	x,
		fl::u32	y,
		fl::u32	z )

Definition at line 196 of file simplex.cpp.hpp.

                                          {
    // Simple skewing factors for the 3D case
    const u64 F3 = 1431655764; // .32: 0.333333333
    const u64 G3 = 715827884;  // .32: 0.166666667
 
    // Skew the input space to determine which simplex cell we're in
    fl::u32 s = (((u64)x + (u64)y + (u64)z) * F3) >> 32; // .12 + .32 = .12: Very nice and simple skew factor for 3D
    fl::u32 i = ((x>>1) + (s>>1)) >> 11;                                // .0
    fl::u32 j = ((y>>1) + (s>>1)) >> 11;                                // .0
    fl::u32 k = ((z>>1) + (s>>1)) >> 11;                                // .0
 
    u64 t = ((u64)i + (u64)j + (u64)k) * G3; // .32
    u64 X0 = ((u64)i<<32) - t;                         // .32: Unskew the cell origin back to (x,y) space
    u64 Y0 = ((u64)j<<32) - t;                         // .32
    u64 Z0 = ((u64)k<<32) - t;                         // .32
    fl::i32 x0 = ((u64)x<<2) - (X0>>18);                    // .14: The x,y distances from the cell origin
    fl::i32 y0 = ((u64)y<<2) - (Y0>>18);                    // .14
    fl::i32 z0 = ((u64)z<<2) - (Z0>>18);                    // .14
 
    // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
    // Determine which simplex we are in.
    fl::u32 i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
    fl::u32 i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
 
    // This code would benefit from a backport from the GLSL version!
    if (x0 >= y0) {
        if (y0 >= z0) {
            i1 = 1;
            j1 = 0;
            k1 = 0;
            i2 = 1;
            j2 = 1;
            k2 = 0; // X Y Z order
        } else if (x0 >= z0) {
            i1 = 1;
            j1 = 0;
            k1 = 0;
            i2 = 1;
            j2 = 0;
            k2 = 1; // X Z Y order
        } else {
            i1 = 0;
            j1 = 0;
            k1 = 1;
            i2 = 1;
            j2 = 0;
            k2 = 1; // Z X Y order
        }
    } else { // x0<y0
        if (y0 < z0) {
            i1 = 0;
            j1 = 0;
            k1 = 1;
            i2 = 0;
            j2 = 1;
            k2 = 1; // Z Y X order
        } else if (x0 < z0) {
            i1 = 0;
            j1 = 1;
            k1 = 0;
            i2 = 0;
            j2 = 1;
            k2 = 1; // Y Z X order
        } else {
            i1 = 0;
            j1 = 1;
            k1 = 0;
            i2 = 1;
            j2 = 1;
            k2 = 0; // Y X Z order
        }
    }
 
    // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
    // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
    // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
    // c = 1/6.
 
    fl::i32 x1 = x0 - ((fl::i32)i1<<14) + ((fl::i32)(G3>>18));   // .14: Offsets for second corner in (x,y,z) coords
    fl::i32 y1 = y0 - ((fl::i32)j1<<14) + ((fl::i32)(G3>>18));   // .14
    fl::i32 z1 = z0 - ((fl::i32)k1<<14) + ((fl::i32)(G3>>18));   // .14
    fl::i32 x2 = x0 - ((fl::i32)i2<<14) + ((fl::i32)(2*G3)>>18); // .14: Offsets for third corner in (x,y,z) coords
    fl::i32 y2 = y0 - ((fl::i32)j2<<14) + ((fl::i32)(2*G3)>>18); // .14
    fl::i32 z2 = z0 - ((fl::i32)k2<<14) + ((fl::i32)(2*G3)>>18); // .14
    fl::i32 x3 = x0 - (1 << 14) + (fl::i32)((3*G3)>>18);         // .14: Offsets for last corner in (x,y,z) coords
    fl::i32 y3 = y0 - (1 << 14) + (fl::i32)((3*G3)>>18);         // .14
    fl::i32 z3 = z0 - (1 << 14) + (fl::i32)((3*G3)>>18);         // .14
 
    // Calculate the contribution from the four corners
    fl::i32 n0 = 0, n1 = 0, n2 = 0, n3 = 0; // .30
    const fl::i32 fix0_6 = 161061274;       // .28: 0.6
 
    fl::i32 t0 = (fix0_6 - x0*x0 - y0*y0 - z0*z0) >> 12; // .16
    if (t0 > 0) {
        t0 = (t0 * t0) >> 16; // .16
        t0 = (t0 * t0) >> 16; // .16
        // .16 * .14 = .30
        n0 = t0 * grad(SIMPLEX_P((i+(fl::u32)SIMPLEX_P((j+(fl::u32)SIMPLEX_P(k&0xff))&0xff))&0xff), x0, y0, z0);
    }
 
    fl::i32 t1 = (fix0_6 - x1*x1 - y1*y1 - z1*z1) >> 12; // .16
    if (t1 > 0) {
        t1 = (t1 * t1) >> 16; // .16
        t1 = (t1 * t1) >> 16; // .16
        // .16 * .14 = .30
        n1 = t1 * grad(SIMPLEX_P((i+i1+(fl::u32)SIMPLEX_P((j+j1+(fl::u32)SIMPLEX_P((k+k1)&0xff))&0xff))&0xff), x1, y1, z1);
    }
 
    fl::i32 t2 = (fix0_6 - x2*x2 - y2*y2 - z2*z2) >> 12; // .16
    if (t2 > 0) {
        t2 = (t2 * t2) >> 16; // .16
        t2 = (t2 * t2) >> 16; // .16
        // .16 * .14 = .30
        n2 = t2 * grad(SIMPLEX_P((i+i2+(fl::u32)SIMPLEX_P((j+j2+(fl::u32)SIMPLEX_P((k+k2)&0xff))&0xff))&0xff), x2, y2, z2);
    }
 
    fl::i32 t3 = (fix0_6 - x3*x3 - y3*y3 - z3*z3) >> 12; // .16
    if (t3 > 0) {
        t3 = (t3 * t3) >> 16; // .16
        t3 = (t3 * t3) >> 16; // .16
        // .16 * .14 = .30
        n3 = t3 * grad(SIMPLEX_P((i+1+(fl::u32)SIMPLEX_P((j+1+(fl::u32)SIMPLEX_P((k+1)&0xff))&0xff))&0xff), x3, y3, z3);
    }
 
    // Add contributions from each corner to get the final noise value.
    // The result is scaled to stay just inside [-1,1]
    fl::i32 n = n0 + n1 + n2 + n3; // .30
    n = ((n >> 8) * 16748) >> 16 ; // fix scale to fit exactly in an int16
    return (fl::u16)n + 0x8000;
}

References grad(), SIMPLEX_P, t, x, y, and z.

Here is the call graph for this function: