inoise16_raw() [4/4]

int16_t inoise16_raw ( uint32_t x, uint32_t y, uint32_t z, uint32_t w )

extern

Definition at line 387 of file noise.cpp.

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

References grad16(), P, x, y, and z.

Here is the call graph for this function: