warp-lang 1.0.2__py3-none-win_amd64.whl → 1.2.0__py3-none-win_amd64.whl

warp/native/noise.h

@@ -1,850 +1,850 @@
-/** Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-#pragma once
-
-#ifndef M_PI_F
-#define M_PI_F 3.14159265358979323846f
-#endif
-
-namespace wp
-{
-
-inline CUDA_CALLABLE float smootherstep(float t)
-{
-    return t * t * t * (t * (t * 6.f - 15.f) + 10.f);
-}
-
-inline CUDA_CALLABLE float smootherstep_gradient(float t)
-{
-    return 30.f * t * t * (t * (t - 2.f) + 1.f);
-}
-
-inline CUDA_CALLABLE float smoothstep(float t)
-{
-    return t * t * (3.f - t * 2.f);
-}
-
-inline CUDA_CALLABLE float smoothstep_gradient(float t)
-{
-    return 6.f * t * (1.f - t);
-}
-
-inline CUDA_CALLABLE float interpolate(float a0, float a1, float t)
-{
-    return (a1 - a0) * smootherstep(t) + a0;
-    // return (a1 - a0) * smoothstep(t) + a0;
-    // return (a1 - a0) * t + a0;
-}
-
-inline CUDA_CALLABLE float interpolate_gradient(float a0, float a1, float t, float d_a0, float d_a1, float d_t)
-{
-    return (d_a1 - d_a0) * smootherstep(t) + (a1 - a0) * smootherstep_gradient(t) * d_t + d_a0;
-    // return (d_a1 - d_a0) * smoothstep(t) + (a1 - a0) * smoothstep_gradient(t) * d_t + d_a0;
-    // return (d_a1 - d_a0) * t + (a1 - a0) * d_t + d_a0;
-}
-
-inline CUDA_CALLABLE vec2 interpolate_gradient_2d(float a0, float a1, float t, vec2& d_a0, vec2& d_a1, vec2& d_t)
-{
-    return (d_a1 - d_a0) * smootherstep(t) + (a1 - a0) * smootherstep_gradient(t) * d_t + d_a0;
-}
-
-inline CUDA_CALLABLE vec3 interpolate_gradient_3d(float a0, float a1, float t, vec3& d_a0, vec3& d_a1, vec3& d_t)
-{
-    return (d_a1 - d_a0) * smootherstep(t) + (a1 - a0) * smootherstep_gradient(t) * d_t + d_a0;
-}
-
-inline CUDA_CALLABLE vec4 interpolate_gradient_4d(float a0, float a1, float t, vec4& d_a0, vec4& d_a1, vec4& d_t)
-{
-    return (d_a1 - d_a0) * smootherstep(t) + (a1 - a0) * smootherstep_gradient(t) * d_t + d_a0;
-}
-
-inline CUDA_CALLABLE float random_gradient_1d(uint32 state, int ix)
-{
-    const uint32 p1 = 73856093;
-    uint32 idx = ix*p1 + state;
-    return randf(idx, -1.f, 1.f);
-}
-
-inline CUDA_CALLABLE vec2 random_gradient_2d(uint32 state, int ix, int iy)
-{
-    const uint32 p1 = 73856093;
-    const uint32 p2 = 19349663;
-    uint32 idx = ix*p1 ^ iy*p2 + state;
-    
-    return normalize(sample_unit_square(idx));
-}
-
-inline CUDA_CALLABLE vec3 random_gradient_3d(uint32 state, int ix, int iy, int iz)
-{
-    const uint32 p1 = 73856093;
-	const uint32 p2 = 19349663;
-    const uint32 p3 = 53471161;
-    uint32 idx = ix*p1 ^ iy*p2 ^ iz*p3 + state;
-
-    return normalize(sample_unit_cube(idx));
-}
-
-inline CUDA_CALLABLE vec4 random_gradient_4d(uint32 state, int ix, int iy, int iz, int it)
-{
-    const uint32 p1 = 73856093;
-	const uint32 p2 = 19349663;
-	const uint32 p3 = 53471161;
-    const uint32 p4 = 10000019;
-    uint32 idx = ix*p1 ^ iy*p2 ^ iz*p3 ^ it*p4 + state;
-
-    return normalize(sample_unit_hypercube(idx));
-}
-
-inline CUDA_CALLABLE float dot_grid_gradient_1d(uint32 state, int ix, float dx)
-{
-    float gradient = random_gradient_1d(state, ix);
-    return dx*gradient;
-}
-
-inline CUDA_CALLABLE float dot_grid_gradient_2d(uint32 state, int ix, int iy, float dx, float dy)
-{
-    vec2 gradient = random_gradient_2d(state, ix, iy);
-    return (dx*gradient[0] + dy*gradient[1]);
-}
-
-inline CUDA_CALLABLE float dot_grid_gradient_3d(uint32 state, int ix, int iy, int iz, float dx, float dy, float dz)
-{
-    vec3 gradient = random_gradient_3d(state, ix, iy, iz);
-    return (dx*gradient[0] + dy*gradient[1] + dz*gradient[2]);
-}
-
-inline CUDA_CALLABLE float dot_grid_gradient_4d(uint32 state, int ix, int iy, int iz, int it, float dx, float dy, float dz, float dt)
-{
-    vec4 gradient = random_gradient_4d(state, ix, iy, iz, it);
-    return (dx*gradient[0] + dy*gradient[1] + dz*gradient[2] + dt*gradient[3]);
-}
-
-inline CUDA_CALLABLE float noise_1d(uint32 state, int x0, int x1, float dx)
-{
-    //vX
-    float v0 = dot_grid_gradient_1d(state, x0, dx);
-    float v1 = dot_grid_gradient_1d(state, x1, dx-1.f);
-
-    return interpolate(v0, v1, dx);
-}
-
-inline CUDA_CALLABLE float noise_1d_gradient(uint32 state, int x0, int x1, float dx)
-{
-    float gradient_x0 = random_gradient_1d(state, x0);
-    float v0 = dx * gradient_x0;
-
-    float gradient_x1 = random_gradient_1d(state, x1);
-    float v1 = (dx-1.f) * gradient_x1;
-
-    return interpolate_gradient(v0, v1, dx, gradient_x0, gradient_x1, 1.f);
-}
-
-inline CUDA_CALLABLE float noise_2d(uint32 state, int x0, int y0, int x1, int y1, float dx, float dy)
-{
-    //vXY
-    float v00 = dot_grid_gradient_2d(state, x0, y0, dx, dy);
-    float v10 = dot_grid_gradient_2d(state, x1, y0, dx-1.f, dy);
-    float xi0 = interpolate(v00, v10, dx);
-
-    float v01 = dot_grid_gradient_2d(state, x0, y1, dx, dy-1.f);
-    float v11 = dot_grid_gradient_2d(state, x1, y1, dx-1.f, dy-1.f);
-    float xi1 = interpolate(v01, v11, dx);
-
-    return interpolate(xi0, xi1, dy);
-}
-
-inline CUDA_CALLABLE vec2 noise_2d_gradient(uint32 state, int x0, int y0, int x1, int y1, float dx, float dy)
-{
-    vec2 d00 = vec2(dx, dy);
-    vec2 gradient_v00 = random_gradient_2d(state, x0, y0);
-    float v00 = dot(d00, gradient_v00);
-
-    vec2 d10 = vec2(dx-1.f, dy);
-    vec2 gradient_v10 = random_gradient_2d(state, x1, y0);
-    float v10 = dot(d10, gradient_v10);
-
-    vec2 d01 = vec2(dx, dy-1.f);
-    vec2 gradient_v01 = random_gradient_2d(state, x0, y1);
-    float v01 = dot(d01, gradient_v01);
-
-    vec2 d11 = vec2(dx-1.f, dy-1.f);
-    vec2 gradient_v11 = random_gradient_2d(state, x1, y1);
-    float v11 = dot(d11, gradient_v11);
-
-    vec2 dx_dt = vec2(1.f, 0.f);
-
-    float xi0 = interpolate(v00, v10, dx);
-    vec2 gradient_xi0 = interpolate_gradient_2d(v00, v10, dx, gradient_v00, gradient_v10, dx_dt);
-
-    float xi1 = interpolate(v01, v11, dx);
-    vec2 gradient_xi1 = interpolate_gradient_2d(v01, v11, dx, gradient_v01, gradient_v11, dx_dt);
-
-    vec2 dy_dt = vec2(0.f, 1.f);
-
-    vec2 gradient = interpolate_gradient_2d(xi0, xi1, dy, gradient_xi0, gradient_xi1, dy_dt);
-
-    return gradient;
-}
-
-inline CUDA_CALLABLE float noise_3d(uint32 state, int x0, int y0, int z0, int x1, int y1, int z1, float dx, float dy, float dz)
-{
-    //vXYZ
-    float v000 = dot_grid_gradient_3d(state, x0, y0, z0, dx, dy, dz);
-    float v100 = dot_grid_gradient_3d(state, x1, y0, z0, dx-1.f, dy, dz);
-    float xi00 = interpolate(v000, v100, dx);
-
-    float v010 = dot_grid_gradient_3d(state, x0, y1, z0, dx, dy-1.f, dz);
-    float v110 = dot_grid_gradient_3d(state, x1, y1, z0, dx-1.f, dy-1.f, dz);
-    float xi10 = interpolate(v010, v110, dx);
-
-    float yi0 = interpolate(xi00, xi10, dy);
-
-    float v001 = dot_grid_gradient_3d(state, x0, y0, z1, dx, dy, dz-1.f);
-    float v101 = dot_grid_gradient_3d(state, x1, y0, z1, dx-1.f, dy, dz-1.f);
-    float xi01 = interpolate(v001, v101, dx);
-
-    float v011 = dot_grid_gradient_3d(state, x0, y1, z1, dx, dy-1.f, dz-1.f);
-    float v111 = dot_grid_gradient_3d(state, x1, y1, z1, dx-1.f, dy-1.f, dz-1.f);
-    float xi11 = interpolate(v011, v111, dx);
-
-    float yi1 = interpolate(xi01, xi11, dy);
-
-    return interpolate(yi0, yi1, dz);
-}
-
-inline CUDA_CALLABLE vec3 noise_3d_gradient(uint32 state, int x0, int y0, int z0, int x1, int y1, int z1, float dx, float dy, float dz)
-{
-    vec3 d000 = vec3(dx, dy, dz);
-    vec3 gradient_v000 = random_gradient_3d(state, x0, y0, z0);
-    float v000 = dot(d000, gradient_v000);
-
-    vec3 d100 = vec3(dx-1.f, dy, dz);
-    vec3 gradient_v100 = random_gradient_3d(state, x1, y0, z0);
-    float v100 = dot(d100, gradient_v100);
-
-    vec3 d010 = vec3(dx, dy-1.f, dz);
-    vec3 gradient_v010 = random_gradient_3d(state, x0, y1, z0);
-    float v010 = dot(d010, gradient_v010);
-    
-    vec3 d110 = vec3(dx-1.f, dy-1.f, dz);
-    vec3 gradient_v110 = random_gradient_3d(state, x1, y1, z0);
-    float v110 = dot(d110, gradient_v110);
-
-    vec3 d001 = vec3(dx, dy, dz-1.f);
-    vec3 gradient_v001 = random_gradient_3d(state, x0, y0, z1);
-    float v001 = dot(d001, gradient_v001);
-
-    vec3 d101 = vec3(dx-1.f, dy, dz-1.f);
-    vec3 gradient_v101 = random_gradient_3d(state, x1, y0, z1);
-    float v101 = dot(d101, gradient_v101);
-
-    vec3 d011 = vec3(dx, dy-1.f, dz-1.f);
-    vec3 gradient_v011 = random_gradient_3d(state, x0, y1, z1);
-    float v011 = dot(d011, gradient_v011);
-
-    vec3 d111 = vec3(dx-1.f, dy-1.f, dz-1.f);
-    vec3 gradient_v111 = random_gradient_3d(state, x1, y1, z1);
-    float v111 = dot(d111, gradient_v111);
-
-    vec3 dx_dt = vec3(1.f, 0.f, 0.f);
-
-    float xi00 = interpolate(v000, v100, dx);
-    vec3 gradient_xi00 = interpolate_gradient_3d(v000, v100, dx, gradient_v000, gradient_v100, dx_dt);
-
-    float xi10 = interpolate(v010, v110, dx);
-    vec3 gradient_xi10 = interpolate_gradient_3d(v010, v110, dx, gradient_v010, gradient_v110, dx_dt);
-    
-    float xi01 = interpolate(v001, v101, dx);
-    vec3 gradient_xi01 = interpolate_gradient_3d(v001, v101, dx, gradient_v001, gradient_v101, dx_dt);
-
-    float xi11 = interpolate(v011, v111, dx);
-    vec3 gradient_xi11 = interpolate_gradient_3d(v011, v111, dx, gradient_v011, gradient_v111, dx_dt);
-
-    vec3 dy_dt = vec3(0.f, 1.f, 0.f);
-
-    float yi0 = interpolate(xi00, xi10, dy);
-    vec3 gradient_yi0 = interpolate_gradient_3d(xi00, xi10, dy, gradient_xi00, gradient_xi10, dy_dt);
-
-    float yi1 = interpolate(xi01, xi11, dy);    
-    vec3 gradient_yi1 = interpolate_gradient_3d(xi01, xi11, dy, gradient_xi01, gradient_xi11, dy_dt);
-
-    vec3 dz_dt = vec3(0.f, 0.f, 1.f);
-
-    vec3 gradient = interpolate_gradient_3d(yi0, yi1, dz, gradient_yi0, gradient_yi1, dz_dt);
-
-    return gradient;
-}
-
-inline CUDA_CALLABLE float noise_4d(uint32 state, int x0, int y0, int z0, int t0, int x1, int y1, int z1, int t1, float dx, float dy, float dz, float dt)
-{
-    //vXYZT
-    float v0000 = dot_grid_gradient_4d(state, x0, y0, z0, t0, dx, dy, dz, dt);
-    float v1000 = dot_grid_gradient_4d(state, x1, y0, z0, t0, dx-1.f, dy, dz, dt);
-    float xi000 = interpolate(v0000, v1000, dx);
-
-    float v0100 = dot_grid_gradient_4d(state, x0, y1, z0, t0, dx, dy-1.f, dz, dt);
-    float v1100 = dot_grid_gradient_4d(state, x1, y1, z0, t0, dx-1.f, dy-1.f, dz, dt);
-    float xi100 = interpolate(v0100, v1100, dx);
-
-    float yi00 = interpolate(xi000, xi100, dy);
-
-    float v0010 = dot_grid_gradient_4d(state, x0, y0, z1, t0, dx, dy, dz-1.f, dt);
-    float v1010 = dot_grid_gradient_4d(state, x1, y0, z1, t0, dx-1.f, dy, dz-1.f, dt);
-    float xi010 = interpolate(v0010, v1010, dx);
-
-    float v0110 = dot_grid_gradient_4d(state, x0, y1, z1, t0, dx, dy-1.f, dz-1.f, dt);
-    float v1110 = dot_grid_gradient_4d(state, x1, y1, z1, t0, dx-1.f, dy-1.f, dz-1.f, dt);
-    float xi110 = interpolate(v0110, v1110, dx);
-
-    float yi10 = interpolate(xi010, xi110, dy);
-
-    float zi0 = interpolate(yi00, yi10, dz);
-
-    float v0001 = dot_grid_gradient_4d(state, x0, y0, z0, t1, dx, dy, dz, dt-1.f);
-    float v1001 = dot_grid_gradient_4d(state, x1, y0, z0, t1, dx-1.f, dy, dz, dt-1.f);
-    float xi001 = interpolate(v0001, v1001, dx);
-
-    float v0101 = dot_grid_gradient_4d(state, x0, y1, z0, t1, dx, dy-1.f, dz, dt-1.f);
-    float v1101 = dot_grid_gradient_4d(state, x1, y1, z0, t1, dx-1.f, dy-1.f, dz, dt-1.f);
-    float xi101 = interpolate(v0101, v1101, dx);
-
-    float yi01 = interpolate(xi001, xi101, dy);
-
-    float v0011 = dot_grid_gradient_4d(state, x0, y0, z1, t1, dx, dy, dz-1.f, dt-1.f);
-    float v1011 = dot_grid_gradient_4d(state, x1, y0, z1, t1, dx-1.f, dy, dz-1.f, dt-1.f);
-    float xi011 = interpolate(v0011, v1011, dx);
-
-    float v0111 = dot_grid_gradient_4d(state, x0, y1, z1, t1, dx, dy-1.f, dz-1.f, dt-1.f);
-    float v1111 = dot_grid_gradient_4d(state, x1, y1, z1, t1, dx-1.f, dy-1.f, dz-1.f, dt-1.f);
-    float xi111 = interpolate(v0111, v1111, dx);
-
-    float yi11 = interpolate(xi011, xi111, dy);
-
-    float zi1 = interpolate(yi01, yi11, dz);
-
-    return interpolate(zi0, zi1, dt);
-}
-
-inline CUDA_CALLABLE vec4 noise_4d_gradient(uint32 state, int x0, int y0, int z0, int t0, int x1, int y1, int z1, int t1, float dx, float dy, float dz, float dt)
-{
-    vec4 d0000 = vec4(dx, dy, dz, dt);
-    vec4 gradient_v0000 = random_gradient_4d(state, x0, y0, z0, t0);
-    float v0000 = dot(d0000, gradient_v0000);
-
-    vec4 d1000 = vec4(dx-1.f, dy, dz, dt);
-    vec4 gradient_v1000 = random_gradient_4d(state, x1, y0, z0, t0);
-    float v1000 = dot(d1000, gradient_v1000);
-
-    vec4 d0100 = vec4(dx, dy-1.f, dz, dt);
-    vec4 gradient_v0100 = random_gradient_4d(state, x0, y1, z0, t0);
-    float v0100 = dot(d0100, gradient_v0100);
-
-    vec4 d1100 = vec4(dx-1.f, dy-1.f, dz, dt);
-    vec4 gradient_v1100 = random_gradient_4d(state, x1, y1, z0, t0);
-    float v1100 = dot(d1100, gradient_v1100);
-
-    vec4 d0010 = vec4(dx, dy, dz-1.f, dt);
-    vec4 gradient_v0010 = random_gradient_4d(state, x0, y0, z1, t0);
-    float v0010 = dot(d0010, gradient_v0010);
-
-    vec4 d1010 = vec4(dx-1.f, dy, dz-1.f, dt);
-    vec4 gradient_v1010 = random_gradient_4d(state, x1, y0, z1, t0);
-    float v1010 = dot(d1010, gradient_v1010);
-
-    vec4 d0110 = vec4(dx, dy-1.f, dz-1.f, dt);
-    vec4 gradient_v0110 = random_gradient_4d(state, x0, y1, z1, t0);
-    float v0110 = dot(d0110, gradient_v0110);
-    
-    vec4 d1110 = vec4(dx-1.f, dy-1.f, dz-1.f, dt);
-    vec4 gradient_v1110 = random_gradient_4d(state, x1, y1, z1, t0);
-    float v1110 = dot(d1110, gradient_v1110);
-
-    vec4 d0001 = vec4(dx, dy, dz, dt-1.f);
-    vec4 gradient_v0001 = random_gradient_4d(state, x0, y0, z0, t1);
-    float v0001 = dot(d0001, gradient_v0001);
-
-    vec4 d1001 = vec4(dx-1.f, dy, dz, dt-1.f);
-    vec4 gradient_v1001 = random_gradient_4d(state, x1, y0, z0, t1);
-    float v1001 = dot(d1001, gradient_v1001);
-
-    vec4 d0101 = vec4(dx, dy-1.f, dz, dt-1.f);
-    vec4 gradient_v0101 = random_gradient_4d(state, x0, y1, z0, t1);
-    float v0101 = dot(d0101, gradient_v0101);
-
-    vec4 d1101 = vec4(dx-1.f, dy-1.f, dz, dt-1.f);
-    vec4 gradient_v1101 = random_gradient_4d(state, x1, y1, z0, t1);
-    float v1101 = dot(d1101, gradient_v1101);
-
-    vec4 d0011 = vec4(dx, dy, dz-1.f, dt-1.f);
-    vec4 gradient_v0011 = random_gradient_4d(state, x0, y0, z1, t1);
-    float v0011 = dot(d0011, gradient_v0011);
-
-    vec4 d1011 = vec4(dx-1.f, dy, dz-1.f, dt-1.f);
-    vec4 gradient_v1011 = random_gradient_4d(state, x1, y0, z1, t1);
-    float v1011 = dot(d1011, gradient_v1011);
-
-    vec4 d0111 = vec4(dx, dy-1.f, dz-1.f, dt-1.f);
-    vec4 gradient_v0111 = random_gradient_4d(state, x0, y1, z1, t1);
-    float v0111 = dot(d0111, gradient_v0111);
-    
-    vec4 d1111 = vec4(dx-1.f, dy-1.f, dz-1.f, dt-1.f);
-    vec4 gradient_v1111 = random_gradient_4d(state, x1, y1, z1, t1);
-    float v1111 = dot(d1111, gradient_v1111);
-
-    vec4 dx_dt = vec4(1.f, 0.f, 0.f, 0.f);
-
-    float xi000 = interpolate(v0000, v1000, dx);
-    vec4 gradient_xi000 = interpolate_gradient_4d(v0000, v1000, dx, gradient_v0000, gradient_v1000, dx_dt);
-
-    float xi100 = interpolate(v0100, v1100, dx);
-    vec4 gradient_xi100 = interpolate_gradient_4d(v0100, v1100, dx, gradient_v0100, gradient_v1100, dx_dt);
-
-    float xi010 = interpolate(v0010, v1010, dx);
-    vec4 gradient_xi010 = interpolate_gradient_4d(v0010, v1010, dx, gradient_v0010, gradient_v1010, dx_dt);
-
-    float xi110 = interpolate(v0110, v1110, dx);
-    vec4 gradient_xi110 = interpolate_gradient_4d(v0110, v1110, dx, gradient_v0110, gradient_v1110, dx_dt);
-
-    float xi001 = interpolate(v0001, v1001, dx);
-    vec4 gradient_xi001 = interpolate_gradient_4d(v0001, v1001, dx, gradient_v0001, gradient_v1001, dx_dt);
-
-    float xi101 = interpolate(v0101, v1101, dx);
-    vec4 gradient_xi101 = interpolate_gradient_4d(v0101, v1101, dx, gradient_v0101, gradient_v1101, dx_dt);
-
-    float xi011 = interpolate(v0011, v1011, dx);
-    vec4 gradient_xi011 = interpolate_gradient_4d(v0011, v1011, dx, gradient_v0011, gradient_v1011, dx_dt);
-    
-    float xi111 = interpolate(v0111, v1111, dx);
-    vec4 gradient_xi111 = interpolate_gradient_4d(v0111, v1111, dx, gradient_v0111, gradient_v1111, dx_dt);
-    
-    vec4 dy_dt = vec4(0.f, 1.f, 0.f, 0.f);
-
-    float yi00 = interpolate(xi000, xi100, dy);
-    vec4 gradient_yi00 = interpolate_gradient_4d(xi000, xi100, dy, gradient_xi000, gradient_xi100, dy_dt);
-
-    float yi10 = interpolate(xi010, xi110, dy);
-    vec4 gradient_yi10 = interpolate_gradient_4d(xi010, xi110, dy, gradient_xi010, gradient_xi110, dy_dt);
-
-    float yi01 = interpolate(xi001, xi101, dy);
-    vec4 gradient_yi01 = interpolate_gradient_4d(xi001, xi101, dy, gradient_xi001, gradient_xi101, dy_dt);
-
-    float yi11 = interpolate(xi011, xi111, dy);
-    vec4 gradient_yi11 = interpolate_gradient_4d(xi011, xi111, dy, gradient_xi011, gradient_xi111, dy_dt);
-
-    vec4 dz_dt = vec4(0.f, 0.f, 1.f, 0.f);
-
-    float zi0 = interpolate(yi00, yi10, dz);
-    vec4 gradient_zi0 = interpolate_gradient_4d(yi00, yi10, dz, gradient_yi00, gradient_yi10, dz_dt);
-
-    float zi1 = interpolate(yi01, yi11, dz);
-    vec4 gradient_zi1 = interpolate_gradient_4d(yi01, yi11, dz, gradient_yi01, gradient_yi11, dz_dt);
-
-    vec4 dt_dt = vec4(0.f, 0.f, 0.f, 1.f);
-
-    vec4 gradient = interpolate_gradient_4d(zi0, zi1, dt, gradient_zi0, gradient_zi1, dt_dt);
-
-    return gradient;
-}
-
-// non-periodic Perlin noise
-
-inline CUDA_CALLABLE float noise(uint32 state, float x)
-{
-    float dx = x - floor(x);
-
-    int x0 = (int)floor(x);
-    int x1 = x0 + 1;
-
-    return noise_1d(state, x0, x1, dx);
-}
-
-inline CUDA_CALLABLE void adj_noise(uint32 state, float x, uint32& adj_state, float& adj_x, const float adj_ret)
-{
-    float dx = x - floor(x);
-
-    int x0 = (int)floor(x);
-    int x1 = x0 + 1;
-
-    float gradient = noise_1d_gradient(state, x0, x1, dx);
-    adj_x += gradient * adj_ret;
-}
-
-inline CUDA_CALLABLE float noise(uint32 state, const vec2& xy)
-{
-    float dx = xy[0] - floor(xy[0]);
-    float dy = xy[1] - floor(xy[1]);
-
-    int x0 = (int)floor(xy[0]); 
-    int y0 = (int)floor(xy[1]); 
-
-    int x1 = x0 + 1;
-    int y1 = y0 + 1;
-
-    return noise_2d(state, x0, y0, x1, y1, dx, dy);
-}
-
-inline CUDA_CALLABLE void adj_noise(uint32 state, const vec2& xy, uint32& adj_state, vec2& adj_xy, const float adj_ret)
-{
-    float dx = xy[0] - floor(xy[0]);
-    float dy = xy[1] - floor(xy[1]);
-
-    int x0 = (int)floor(xy[0]); 
-    int y0 = (int)floor(xy[1]); 
-
-    int x1 = x0 + 1;
-    int y1 = y0 + 1;
-
-    vec2 gradient = noise_2d_gradient(state, x0, y0, x1, y1, dx, dy);
-
-    adj_xy[0] += gradient[0] * adj_ret;
-    adj_xy[1] += gradient[1] * adj_ret;
-}
-
-inline CUDA_CALLABLE float noise(uint32 state, const vec3& xyz)
-{
-    float dx = xyz[0] - floor(xyz[0]);
-    float dy = xyz[1] - floor(xyz[1]);
-    float dz = xyz[2] - floor(xyz[2]);
-
-    int x0 = (int)floor(xyz[0]);
-    int y0 = (int)floor(xyz[1]);
-    int z0 = (int)floor(xyz[2]);
-
-    int x1 = x0 + 1;
-    int y1 = y0 + 1;
-    int z1 = z0 + 1;
-
-    return noise_3d(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
-}
-
-inline CUDA_CALLABLE void adj_noise(uint32 state, const vec3& xyz, uint32& adj_state, vec3& adj_xyz, const float adj_ret)
-{
-    float dx = xyz[0] - floor(xyz[0]);
-    float dy = xyz[1] - floor(xyz[1]);
-    float dz = xyz[2] - floor(xyz[2]);
-
-    int x0 = (int)floor(xyz[0]);
-    int y0 = (int)floor(xyz[1]);
-    int z0 = (int)floor(xyz[2]);
-
-    int x1 = x0 + 1;
-    int y1 = y0 + 1;
-    int z1 = z0 + 1;
-
-    vec3 gradient = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
-    adj_xyz[0] += gradient[0] * adj_ret;
-    adj_xyz[1] += gradient[1] * adj_ret;
-    adj_xyz[2] += gradient[2] * adj_ret;
-}
-
-inline CUDA_CALLABLE float noise(uint32 state, const vec4& xyzt)
-{
-    float dx = xyzt[0] - floor(xyzt[0]);
-    float dy = xyzt[1] - floor(xyzt[1]);
-    float dz = xyzt[2] - floor(xyzt[2]);
-    float dt = xyzt[3] - floor(xyzt[3]);
-
-    int x0 = (int)floor(xyzt[0]);
-    int y0 = (int)floor(xyzt[1]);
-    int z0 = (int)floor(xyzt[2]);
-    int t0 = (int)floor(xyzt[3]);
-
-    int x1 = x0 + 1;
-    int y1 = y0 + 1;
-    int z1 = z0 + 1;
-    int t1 = t0 + 1;
-
-    return noise_4d(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
-}
-
-inline CUDA_CALLABLE void adj_noise(uint32 state, const vec4& xyzt, uint32& adj_state, vec4& adj_xyzt, const float adj_ret)
-{
-    float dx = xyzt[0] - floor(xyzt[0]);
-    float dy = xyzt[1] - floor(xyzt[1]);
-    float dz = xyzt[2] - floor(xyzt[2]);
-    float dt = xyzt[3] - floor(xyzt[3]);
-
-    int x0 = (int)floor(xyzt[0]);
-    int y0 = (int)floor(xyzt[1]);
-    int z0 = (int)floor(xyzt[2]);
-    int t0 = (int)floor(xyzt[3]);
-
-    int x1 = x0 + 1;
-    int y1 = y0 + 1;
-    int z1 = z0 + 1;
-    int t1 = t0 + 1;
-
-    vec4 gradient = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
-
-    adj_xyzt[0] += gradient[0] * adj_ret;
-    adj_xyzt[1] += gradient[1] * adj_ret;
-    adj_xyzt[2] += gradient[2] * adj_ret;
-    adj_xyzt[3] += gradient[3] * adj_ret;
-}
-
-// periodic Perlin noise
-
-inline CUDA_CALLABLE float pnoise(uint32 state, float x, int px)
-{
-    float dx = x - floor(x);
-
-    int x0 = mod(((int)floor(x)), px);
-    int x1 = mod((x0 + 1), px);
-
-    return noise_1d(state, x0, x1, dx);
-}
-
-inline CUDA_CALLABLE void adj_pnoise(uint32 state, float x, int px, uint32& adj_state, float& adj_x, int& adj_px, const float adj_ret)
-{
-    float dx = x - floor(x);
-
-    int x0 = mod(((int)floor(x)), px);
-    int x1 = mod((x0 + 1), px);
-
-    float gradient = noise_1d_gradient(state, x0, x1, dx);
-    adj_x += gradient * adj_ret;
-}
-
-inline CUDA_CALLABLE float pnoise(uint32 state, const vec2& xy, int px, int py)
-{
-    float dx = xy[0] - floor(xy[0]);
-    float dy = xy[1] - floor(xy[1]);
-
-    int x0 = mod(((int)floor(xy[0])), px); 
-    int y0 = mod(((int)floor(xy[1])), py); 
-
-    int x1 = mod((x0 + 1), px);
-    int y1 = mod((y0 + 1), py);
-
-    return noise_2d(state, x0, y0, x1, y1, dx, dy);
-}
-
-inline CUDA_CALLABLE void adj_pnoise(uint32 state, const vec2& xy, int px, int py, uint32& adj_state, vec2& adj_xy, int& adj_px, int& adj_py, const float adj_ret)
-{
-    float dx = xy[0] - floor(xy[0]);
-    float dy = xy[1] - floor(xy[1]);
-
-    int x0 = mod(((int)floor(xy[0])), px); 
-    int y0 = mod(((int)floor(xy[1])), py); 
-
-    int x1 = mod((x0 + 1), px);
-    int y1 = mod((y0 + 1), py);
-
-    vec2 gradient = noise_2d_gradient(state, x0, y0, x1, y1, dx, dy);
-
-    adj_xy[0] += gradient[0] * adj_ret;
-    adj_xy[1] += gradient[1] * adj_ret;
-}
-
-inline CUDA_CALLABLE float pnoise(uint32 state, const vec3& xyz, int px, int py, int pz)
-{
-    float dx = xyz[0] - floor(xyz[0]);
-    float dy = xyz[1] - floor(xyz[1]);
-    float dz = xyz[2] - floor(xyz[2]);
-
-    int x0 = mod(((int)floor(xyz[0])), px); 
-    int y0 = mod(((int)floor(xyz[1])), py); 
-    int z0 = mod(((int)floor(xyz[2])), pz); 
-
-    int x1 = mod((x0 + 1), px);
-    int y1 = mod((y0 + 1), py);
-    int z1 = mod((z0 + 1), pz);
-
-    return noise_3d(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
-}
-
-inline CUDA_CALLABLE void adj_pnoise(uint32 state, const vec3& xyz, int px, int py, int pz, uint32& adj_state, vec3& adj_xyz, int& adj_px, int& adj_py, int& adj_pz, const float adj_ret)
-{
-    float dx = xyz[0] - floor(xyz[0]);
-    float dy = xyz[1] - floor(xyz[1]);
-    float dz = xyz[2] - floor(xyz[2]);
-
-    int x0 = mod(((int)floor(xyz[0])), px); 
-    int y0 = mod(((int)floor(xyz[1])), py); 
-    int z0 = mod(((int)floor(xyz[2])), pz); 
-
-    int x1 = mod((x0 + 1), px);
-    int y1 = mod((y0 + 1), py);
-    int z1 = mod((z0 + 1), pz);
-
-    vec3 gradient = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
-    adj_xyz[0] += gradient[0] * adj_ret;
-    adj_xyz[1] += gradient[1] * adj_ret;
-    adj_xyz[2] += gradient[2] * adj_ret;
-}
-
-inline CUDA_CALLABLE float pnoise(uint32 state, const vec4& xyzt, int px, int py, int pz, int pt)
-{
-    float dx = xyzt[0] - floor(xyzt[0]);
-    float dy = xyzt[1] - floor(xyzt[1]);
-    float dz = xyzt[2] - floor(xyzt[2]);
-    float dt = xyzt[3] - floor(xyzt[3]);
-
-    int x0 = mod(((int)floor(xyzt[0])), px);
-    int y0 = mod(((int)floor(xyzt[1])), py);
-    int z0 = mod(((int)floor(xyzt[2])), pz);
-    int t0 = mod(((int)floor(xyzt[3])), pt);
-
-    int x1 = mod((x0 + 1), px);
-    int y1 = mod((y0 + 1), py);
-    int z1 = mod((z0 + 1), pz);
-    int t1 = mod((t0 + 1), pt);
-
-    return noise_4d(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
-}
-
-inline CUDA_CALLABLE void adj_pnoise(uint32 state, const vec4& xyzt, int px, int py, int pz, int pt, uint32& adj_state, vec4& adj_xyzt, int& adj_px, int& adj_py, int& adj_pz, int& adj_pt, const float adj_ret)
-{
-    float dx = xyzt[0] - floor(xyzt[0]);
-    float dy = xyzt[1] - floor(xyzt[1]);
-    float dz = xyzt[2] - floor(xyzt[2]);
-    float dt = xyzt[3] - floor(xyzt[3]);
-
-    int x0 = mod(((int)floor(xyzt[0])), px);
-    int y0 = mod(((int)floor(xyzt[1])), py);
-    int z0 = mod(((int)floor(xyzt[2])), pz);
-    int t0 = mod(((int)floor(xyzt[3])), pt);
-
-    int x1 = mod((x0 + 1), px);
-    int y1 = mod((y0 + 1), py);
-    int z1 = mod((z0 + 1), pz);
-    int t1 = mod((t0 + 1), pt);
-
-    vec4 gradient = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
-
-    adj_xyzt[0] += gradient[0] * adj_ret;
-    adj_xyzt[1] += gradient[1] * adj_ret;
-    adj_xyzt[2] += gradient[2] * adj_ret;
-    adj_xyzt[3] += gradient[3] * adj_ret;
-}
-
-// curl noise
-
-inline CUDA_CALLABLE vec2 curlnoise(uint32 state, const vec2& xy, const uint32 octaves, const float lacunarity, const float gain)
-{
-    vec2 curl_sum = vec2(0.f);
-    float freq = 1.f;
-    float amplitude = 1.f;
-
-    for (int i = 0; i < octaves; i++)
-    {
-        vec2 pt = freq * xy;
-        float dx = pt[0] - floor(pt[0]);
-        float dy = pt[1] - floor(pt[1]);
-
-        int x0 = (int)floor(pt[0]); 
-        int y0 = (int)floor(pt[1]); 
-
-        int x1 = x0 + 1;
-        int y1 = y0 + 1;
-
-        vec2 grad_field = noise_2d_gradient(state, x0, y0, x1, y1, dx, dy);
-        curl_sum += amplitude * grad_field;
-
-        amplitude *= gain;
-        freq *= lacunarity;
-    }
-    return vec2(-curl_sum[1], curl_sum[0]);
-}
-inline CUDA_CALLABLE void adj_curlnoise(uint32 state, const vec2& xy, const uint32 octaves, const float lacunarity, const float gain, uint32& adj_state, vec2& adj_xy, const uint32& adj_octaves, const float& adj_lacunarity, const float& adj_gain, const vec2& adj_ret) {}
-
-inline CUDA_CALLABLE vec3 curlnoise(uint32 state, const vec3& xyz, const uint32 octaves, const float lacunarity, const float gain)
-{
-    vec3 curl_sum_1 = vec3(0.f);
-    vec3 curl_sum_2 = vec3(0.f);
-    vec3 curl_sum_3 = vec3(0.f);
-    
-    float freq = 1.f;
-    float amplitude = 1.f;
-    
-    for(int i = 0; i < octaves; i++)
-    {
-        vec3 pt = freq * xyz;
-        float dx = pt[0] - floor(pt[0]);
-        float dy = pt[1] - floor(pt[1]);
-        float dz = pt[2] - floor(pt[2]);
-
-        int x0 = (int)floor(pt[0]);
-        int y0 = (int)floor(pt[1]);
-        int z0 = (int)floor(pt[2]);
-
-        int x1 = x0 + 1;
-        int y1 = y0 + 1;
-        int z1 = z0 + 1;
-
-        vec3 grad_field_1 = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
-        state = rand_init(state, 10019689);
-        vec3 grad_field_2 = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
-        state = rand_init(state, 13112221);
-        vec3 grad_field_3 = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
-        
-        curl_sum_1 += amplitude * grad_field_1;
-        curl_sum_2 += amplitude * grad_field_2;
-        curl_sum_3 += amplitude * grad_field_3;
-
-        amplitude *= gain;
-        freq *= lacunarity;
-    }
-    
-    return vec3(
-        curl_sum_3[1] - curl_sum_2[2],
-        curl_sum_1[2] - curl_sum_3[0],
-        curl_sum_2[0] - curl_sum_1[1]);
-}
-inline CUDA_CALLABLE void adj_curlnoise(uint32 state, const vec3& xyz, const uint32 octaves, const float lacunarity, const float gain, uint32& adj_state, vec3& adj_xyz, const uint32& adj_octaves, const float& adj_lacunarity, const float& adj_gain, vec3& adj_ret) {}
-
-inline CUDA_CALLABLE vec3 curlnoise(uint32 state, const vec4& xyzt, const uint32 octaves, const float lacunarity, const float gain)
-{
-    vec4 curl_sum_1 = vec4(0.f);
-    vec4 curl_sum_2 = vec4(0.f);
-    vec4 curl_sum_3 = vec4(0.f);
-    
-    float freq = 1.f;
-    float amplitude = 1.f;
-
-    for(int i = 0; i < octaves; i++)
-    {
-        vec4 pt = freq * xyzt;
-        float dx = pt[0] - floor(pt[0]);
-        float dy = pt[1] - floor(pt[1]);
-        float dz = pt[2] - floor(pt[2]);
-        float dt = pt[3] - floor(pt[3]);
-
-        int x0 = (int)floor(pt[0]);
-        int y0 = (int)floor(pt[1]);
-        int z0 = (int)floor(pt[2]);
-        int t0 = (int)floor(pt[3]);
-
-        int x1 = x0 + 1;
-        int y1 = y0 + 1;
-        int z1 = z0 + 1;
-        int t1 = t0 + 1;
-
-        vec4 grad_field_1 = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
-        state = rand_init(state, 10019689);
-        vec4 grad_field_2 = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
-        state = rand_init(state, 13112221);
-        vec4 grad_field_3 = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
-
-        curl_sum_1 += amplitude * grad_field_1;
-        curl_sum_2 += amplitude * grad_field_2;
-        curl_sum_3 += amplitude * grad_field_3;
-
-        amplitude *= gain;
-        freq *= lacunarity;        
-    }
-
-    return vec3(
-        curl_sum_3[1] - curl_sum_2[2],
-        curl_sum_1[2] - curl_sum_3[0],
-        curl_sum_2[0] - curl_sum_1[1]);
-}
-inline CUDA_CALLABLE void adj_curlnoise(uint32 state, const vec4& xyzt, const uint32 octaves, const float lacunarity, const float gain, uint32& adj_state, vec4& adj_xyzt, const uint32& adj_octaves, const float& adj_lacunarity, const float& adj_gain, const vec3& adj_ret) {}
-
-} // namespace wp
+/** Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+#pragma once
+
+#ifndef M_PI_F
+#define M_PI_F 3.14159265358979323846f
+#endif
+
+namespace wp
+{
+
+inline CUDA_CALLABLE float smootherstep(float t)
+{
+    return t * t * t * (t * (t * 6.f - 15.f) + 10.f);
+}
+
+inline CUDA_CALLABLE float smootherstep_gradient(float t)
+{
+    return 30.f * t * t * (t * (t - 2.f) + 1.f);
+}
+
+inline CUDA_CALLABLE float smoothstep(float t)
+{
+    return t * t * (3.f - t * 2.f);
+}
+
+inline CUDA_CALLABLE float smoothstep_gradient(float t)
+{
+    return 6.f * t * (1.f - t);
+}
+
+inline CUDA_CALLABLE float interpolate(float a0, float a1, float t)
+{
+    return (a1 - a0) * smootherstep(t) + a0;
+    // return (a1 - a0) * smoothstep(t) + a0;
+    // return (a1 - a0) * t + a0;
+}
+
+inline CUDA_CALLABLE float interpolate_gradient(float a0, float a1, float t, float d_a0, float d_a1, float d_t)
+{
+    return (d_a1 - d_a0) * smootherstep(t) + (a1 - a0) * smootherstep_gradient(t) * d_t + d_a0;
+    // return (d_a1 - d_a0) * smoothstep(t) + (a1 - a0) * smoothstep_gradient(t) * d_t + d_a0;
+    // return (d_a1 - d_a0) * t + (a1 - a0) * d_t + d_a0;
+}
+
+inline CUDA_CALLABLE vec2 interpolate_gradient_2d(float a0, float a1, float t, vec2& d_a0, vec2& d_a1, vec2& d_t)
+{
+    return (d_a1 - d_a0) * smootherstep(t) + (a1 - a0) * smootherstep_gradient(t) * d_t + d_a0;
+}
+
+inline CUDA_CALLABLE vec3 interpolate_gradient_3d(float a0, float a1, float t, vec3& d_a0, vec3& d_a1, vec3& d_t)
+{
+    return (d_a1 - d_a0) * smootherstep(t) + (a1 - a0) * smootherstep_gradient(t) * d_t + d_a0;
+}
+
+inline CUDA_CALLABLE vec4 interpolate_gradient_4d(float a0, float a1, float t, vec4& d_a0, vec4& d_a1, vec4& d_t)
+{
+    return (d_a1 - d_a0) * smootherstep(t) + (a1 - a0) * smootherstep_gradient(t) * d_t + d_a0;
+}
+
+inline CUDA_CALLABLE float random_gradient_1d(uint32 state, int ix)
+{
+    const uint32 p1 = 73856093;
+    uint32 idx = ix*p1 + state;
+    return randf(idx, -1.f, 1.f);
+}
+
+inline CUDA_CALLABLE vec2 random_gradient_2d(uint32 state, int ix, int iy)
+{
+    const uint32 p1 = 73856093;
+    const uint32 p2 = 19349663;
+    uint32 idx = ix*p1 ^ iy*p2 + state;
+    
+    return normalize(sample_unit_square(idx));
+}
+
+inline CUDA_CALLABLE vec3 random_gradient_3d(uint32 state, int ix, int iy, int iz)
+{
+    const uint32 p1 = 73856093;
+	const uint32 p2 = 19349663;
+    const uint32 p3 = 53471161;
+    uint32 idx = ix*p1 ^ iy*p2 ^ iz*p3 + state;
+
+    return normalize(sample_unit_cube(idx));
+}
+
+inline CUDA_CALLABLE vec4 random_gradient_4d(uint32 state, int ix, int iy, int iz, int it)
+{
+    const uint32 p1 = 73856093;
+	const uint32 p2 = 19349663;
+	const uint32 p3 = 53471161;
+    const uint32 p4 = 10000019;
+    uint32 idx = ix*p1 ^ iy*p2 ^ iz*p3 ^ it*p4 + state;
+
+    return normalize(sample_unit_hypercube(idx));
+}
+
+inline CUDA_CALLABLE float dot_grid_gradient_1d(uint32 state, int ix, float dx)
+{
+    float gradient = random_gradient_1d(state, ix);
+    return dx*gradient;
+}
+
+inline CUDA_CALLABLE float dot_grid_gradient_2d(uint32 state, int ix, int iy, float dx, float dy)
+{
+    vec2 gradient = random_gradient_2d(state, ix, iy);
+    return (dx*gradient[0] + dy*gradient[1]);
+}
+
+inline CUDA_CALLABLE float dot_grid_gradient_3d(uint32 state, int ix, int iy, int iz, float dx, float dy, float dz)
+{
+    vec3 gradient = random_gradient_3d(state, ix, iy, iz);
+    return (dx*gradient[0] + dy*gradient[1] + dz*gradient[2]);
+}
+
+inline CUDA_CALLABLE float dot_grid_gradient_4d(uint32 state, int ix, int iy, int iz, int it, float dx, float dy, float dz, float dt)
+{
+    vec4 gradient = random_gradient_4d(state, ix, iy, iz, it);
+    return (dx*gradient[0] + dy*gradient[1] + dz*gradient[2] + dt*gradient[3]);
+}
+
+inline CUDA_CALLABLE float noise_1d(uint32 state, int x0, int x1, float dx)
+{
+    //vX
+    float v0 = dot_grid_gradient_1d(state, x0, dx);
+    float v1 = dot_grid_gradient_1d(state, x1, dx-1.f);
+
+    return interpolate(v0, v1, dx);
+}
+
+inline CUDA_CALLABLE float noise_1d_gradient(uint32 state, int x0, int x1, float dx)
+{
+    float gradient_x0 = random_gradient_1d(state, x0);
+    float v0 = dx * gradient_x0;
+
+    float gradient_x1 = random_gradient_1d(state, x1);
+    float v1 = (dx-1.f) * gradient_x1;
+
+    return interpolate_gradient(v0, v1, dx, gradient_x0, gradient_x1, 1.f);
+}
+
+inline CUDA_CALLABLE float noise_2d(uint32 state, int x0, int y0, int x1, int y1, float dx, float dy)
+{
+    //vXY
+    float v00 = dot_grid_gradient_2d(state, x0, y0, dx, dy);
+    float v10 = dot_grid_gradient_2d(state, x1, y0, dx-1.f, dy);
+    float xi0 = interpolate(v00, v10, dx);
+
+    float v01 = dot_grid_gradient_2d(state, x0, y1, dx, dy-1.f);
+    float v11 = dot_grid_gradient_2d(state, x1, y1, dx-1.f, dy-1.f);
+    float xi1 = interpolate(v01, v11, dx);
+
+    return interpolate(xi0, xi1, dy);
+}
+
+inline CUDA_CALLABLE vec2 noise_2d_gradient(uint32 state, int x0, int y0, int x1, int y1, float dx, float dy)
+{
+    vec2 d00 = vec2(dx, dy);
+    vec2 gradient_v00 = random_gradient_2d(state, x0, y0);
+    float v00 = dot(d00, gradient_v00);
+
+    vec2 d10 = vec2(dx-1.f, dy);
+    vec2 gradient_v10 = random_gradient_2d(state, x1, y0);
+    float v10 = dot(d10, gradient_v10);
+
+    vec2 d01 = vec2(dx, dy-1.f);
+    vec2 gradient_v01 = random_gradient_2d(state, x0, y1);
+    float v01 = dot(d01, gradient_v01);
+
+    vec2 d11 = vec2(dx-1.f, dy-1.f);
+    vec2 gradient_v11 = random_gradient_2d(state, x1, y1);
+    float v11 = dot(d11, gradient_v11);
+
+    vec2 dx_dt = vec2(1.f, 0.f);
+
+    float xi0 = interpolate(v00, v10, dx);
+    vec2 gradient_xi0 = interpolate_gradient_2d(v00, v10, dx, gradient_v00, gradient_v10, dx_dt);
+
+    float xi1 = interpolate(v01, v11, dx);
+    vec2 gradient_xi1 = interpolate_gradient_2d(v01, v11, dx, gradient_v01, gradient_v11, dx_dt);
+
+    vec2 dy_dt = vec2(0.f, 1.f);
+
+    vec2 gradient = interpolate_gradient_2d(xi0, xi1, dy, gradient_xi0, gradient_xi1, dy_dt);
+
+    return gradient;
+}
+
+inline CUDA_CALLABLE float noise_3d(uint32 state, int x0, int y0, int z0, int x1, int y1, int z1, float dx, float dy, float dz)
+{
+    //vXYZ
+    float v000 = dot_grid_gradient_3d(state, x0, y0, z0, dx, dy, dz);
+    float v100 = dot_grid_gradient_3d(state, x1, y0, z0, dx-1.f, dy, dz);
+    float xi00 = interpolate(v000, v100, dx);
+
+    float v010 = dot_grid_gradient_3d(state, x0, y1, z0, dx, dy-1.f, dz);
+    float v110 = dot_grid_gradient_3d(state, x1, y1, z0, dx-1.f, dy-1.f, dz);
+    float xi10 = interpolate(v010, v110, dx);
+
+    float yi0 = interpolate(xi00, xi10, dy);
+
+    float v001 = dot_grid_gradient_3d(state, x0, y0, z1, dx, dy, dz-1.f);
+    float v101 = dot_grid_gradient_3d(state, x1, y0, z1, dx-1.f, dy, dz-1.f);
+    float xi01 = interpolate(v001, v101, dx);
+
+    float v011 = dot_grid_gradient_3d(state, x0, y1, z1, dx, dy-1.f, dz-1.f);
+    float v111 = dot_grid_gradient_3d(state, x1, y1, z1, dx-1.f, dy-1.f, dz-1.f);
+    float xi11 = interpolate(v011, v111, dx);
+
+    float yi1 = interpolate(xi01, xi11, dy);
+
+    return interpolate(yi0, yi1, dz);
+}
+
+inline CUDA_CALLABLE vec3 noise_3d_gradient(uint32 state, int x0, int y0, int z0, int x1, int y1, int z1, float dx, float dy, float dz)
+{
+    vec3 d000 = vec3(dx, dy, dz);
+    vec3 gradient_v000 = random_gradient_3d(state, x0, y0, z0);
+    float v000 = dot(d000, gradient_v000);
+
+    vec3 d100 = vec3(dx-1.f, dy, dz);
+    vec3 gradient_v100 = random_gradient_3d(state, x1, y0, z0);
+    float v100 = dot(d100, gradient_v100);
+
+    vec3 d010 = vec3(dx, dy-1.f, dz);
+    vec3 gradient_v010 = random_gradient_3d(state, x0, y1, z0);
+    float v010 = dot(d010, gradient_v010);
+    
+    vec3 d110 = vec3(dx-1.f, dy-1.f, dz);
+    vec3 gradient_v110 = random_gradient_3d(state, x1, y1, z0);
+    float v110 = dot(d110, gradient_v110);
+
+    vec3 d001 = vec3(dx, dy, dz-1.f);
+    vec3 gradient_v001 = random_gradient_3d(state, x0, y0, z1);
+    float v001 = dot(d001, gradient_v001);
+
+    vec3 d101 = vec3(dx-1.f, dy, dz-1.f);
+    vec3 gradient_v101 = random_gradient_3d(state, x1, y0, z1);
+    float v101 = dot(d101, gradient_v101);
+
+    vec3 d011 = vec3(dx, dy-1.f, dz-1.f);
+    vec3 gradient_v011 = random_gradient_3d(state, x0, y1, z1);
+    float v011 = dot(d011, gradient_v011);
+
+    vec3 d111 = vec3(dx-1.f, dy-1.f, dz-1.f);
+    vec3 gradient_v111 = random_gradient_3d(state, x1, y1, z1);
+    float v111 = dot(d111, gradient_v111);
+
+    vec3 dx_dt = vec3(1.f, 0.f, 0.f);
+
+    float xi00 = interpolate(v000, v100, dx);
+    vec3 gradient_xi00 = interpolate_gradient_3d(v000, v100, dx, gradient_v000, gradient_v100, dx_dt);
+
+    float xi10 = interpolate(v010, v110, dx);
+    vec3 gradient_xi10 = interpolate_gradient_3d(v010, v110, dx, gradient_v010, gradient_v110, dx_dt);
+    
+    float xi01 = interpolate(v001, v101, dx);
+    vec3 gradient_xi01 = interpolate_gradient_3d(v001, v101, dx, gradient_v001, gradient_v101, dx_dt);
+
+    float xi11 = interpolate(v011, v111, dx);
+    vec3 gradient_xi11 = interpolate_gradient_3d(v011, v111, dx, gradient_v011, gradient_v111, dx_dt);
+
+    vec3 dy_dt = vec3(0.f, 1.f, 0.f);
+
+    float yi0 = interpolate(xi00, xi10, dy);
+    vec3 gradient_yi0 = interpolate_gradient_3d(xi00, xi10, dy, gradient_xi00, gradient_xi10, dy_dt);
+
+    float yi1 = interpolate(xi01, xi11, dy);    
+    vec3 gradient_yi1 = interpolate_gradient_3d(xi01, xi11, dy, gradient_xi01, gradient_xi11, dy_dt);
+
+    vec3 dz_dt = vec3(0.f, 0.f, 1.f);
+
+    vec3 gradient = interpolate_gradient_3d(yi0, yi1, dz, gradient_yi0, gradient_yi1, dz_dt);
+
+    return gradient;
+}
+
+inline CUDA_CALLABLE float noise_4d(uint32 state, int x0, int y0, int z0, int t0, int x1, int y1, int z1, int t1, float dx, float dy, float dz, float dt)
+{
+    //vXYZT
+    float v0000 = dot_grid_gradient_4d(state, x0, y0, z0, t0, dx, dy, dz, dt);
+    float v1000 = dot_grid_gradient_4d(state, x1, y0, z0, t0, dx-1.f, dy, dz, dt);
+    float xi000 = interpolate(v0000, v1000, dx);
+
+    float v0100 = dot_grid_gradient_4d(state, x0, y1, z0, t0, dx, dy-1.f, dz, dt);
+    float v1100 = dot_grid_gradient_4d(state, x1, y1, z0, t0, dx-1.f, dy-1.f, dz, dt);
+    float xi100 = interpolate(v0100, v1100, dx);
+
+    float yi00 = interpolate(xi000, xi100, dy);
+
+    float v0010 = dot_grid_gradient_4d(state, x0, y0, z1, t0, dx, dy, dz-1.f, dt);
+    float v1010 = dot_grid_gradient_4d(state, x1, y0, z1, t0, dx-1.f, dy, dz-1.f, dt);
+    float xi010 = interpolate(v0010, v1010, dx);
+
+    float v0110 = dot_grid_gradient_4d(state, x0, y1, z1, t0, dx, dy-1.f, dz-1.f, dt);
+    float v1110 = dot_grid_gradient_4d(state, x1, y1, z1, t0, dx-1.f, dy-1.f, dz-1.f, dt);
+    float xi110 = interpolate(v0110, v1110, dx);
+
+    float yi10 = interpolate(xi010, xi110, dy);
+
+    float zi0 = interpolate(yi00, yi10, dz);
+
+    float v0001 = dot_grid_gradient_4d(state, x0, y0, z0, t1, dx, dy, dz, dt-1.f);
+    float v1001 = dot_grid_gradient_4d(state, x1, y0, z0, t1, dx-1.f, dy, dz, dt-1.f);
+    float xi001 = interpolate(v0001, v1001, dx);
+
+    float v0101 = dot_grid_gradient_4d(state, x0, y1, z0, t1, dx, dy-1.f, dz, dt-1.f);
+    float v1101 = dot_grid_gradient_4d(state, x1, y1, z0, t1, dx-1.f, dy-1.f, dz, dt-1.f);
+    float xi101 = interpolate(v0101, v1101, dx);
+
+    float yi01 = interpolate(xi001, xi101, dy);
+
+    float v0011 = dot_grid_gradient_4d(state, x0, y0, z1, t1, dx, dy, dz-1.f, dt-1.f);
+    float v1011 = dot_grid_gradient_4d(state, x1, y0, z1, t1, dx-1.f, dy, dz-1.f, dt-1.f);
+    float xi011 = interpolate(v0011, v1011, dx);
+
+    float v0111 = dot_grid_gradient_4d(state, x0, y1, z1, t1, dx, dy-1.f, dz-1.f, dt-1.f);
+    float v1111 = dot_grid_gradient_4d(state, x1, y1, z1, t1, dx-1.f, dy-1.f, dz-1.f, dt-1.f);
+    float xi111 = interpolate(v0111, v1111, dx);
+
+    float yi11 = interpolate(xi011, xi111, dy);
+
+    float zi1 = interpolate(yi01, yi11, dz);
+
+    return interpolate(zi0, zi1, dt);
+}
+
+inline CUDA_CALLABLE vec4 noise_4d_gradient(uint32 state, int x0, int y0, int z0, int t0, int x1, int y1, int z1, int t1, float dx, float dy, float dz, float dt)
+{
+    vec4 d0000 = vec4(dx, dy, dz, dt);
+    vec4 gradient_v0000 = random_gradient_4d(state, x0, y0, z0, t0);
+    float v0000 = dot(d0000, gradient_v0000);
+
+    vec4 d1000 = vec4(dx-1.f, dy, dz, dt);
+    vec4 gradient_v1000 = random_gradient_4d(state, x1, y0, z0, t0);
+    float v1000 = dot(d1000, gradient_v1000);
+
+    vec4 d0100 = vec4(dx, dy-1.f, dz, dt);
+    vec4 gradient_v0100 = random_gradient_4d(state, x0, y1, z0, t0);
+    float v0100 = dot(d0100, gradient_v0100);
+
+    vec4 d1100 = vec4(dx-1.f, dy-1.f, dz, dt);
+    vec4 gradient_v1100 = random_gradient_4d(state, x1, y1, z0, t0);
+    float v1100 = dot(d1100, gradient_v1100);
+
+    vec4 d0010 = vec4(dx, dy, dz-1.f, dt);
+    vec4 gradient_v0010 = random_gradient_4d(state, x0, y0, z1, t0);
+    float v0010 = dot(d0010, gradient_v0010);
+
+    vec4 d1010 = vec4(dx-1.f, dy, dz-1.f, dt);
+    vec4 gradient_v1010 = random_gradient_4d(state, x1, y0, z1, t0);
+    float v1010 = dot(d1010, gradient_v1010);
+
+    vec4 d0110 = vec4(dx, dy-1.f, dz-1.f, dt);
+    vec4 gradient_v0110 = random_gradient_4d(state, x0, y1, z1, t0);
+    float v0110 = dot(d0110, gradient_v0110);
+    
+    vec4 d1110 = vec4(dx-1.f, dy-1.f, dz-1.f, dt);
+    vec4 gradient_v1110 = random_gradient_4d(state, x1, y1, z1, t0);
+    float v1110 = dot(d1110, gradient_v1110);
+
+    vec4 d0001 = vec4(dx, dy, dz, dt-1.f);
+    vec4 gradient_v0001 = random_gradient_4d(state, x0, y0, z0, t1);
+    float v0001 = dot(d0001, gradient_v0001);
+
+    vec4 d1001 = vec4(dx-1.f, dy, dz, dt-1.f);
+    vec4 gradient_v1001 = random_gradient_4d(state, x1, y0, z0, t1);
+    float v1001 = dot(d1001, gradient_v1001);
+
+    vec4 d0101 = vec4(dx, dy-1.f, dz, dt-1.f);
+    vec4 gradient_v0101 = random_gradient_4d(state, x0, y1, z0, t1);
+    float v0101 = dot(d0101, gradient_v0101);
+
+    vec4 d1101 = vec4(dx-1.f, dy-1.f, dz, dt-1.f);
+    vec4 gradient_v1101 = random_gradient_4d(state, x1, y1, z0, t1);
+    float v1101 = dot(d1101, gradient_v1101);
+
+    vec4 d0011 = vec4(dx, dy, dz-1.f, dt-1.f);
+    vec4 gradient_v0011 = random_gradient_4d(state, x0, y0, z1, t1);
+    float v0011 = dot(d0011, gradient_v0011);
+
+    vec4 d1011 = vec4(dx-1.f, dy, dz-1.f, dt-1.f);
+    vec4 gradient_v1011 = random_gradient_4d(state, x1, y0, z1, t1);
+    float v1011 = dot(d1011, gradient_v1011);
+
+    vec4 d0111 = vec4(dx, dy-1.f, dz-1.f, dt-1.f);
+    vec4 gradient_v0111 = random_gradient_4d(state, x0, y1, z1, t1);
+    float v0111 = dot(d0111, gradient_v0111);
+    
+    vec4 d1111 = vec4(dx-1.f, dy-1.f, dz-1.f, dt-1.f);
+    vec4 gradient_v1111 = random_gradient_4d(state, x1, y1, z1, t1);
+    float v1111 = dot(d1111, gradient_v1111);
+
+    vec4 dx_dt = vec4(1.f, 0.f, 0.f, 0.f);
+
+    float xi000 = interpolate(v0000, v1000, dx);
+    vec4 gradient_xi000 = interpolate_gradient_4d(v0000, v1000, dx, gradient_v0000, gradient_v1000, dx_dt);
+
+    float xi100 = interpolate(v0100, v1100, dx);
+    vec4 gradient_xi100 = interpolate_gradient_4d(v0100, v1100, dx, gradient_v0100, gradient_v1100, dx_dt);
+
+    float xi010 = interpolate(v0010, v1010, dx);
+    vec4 gradient_xi010 = interpolate_gradient_4d(v0010, v1010, dx, gradient_v0010, gradient_v1010, dx_dt);
+
+    float xi110 = interpolate(v0110, v1110, dx);
+    vec4 gradient_xi110 = interpolate_gradient_4d(v0110, v1110, dx, gradient_v0110, gradient_v1110, dx_dt);
+
+    float xi001 = interpolate(v0001, v1001, dx);
+    vec4 gradient_xi001 = interpolate_gradient_4d(v0001, v1001, dx, gradient_v0001, gradient_v1001, dx_dt);
+
+    float xi101 = interpolate(v0101, v1101, dx);
+    vec4 gradient_xi101 = interpolate_gradient_4d(v0101, v1101, dx, gradient_v0101, gradient_v1101, dx_dt);
+
+    float xi011 = interpolate(v0011, v1011, dx);
+    vec4 gradient_xi011 = interpolate_gradient_4d(v0011, v1011, dx, gradient_v0011, gradient_v1011, dx_dt);
+    
+    float xi111 = interpolate(v0111, v1111, dx);
+    vec4 gradient_xi111 = interpolate_gradient_4d(v0111, v1111, dx, gradient_v0111, gradient_v1111, dx_dt);
+    
+    vec4 dy_dt = vec4(0.f, 1.f, 0.f, 0.f);
+
+    float yi00 = interpolate(xi000, xi100, dy);
+    vec4 gradient_yi00 = interpolate_gradient_4d(xi000, xi100, dy, gradient_xi000, gradient_xi100, dy_dt);
+
+    float yi10 = interpolate(xi010, xi110, dy);
+    vec4 gradient_yi10 = interpolate_gradient_4d(xi010, xi110, dy, gradient_xi010, gradient_xi110, dy_dt);
+
+    float yi01 = interpolate(xi001, xi101, dy);
+    vec4 gradient_yi01 = interpolate_gradient_4d(xi001, xi101, dy, gradient_xi001, gradient_xi101, dy_dt);
+
+    float yi11 = interpolate(xi011, xi111, dy);
+    vec4 gradient_yi11 = interpolate_gradient_4d(xi011, xi111, dy, gradient_xi011, gradient_xi111, dy_dt);
+
+    vec4 dz_dt = vec4(0.f, 0.f, 1.f, 0.f);
+
+    float zi0 = interpolate(yi00, yi10, dz);
+    vec4 gradient_zi0 = interpolate_gradient_4d(yi00, yi10, dz, gradient_yi00, gradient_yi10, dz_dt);
+
+    float zi1 = interpolate(yi01, yi11, dz);
+    vec4 gradient_zi1 = interpolate_gradient_4d(yi01, yi11, dz, gradient_yi01, gradient_yi11, dz_dt);
+
+    vec4 dt_dt = vec4(0.f, 0.f, 0.f, 1.f);
+
+    vec4 gradient = interpolate_gradient_4d(zi0, zi1, dt, gradient_zi0, gradient_zi1, dt_dt);
+
+    return gradient;
+}
+
+// non-periodic Perlin noise
+
+inline CUDA_CALLABLE float noise(uint32 state, float x)
+{
+    float dx = x - floor(x);
+
+    int x0 = (int)floor(x);
+    int x1 = x0 + 1;
+
+    return noise_1d(state, x0, x1, dx);
+}
+
+inline CUDA_CALLABLE void adj_noise(uint32 state, float x, uint32& adj_state, float& adj_x, const float adj_ret)
+{
+    float dx = x - floor(x);
+
+    int x0 = (int)floor(x);
+    int x1 = x0 + 1;
+
+    float gradient = noise_1d_gradient(state, x0, x1, dx);
+    adj_x += gradient * adj_ret;
+}
+
+inline CUDA_CALLABLE float noise(uint32 state, const vec2& xy)
+{
+    float dx = xy[0] - floor(xy[0]);
+    float dy = xy[1] - floor(xy[1]);
+
+    int x0 = (int)floor(xy[0]); 
+    int y0 = (int)floor(xy[1]); 
+
+    int x1 = x0 + 1;
+    int y1 = y0 + 1;
+
+    return noise_2d(state, x0, y0, x1, y1, dx, dy);
+}
+
+inline CUDA_CALLABLE void adj_noise(uint32 state, const vec2& xy, uint32& adj_state, vec2& adj_xy, const float adj_ret)
+{
+    float dx = xy[0] - floor(xy[0]);
+    float dy = xy[1] - floor(xy[1]);
+
+    int x0 = (int)floor(xy[0]); 
+    int y0 = (int)floor(xy[1]); 
+
+    int x1 = x0 + 1;
+    int y1 = y0 + 1;
+
+    vec2 gradient = noise_2d_gradient(state, x0, y0, x1, y1, dx, dy);
+
+    adj_xy[0] += gradient[0] * adj_ret;
+    adj_xy[1] += gradient[1] * adj_ret;
+}
+
+inline CUDA_CALLABLE float noise(uint32 state, const vec3& xyz)
+{
+    float dx = xyz[0] - floor(xyz[0]);
+    float dy = xyz[1] - floor(xyz[1]);
+    float dz = xyz[2] - floor(xyz[2]);
+
+    int x0 = (int)floor(xyz[0]);
+    int y0 = (int)floor(xyz[1]);
+    int z0 = (int)floor(xyz[2]);
+
+    int x1 = x0 + 1;
+    int y1 = y0 + 1;
+    int z1 = z0 + 1;
+
+    return noise_3d(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
+}
+
+inline CUDA_CALLABLE void adj_noise(uint32 state, const vec3& xyz, uint32& adj_state, vec3& adj_xyz, const float adj_ret)
+{
+    float dx = xyz[0] - floor(xyz[0]);
+    float dy = xyz[1] - floor(xyz[1]);
+    float dz = xyz[2] - floor(xyz[2]);
+
+    int x0 = (int)floor(xyz[0]);
+    int y0 = (int)floor(xyz[1]);
+    int z0 = (int)floor(xyz[2]);
+
+    int x1 = x0 + 1;
+    int y1 = y0 + 1;
+    int z1 = z0 + 1;
+
+    vec3 gradient = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
+    adj_xyz[0] += gradient[0] * adj_ret;
+    adj_xyz[1] += gradient[1] * adj_ret;
+    adj_xyz[2] += gradient[2] * adj_ret;
+}
+
+inline CUDA_CALLABLE float noise(uint32 state, const vec4& xyzt)
+{
+    float dx = xyzt[0] - floor(xyzt[0]);
+    float dy = xyzt[1] - floor(xyzt[1]);
+    float dz = xyzt[2] - floor(xyzt[2]);
+    float dt = xyzt[3] - floor(xyzt[3]);
+
+    int x0 = (int)floor(xyzt[0]);
+    int y0 = (int)floor(xyzt[1]);
+    int z0 = (int)floor(xyzt[2]);
+    int t0 = (int)floor(xyzt[3]);
+
+    int x1 = x0 + 1;
+    int y1 = y0 + 1;
+    int z1 = z0 + 1;
+    int t1 = t0 + 1;
+
+    return noise_4d(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
+}
+
+inline CUDA_CALLABLE void adj_noise(uint32 state, const vec4& xyzt, uint32& adj_state, vec4& adj_xyzt, const float adj_ret)
+{
+    float dx = xyzt[0] - floor(xyzt[0]);
+    float dy = xyzt[1] - floor(xyzt[1]);
+    float dz = xyzt[2] - floor(xyzt[2]);
+    float dt = xyzt[3] - floor(xyzt[3]);
+
+    int x0 = (int)floor(xyzt[0]);
+    int y0 = (int)floor(xyzt[1]);
+    int z0 = (int)floor(xyzt[2]);
+    int t0 = (int)floor(xyzt[3]);
+
+    int x1 = x0 + 1;
+    int y1 = y0 + 1;
+    int z1 = z0 + 1;
+    int t1 = t0 + 1;
+
+    vec4 gradient = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
+
+    adj_xyzt[0] += gradient[0] * adj_ret;
+    adj_xyzt[1] += gradient[1] * adj_ret;
+    adj_xyzt[2] += gradient[2] * adj_ret;
+    adj_xyzt[3] += gradient[3] * adj_ret;
+}
+
+// periodic Perlin noise
+
+inline CUDA_CALLABLE float pnoise(uint32 state, float x, int px)
+{
+    float dx = x - floor(x);
+
+    int x0 = mod(((int)floor(x)), px);
+    int x1 = mod((x0 + 1), px);
+
+    return noise_1d(state, x0, x1, dx);
+}
+
+inline CUDA_CALLABLE void adj_pnoise(uint32 state, float x, int px, uint32& adj_state, float& adj_x, int& adj_px, const float adj_ret)
+{
+    float dx = x - floor(x);
+
+    int x0 = mod(((int)floor(x)), px);
+    int x1 = mod((x0 + 1), px);
+
+    float gradient = noise_1d_gradient(state, x0, x1, dx);
+    adj_x += gradient * adj_ret;
+}
+
+inline CUDA_CALLABLE float pnoise(uint32 state, const vec2& xy, int px, int py)
+{
+    float dx = xy[0] - floor(xy[0]);
+    float dy = xy[1] - floor(xy[1]);
+
+    int x0 = mod(((int)floor(xy[0])), px); 
+    int y0 = mod(((int)floor(xy[1])), py); 
+
+    int x1 = mod((x0 + 1), px);
+    int y1 = mod((y0 + 1), py);
+
+    return noise_2d(state, x0, y0, x1, y1, dx, dy);
+}
+
+inline CUDA_CALLABLE void adj_pnoise(uint32 state, const vec2& xy, int px, int py, uint32& adj_state, vec2& adj_xy, int& adj_px, int& adj_py, const float adj_ret)
+{
+    float dx = xy[0] - floor(xy[0]);
+    float dy = xy[1] - floor(xy[1]);
+
+    int x0 = mod(((int)floor(xy[0])), px); 
+    int y0 = mod(((int)floor(xy[1])), py); 
+
+    int x1 = mod((x0 + 1), px);
+    int y1 = mod((y0 + 1), py);
+
+    vec2 gradient = noise_2d_gradient(state, x0, y0, x1, y1, dx, dy);
+
+    adj_xy[0] += gradient[0] * adj_ret;
+    adj_xy[1] += gradient[1] * adj_ret;
+}
+
+inline CUDA_CALLABLE float pnoise(uint32 state, const vec3& xyz, int px, int py, int pz)
+{
+    float dx = xyz[0] - floor(xyz[0]);
+    float dy = xyz[1] - floor(xyz[1]);
+    float dz = xyz[2] - floor(xyz[2]);
+
+    int x0 = mod(((int)floor(xyz[0])), px); 
+    int y0 = mod(((int)floor(xyz[1])), py); 
+    int z0 = mod(((int)floor(xyz[2])), pz); 
+
+    int x1 = mod((x0 + 1), px);
+    int y1 = mod((y0 + 1), py);
+    int z1 = mod((z0 + 1), pz);
+
+    return noise_3d(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
+}
+
+inline CUDA_CALLABLE void adj_pnoise(uint32 state, const vec3& xyz, int px, int py, int pz, uint32& adj_state, vec3& adj_xyz, int& adj_px, int& adj_py, int& adj_pz, const float adj_ret)
+{
+    float dx = xyz[0] - floor(xyz[0]);
+    float dy = xyz[1] - floor(xyz[1]);
+    float dz = xyz[2] - floor(xyz[2]);
+
+    int x0 = mod(((int)floor(xyz[0])), px); 
+    int y0 = mod(((int)floor(xyz[1])), py); 
+    int z0 = mod(((int)floor(xyz[2])), pz); 
+
+    int x1 = mod((x0 + 1), px);
+    int y1 = mod((y0 + 1), py);
+    int z1 = mod((z0 + 1), pz);
+
+    vec3 gradient = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
+    adj_xyz[0] += gradient[0] * adj_ret;
+    adj_xyz[1] += gradient[1] * adj_ret;
+    adj_xyz[2] += gradient[2] * adj_ret;
+}
+
+inline CUDA_CALLABLE float pnoise(uint32 state, const vec4& xyzt, int px, int py, int pz, int pt)
+{
+    float dx = xyzt[0] - floor(xyzt[0]);
+    float dy = xyzt[1] - floor(xyzt[1]);
+    float dz = xyzt[2] - floor(xyzt[2]);
+    float dt = xyzt[3] - floor(xyzt[3]);
+
+    int x0 = mod(((int)floor(xyzt[0])), px);
+    int y0 = mod(((int)floor(xyzt[1])), py);
+    int z0 = mod(((int)floor(xyzt[2])), pz);
+    int t0 = mod(((int)floor(xyzt[3])), pt);
+
+    int x1 = mod((x0 + 1), px);
+    int y1 = mod((y0 + 1), py);
+    int z1 = mod((z0 + 1), pz);
+    int t1 = mod((t0 + 1), pt);
+
+    return noise_4d(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
+}
+
+inline CUDA_CALLABLE void adj_pnoise(uint32 state, const vec4& xyzt, int px, int py, int pz, int pt, uint32& adj_state, vec4& adj_xyzt, int& adj_px, int& adj_py, int& adj_pz, int& adj_pt, const float adj_ret)
+{
+    float dx = xyzt[0] - floor(xyzt[0]);
+    float dy = xyzt[1] - floor(xyzt[1]);
+    float dz = xyzt[2] - floor(xyzt[2]);
+    float dt = xyzt[3] - floor(xyzt[3]);
+
+    int x0 = mod(((int)floor(xyzt[0])), px);
+    int y0 = mod(((int)floor(xyzt[1])), py);
+    int z0 = mod(((int)floor(xyzt[2])), pz);
+    int t0 = mod(((int)floor(xyzt[3])), pt);
+
+    int x1 = mod((x0 + 1), px);
+    int y1 = mod((y0 + 1), py);
+    int z1 = mod((z0 + 1), pz);
+    int t1 = mod((t0 + 1), pt);
+
+    vec4 gradient = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
+
+    adj_xyzt[0] += gradient[0] * adj_ret;
+    adj_xyzt[1] += gradient[1] * adj_ret;
+    adj_xyzt[2] += gradient[2] * adj_ret;
+    adj_xyzt[3] += gradient[3] * adj_ret;
+}
+
+// curl noise
+
+inline CUDA_CALLABLE vec2 curlnoise(uint32 state, const vec2& xy, const uint32 octaves, const float lacunarity, const float gain)
+{
+    vec2 curl_sum = vec2(0.f);
+    float freq = 1.f;
+    float amplitude = 1.f;
+
+    for (int i = 0; i < octaves; i++)
+    {
+        vec2 pt = freq * xy;
+        float dx = pt[0] - floor(pt[0]);
+        float dy = pt[1] - floor(pt[1]);
+
+        int x0 = (int)floor(pt[0]); 
+        int y0 = (int)floor(pt[1]); 
+
+        int x1 = x0 + 1;
+        int y1 = y0 + 1;
+
+        vec2 grad_field = noise_2d_gradient(state, x0, y0, x1, y1, dx, dy);
+        curl_sum += amplitude * grad_field;
+
+        amplitude *= gain;
+        freq *= lacunarity;
+    }
+    return vec2(-curl_sum[1], curl_sum[0]);
+}
+inline CUDA_CALLABLE void adj_curlnoise(uint32 state, const vec2& xy, const uint32 octaves, const float lacunarity, const float gain, uint32& adj_state, vec2& adj_xy, const uint32& adj_octaves, const float& adj_lacunarity, const float& adj_gain, const vec2& adj_ret) {}
+
+inline CUDA_CALLABLE vec3 curlnoise(uint32 state, const vec3& xyz, const uint32 octaves, const float lacunarity, const float gain)
+{
+    vec3 curl_sum_1 = vec3(0.f);
+    vec3 curl_sum_2 = vec3(0.f);
+    vec3 curl_sum_3 = vec3(0.f);
+    
+    float freq = 1.f;
+    float amplitude = 1.f;
+    
+    for(int i = 0; i < octaves; i++)
+    {
+        vec3 pt = freq * xyz;
+        float dx = pt[0] - floor(pt[0]);
+        float dy = pt[1] - floor(pt[1]);
+        float dz = pt[2] - floor(pt[2]);
+
+        int x0 = (int)floor(pt[0]);
+        int y0 = (int)floor(pt[1]);
+        int z0 = (int)floor(pt[2]);
+
+        int x1 = x0 + 1;
+        int y1 = y0 + 1;
+        int z1 = z0 + 1;
+
+        vec3 grad_field_1 = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
+        state = rand_init(state, 10019689);
+        vec3 grad_field_2 = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
+        state = rand_init(state, 13112221);
+        vec3 grad_field_3 = noise_3d_gradient(state, x0, y0, z0, x1, y1, z1, dx, dy, dz);
+        
+        curl_sum_1 += amplitude * grad_field_1;
+        curl_sum_2 += amplitude * grad_field_2;
+        curl_sum_3 += amplitude * grad_field_3;
+
+        amplitude *= gain;
+        freq *= lacunarity;
+    }
+    
+    return vec3(
+        curl_sum_3[1] - curl_sum_2[2],
+        curl_sum_1[2] - curl_sum_3[0],
+        curl_sum_2[0] - curl_sum_1[1]);
+}
+inline CUDA_CALLABLE void adj_curlnoise(uint32 state, const vec3& xyz, const uint32 octaves, const float lacunarity, const float gain, uint32& adj_state, vec3& adj_xyz, const uint32& adj_octaves, const float& adj_lacunarity, const float& adj_gain, vec3& adj_ret) {}
+
+inline CUDA_CALLABLE vec3 curlnoise(uint32 state, const vec4& xyzt, const uint32 octaves, const float lacunarity, const float gain)
+{
+    vec4 curl_sum_1 = vec4(0.f);
+    vec4 curl_sum_2 = vec4(0.f);
+    vec4 curl_sum_3 = vec4(0.f);
+    
+    float freq = 1.f;
+    float amplitude = 1.f;
+
+    for(int i = 0; i < octaves; i++)
+    {
+        vec4 pt = freq * xyzt;
+        float dx = pt[0] - floor(pt[0]);
+        float dy = pt[1] - floor(pt[1]);
+        float dz = pt[2] - floor(pt[2]);
+        float dt = pt[3] - floor(pt[3]);
+
+        int x0 = (int)floor(pt[0]);
+        int y0 = (int)floor(pt[1]);
+        int z0 = (int)floor(pt[2]);
+        int t0 = (int)floor(pt[3]);
+
+        int x1 = x0 + 1;
+        int y1 = y0 + 1;
+        int z1 = z0 + 1;
+        int t1 = t0 + 1;
+
+        vec4 grad_field_1 = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
+        state = rand_init(state, 10019689);
+        vec4 grad_field_2 = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
+        state = rand_init(state, 13112221);
+        vec4 grad_field_3 = noise_4d_gradient(state, x0, y0, z0, t0, x1, y1, z1, t1, dx, dy, dz, dt);
+
+        curl_sum_1 += amplitude * grad_field_1;
+        curl_sum_2 += amplitude * grad_field_2;
+        curl_sum_3 += amplitude * grad_field_3;
+
+        amplitude *= gain;
+        freq *= lacunarity;        
+    }
+
+    return vec3(
+        curl_sum_3[1] - curl_sum_2[2],
+        curl_sum_1[2] - curl_sum_3[0],
+        curl_sum_2[0] - curl_sum_1[1]);
+}
+inline CUDA_CALLABLE void adj_curlnoise(uint32 state, const vec4& xyzt, const uint32 octaves, const float lacunarity, const float gain, uint32& adj_state, vec4& adj_xyzt, const uint32& adj_octaves, const float& adj_lacunarity, const float& adj_gain, const vec3& adj_ret) {}
+
+} // namespace wp