inoise16_raw() [4/4]

fl::i16 inoise16_raw ( fl::u32 x, fl::u32 y, fl::u32 z, fl::u32 w )

extern

Definition at line 346 of file noise.cpp.hpp.

                                                       {
    // 1. Extract the integer (grid) parts.
    fl::u8 X = (x >> 16) & 0xFF;
    fl::u8 Y = (y >> 16) & 0xFF;
    fl::u8 Z = (z >> 16) & 0xFF;
    fl::u8 T = (t >> 16) & 0xFF;
 
    // 2. Extract the fractional parts.
    fl::u16 u = x & 0xFFFF;
    fl::u16 v = y & 0xFFFF;
    fl::u16 w = z & 0xFFFF;
    fl::u16 s = t & 0xFFFF;
 
    // 3. Easing of the fractional parts.
    u = EASE16(u);
    v = EASE16(v);
    w = EASE16(w);
    s = EASE16(s);
 
    fl::u16 N = 0x8000L; // fixed-point half-scale
 
    // 4. Precompute fixed-point versions for the gradient evaluations.
    fl::i16 xx = (u >> 1) & 0x7FFF;
    fl::i16 yy = (v >> 1) & 0x7FFF;
    fl::i16 zz = (w >> 1) & 0x7FFF;
 
    // 5. Hash the 3D cube corners (the “base” for both t slices).
    fl::u8 A = NOISE_P(X) + Y;
    fl::u8 AA = NOISE_P(A) + Z;
    fl::u8 AB = NOISE_P(A + 1) + Z;
    fl::u8 B = NOISE_P(X + 1) + Y;
    fl::u8 BA = NOISE_P(B) + Z;
    fl::u8 BB = NOISE_P(B + 1) + Z;
 
    // 6. --- Lower t Slice (using T) ---
    fl::u8 AAA = NOISE_P(AA) + T;
    fl::u8 AAB = NOISE_P(AA + 1) + T;
    fl::u8 ABA = NOISE_P(AB) + T;
    fl::u8 ABB = NOISE_P(AB + 1) + T;
    fl::u8 BAA = NOISE_P(BA) + T;
    fl::u8 BAB = NOISE_P(BA + 1) + T;
    fl::u8 BBA = NOISE_P(BB) + T;
    fl::u8 BBB = NOISE_P(BB + 1) + T;
 
    fl::i16 L1 = LERP(grad16(AAA, xx, yy, zz),     grad16(BAA, xx - N, yy, zz), u);
    fl::i16 L2 = LERP(grad16(ABA, xx, yy - N, zz),  grad16(BBA, xx - N, yy - N, zz), u);
    fl::i16 L3 = LERP(grad16(AAB, xx, yy, zz - N),  grad16(BAB, xx - N, yy, zz - N), u);
    fl::i16 L4 = LERP(grad16(ABB, xx, yy - N, zz - N),  grad16(BBB, xx - N, yy - N, zz - N), u);
 
    fl::i16 Y1 = LERP(L1, L2, v);
    fl::i16 Y2 = LERP(L3, L4, v);
    fl::i16 noise_lower = LERP(Y1, Y2, w);
 
    // 7. --- Upper t Slice (using T+1) ---
    fl::u8 Tupper = T + 1;
    fl::u8 AAA_u = NOISE_P(AA) + Tupper;
    fl::u8 AAB_u = NOISE_P(AA + 1) + Tupper;
    fl::u8 ABA_u = NOISE_P(AB) + Tupper;
    fl::u8 ABB_u = NOISE_P(AB + 1) + Tupper;
    fl::u8 BAA_u = NOISE_P(BA) + Tupper;
    fl::u8 BAB_u = NOISE_P(BA + 1) + Tupper;
    fl::u8 BBA_u = NOISE_P(BB) + Tupper;
    fl::u8 BBB_u = NOISE_P(BB + 1) + Tupper;
 
    fl::i16 U1 = LERP(grad16(AAA_u, xx, yy, zz),     grad16(BAA_u, xx - N, yy, zz), u);
    fl::i16 U2 = LERP(grad16(ABA_u, xx, yy - N, zz),  grad16(BBA_u, xx - N, yy - N, zz), u);
    fl::i16 U3 = LERP(grad16(AAB_u, xx, yy, zz - N),  grad16(BAB_u, xx - N, yy, zz - N), u);
    fl::i16 U4 = LERP(grad16(ABB_u, xx, yy - N, zz - N),  grad16(BBB_u, xx - N, yy - N, zz - N), u);
 
    fl::i16 V1 = LERP(U1, U2, v);
    fl::i16 V2 = LERP(U3, U4, v);
    fl::i16 noise_upper = LERP(V1, V2, w);
 
    // 8. Final interpolation in the t dimension.
    fl::i16 noise4d = LERP(noise_lower, noise_upper, s);
 
    return noise4d;
}

References grad16(), NOISE_P, t, x, y, and z.

Here is the call graph for this function: