snoise16() [2/4]

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

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

                                 {
    const u64 F2 = 1572067135; // .32: F2 = 0.5*(sqrt(3.0)-1.0)
    const u64 G2 = 907633384;  // .32: G2 = (3.0-Math.sqrt(3.0))/6.0
 
    // Skew the input space to determine which simplex cell we're in
    fl::u32 s = (((u64)x + (u64)y) * F2) >> 32; // (.12 + .12) * .32 = .12: Hairy factor for 2D
    fl::u32 i = ((x>>1) + (s>>1)) >> 11;                  // .0
    fl::u32 j = ((y>>1) + (s>>1)) >> 11;                  // .0
 
    u64 t = ((u64)i + (u64)j) * G2; // .32
    u64 X0 = ((u64)i<<32) - t;           // .32: Unskew the cell origin back to (x,y) space
    u64 Y0 = ((u64)j<<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
 
    // For the 2D case, the simplex shape is an equilateral triangle.
    // Determine which simplex we are in.
    fl::u32 i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
    if (x0 > y0) {
        i1 = 1;
        j1 = 0; // lower triangle, XY order: (0,0)->(1,0)->(1,1)
    } else {
        i1 = 0;
        j1 = 1;
    } // upper triangle, YX order: (0,0)->(0,1)->(1,1)
 
    // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
    // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
    // c = (3-sqrt(3))/6
 
    fl::i32 x1 = x0 - ((fl::i32)i1<<14) + (fl::i32)(G2>>18); // .14: Offsets for middle corner in (x,y) unskewed coords
    fl::i32 y1 = y0 - ((fl::i32)j1<<14) + (fl::i32)(G2>>18); // .14
    fl::i32 x2 = x0 - (1 << 14) + ((fl::i32)(2*G2)>>18);     // .14: Offsets for last corner in (x,y) unskewed coords
    fl::i32 y2 = y0 - (1 << 14) + ((fl::i32)(2*G2)>>18);     // .14
 
    fl::i32 n0 = 0, n1 = 0, n2 = 0; // Noise contributions from the three corners
 
    // Calculate the contribution from the three corners
    fl::i32 t0 = (((fl::i32)1 << 27) - x0*x0 - y0*y0) >> 12; // .16
    if (t0 > 0) {
        t0 = (t0 * t0) >> 16;                                      // .16
        t0 = (t0 * t0) >> 16;                                      // .16
        n0 = t0 * grad(SIMPLEX_P((i+(fl::u32)(SIMPLEX_P(j&0xff)))&0xff), x0, y0); // .16 * .14 = .30
    }
 
    fl::i32 t1 = (((fl::i32)1 << 27) - x1*x1 - y1*y1) >> 12; // .16
    if (t1 > 0) {
        t1 = (t1 * t1) >> 16;                                              // .16
        t1 = (t1 * t1) >> 16;                                              // .16
        n1 = t1 * grad(SIMPLEX_P((i+i1+(fl::u32)(SIMPLEX_P((j+j1)&0xff)))&0xff), x1, y1); // .16 * .14 = .30
    }
 
    fl::i32 t2 = (((fl::i32)1 << 27) - x2*x2 - y2*y2) >> 12; // .16
    if (t2 > 0) {
        t2 = (t2 * t2) >> 16;                                            // .16
        t2 = (t2 * t2) >> 16;                                            // .16
        n2 = t2 * grad(SIMPLEX_P((i+1+(fl::u32)(SIMPLEX_P((j+1)&0xff)))&0xff), x2, y2); // .16 * .14 = .30
    }
 
    // Add contributions from each corner to get the final noise value.
    // The result is scaled to return values in the interval [-1,1].
    fl::i32 n = n0 + n1 + n2;    // .30
    n = ((n >> 8) * 23163) >> 16; // fix scale to fit exactly in an int16
    return (fl::u16)n + 0x8000;
}

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

Here is the call graph for this function: