@takram/three-clouds 0.1.0

package/src/shaders/perlin.glsl

@@ -0,0 +1,211 @@
+// Ported from GLM: https://github.com/g-truc/glm/blob/master/glm/gtc/noise.inl
+
+/**
+ * OpenGL Mathematics (GLM)
+ *
+ * GLM is licensed under The Happy Bunny License or MIT License
+ *
+ * The Happy Bunny License (Modified MIT License)
+ *
+ * Copyright (c) 2005 - G-Truc Creation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * Restrictions:
+ *  By making use of the Software for military purposes, you choose to make a
+ *  Bunny unhappy.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * The MIT License
+ *
+ * Copyright (c) 2005 - G-Truc Creation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+vec4 mod289(const vec4 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec4 permute(const vec4 v) {
+  return mod289((v * 34.0 + 1.0) * v);
+}
+
+vec4 taylorInvSqrt(const vec4 r) {
+  return 1.79284291400159 - 0.85373472095314 * r;
+}
+
+vec4 fade(const vec4 v) {
+  return v * v * v * (v * (v * 6.0 - 15.0) + 10.0);
+}
+
+// Classic Perlin noise, periodic version
+float perlin(const vec4 position, const vec4 rep) {
+  vec4 Pi0 = mod(floor(position), rep); // Integer part modulo rep
+  vec4 Pi1 = mod(Pi0 + 1.0, rep); // Integer part + 1 mod rep
+  vec4 Pf0 = fract(position); // Fractional part for interpolation
+  vec4 Pf1 = Pf0 - 1.0; // Fractional part - 1.0
+  vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+  vec4 iy = vec4(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+  vec4 iz0 = vec4(Pi0.z);
+  vec4 iz1 = vec4(Pi1.z);
+  vec4 iw0 = vec4(Pi0.w);
+  vec4 iw1 = vec4(Pi1.w);
+
+  vec4 ixy = permute(permute(ix) + iy);
+  vec4 ixy0 = permute(ixy + iz0);
+  vec4 ixy1 = permute(ixy + iz1);
+  vec4 ixy00 = permute(ixy0 + iw0);
+  vec4 ixy01 = permute(ixy0 + iw1);
+  vec4 ixy10 = permute(ixy1 + iw0);
+  vec4 ixy11 = permute(ixy1 + iw1);
+
+  vec4 gx00 = ixy00 / 7.0;
+  vec4 gy00 = floor(gx00) / 7.0;
+  vec4 gz00 = floor(gy00) / 6.0;
+  gx00 = fract(gx00) - 0.5;
+  gy00 = fract(gy00) - 0.5;
+  gz00 = fract(gz00) - 0.5;
+  vec4 gw00 = vec4(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
+  vec4 sw00 = step(gw00, vec4(0));
+  gx00 -= sw00 * (step(0.0, gx00) - 0.5);
+  gy00 -= sw00 * (step(0.0, gy00) - 0.5);
+
+  vec4 gx01 = ixy01 / 7.0;
+  vec4 gy01 = floor(gx01) / 7.0;
+  vec4 gz01 = floor(gy01) / 6.0;
+  gx01 = fract(gx01) - 0.5;
+  gy01 = fract(gy01) - 0.5;
+  gz01 = fract(gz01) - 0.5;
+  vec4 gw01 = vec4(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
+  vec4 sw01 = step(gw01, vec4(0.0));
+  gx01 -= sw01 * (step(0.0, gx01) - 0.5);
+  gy01 -= sw01 * (step(0.0, gy01) - 0.5);
+
+  vec4 gx10 = ixy10 / 7.0;
+  vec4 gy10 = floor(gx10) / 7.0;
+  vec4 gz10 = floor(gy10) / 6.0;
+  gx10 = fract(gx10) - 0.5;
+  gy10 = fract(gy10) - 0.5;
+  gz10 = fract(gz10) - 0.5;
+  vec4 gw10 = vec4(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
+  vec4 sw10 = step(gw10, vec4(0.0));
+  gx10 -= sw10 * (step(0.0, gx10) - 0.5);
+  gy10 -= sw10 * (step(0.0, gy10) - 0.5);
+
+  vec4 gx11 = ixy11 / 7.0;
+  vec4 gy11 = floor(gx11) / 7.0;
+  vec4 gz11 = floor(gy11) / 6.0;
+  gx11 = fract(gx11) - 0.5;
+  gy11 = fract(gy11) - 0.5;
+  gz11 = fract(gz11) - 0.5;
+  vec4 gw11 = vec4(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
+  vec4 sw11 = step(gw11, vec4(0.0));
+  gx11 -= sw11 * (step(0.0, gx11) - 0.5);
+  gy11 -= sw11 * (step(0.0, gy11) - 0.5);
+
+  vec4 g0000 = vec4(gx00.x, gy00.x, gz00.x, gw00.x);
+  vec4 g1000 = vec4(gx00.y, gy00.y, gz00.y, gw00.y);
+  vec4 g0100 = vec4(gx00.z, gy00.z, gz00.z, gw00.z);
+  vec4 g1100 = vec4(gx00.w, gy00.w, gz00.w, gw00.w);
+  vec4 g0010 = vec4(gx10.x, gy10.x, gz10.x, gw10.x);
+  vec4 g1010 = vec4(gx10.y, gy10.y, gz10.y, gw10.y);
+  vec4 g0110 = vec4(gx10.z, gy10.z, gz10.z, gw10.z);
+  vec4 g1110 = vec4(gx10.w, gy10.w, gz10.w, gw10.w);
+  vec4 g0001 = vec4(gx01.x, gy01.x, gz01.x, gw01.x);
+  vec4 g1001 = vec4(gx01.y, gy01.y, gz01.y, gw01.y);
+  vec4 g0101 = vec4(gx01.z, gy01.z, gz01.z, gw01.z);
+  vec4 g1101 = vec4(gx01.w, gy01.w, gz01.w, gw01.w);
+  vec4 g0011 = vec4(gx11.x, gy11.x, gz11.x, gw11.x);
+  vec4 g1011 = vec4(gx11.y, gy11.y, gz11.y, gw11.y);
+  vec4 g0111 = vec4(gx11.z, gy11.z, gz11.z, gw11.z);
+  vec4 g1111 = vec4(gx11.w, gy11.w, gz11.w, gw11.w);
+
+  vec4 norm00 = taylorInvSqrt(
+    vec4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100))
+  );
+  g0000 *= norm00.x;
+  g0100 *= norm00.y;
+  g1000 *= norm00.z;
+  g1100 *= norm00.w;
+
+  vec4 norm01 = taylorInvSqrt(
+    vec4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101))
+  );
+  g0001 *= norm01.x;
+  g0101 *= norm01.y;
+  g1001 *= norm01.z;
+  g1101 *= norm01.w;
+
+  vec4 norm10 = taylorInvSqrt(
+    vec4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110))
+  );
+  g0010 *= norm10.x;
+  g0110 *= norm10.y;
+  g1010 *= norm10.z;
+  g1110 *= norm10.w;
+
+  vec4 norm11 = taylorInvSqrt(
+    vec4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111))
+  );
+  g0011 *= norm11.x;
+  g0111 *= norm11.y;
+  g1011 *= norm11.z;
+  g1111 *= norm11.w;
+
+  float n0000 = dot(g0000, Pf0);
+  float n1000 = dot(g1000, vec4(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
+  float n0100 = dot(g0100, vec4(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
+  float n1100 = dot(g1100, vec4(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
+  float n0010 = dot(g0010, vec4(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
+  float n1010 = dot(g1010, vec4(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+  float n0110 = dot(g0110, vec4(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
+  float n1110 = dot(g1110, vec4(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
+  float n0001 = dot(g0001, vec4(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
+  float n1001 = dot(g1001, vec4(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
+  float n0101 = dot(g0101, vec4(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+  float n1101 = dot(g1101, vec4(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
+  float n0011 = dot(g0011, vec4(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
+  float n1011 = dot(g1011, vec4(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
+  float n0111 = dot(g0111, vec4(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
+  float n1111 = dot(g1111, Pf1);
+
+  vec4 fade_xyzw = fade(Pf0);
+  vec4 n_0w = mix(vec4(n0000, n1000, n0100, n1100), vec4(n0001, n1001, n0101, n1101), fade_xyzw.w);
+  vec4 n_1w = mix(vec4(n0010, n1010, n0110, n1110), vec4(n0011, n1011, n0111, n1111), fade_xyzw.w);
+  vec4 n_zw = mix(n_0w, n_1w, fade_xyzw.z);
+  vec2 n_yzw = mix(n_zw.xy, n_zw.zw, fade_xyzw.y);
+  float n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
+  return 2.2 * n_xyzw;
+}

package/src/shaders/shadow.frag

@@ -0,0 +1,197 @@
+precision highp float;
+precision highp sampler3D;
+
+#include <common>
+
+#include "core/math"
+#include "core/raySphereIntersection"
+#include "types"
+#include "parameters"
+#include "structuredSampling"
+#include "clouds"
+
+uniform mat4 inverseShadowMatrices[CASCADE_COUNT];
+uniform mat4 reprojectionMatrices[CASCADE_COUNT];
+
+// Primary raymarch
+uniform int maxIterationCount;
+uniform float minStepSize;
+uniform float maxStepSize;
+uniform float opticalDepthTailScale;
+
+in vec2 vUv;
+in vec3 vEllipsoidCenter;
+
+layout(location = 0) out vec4 outputColor[CASCADE_COUNT];
+
+// Redundant notation for prettier.
+#if CASCADE_COUNT == 1
+layout(location = 1) out vec3 outputDepthVelocity[CASCADE_COUNT];
+#elif CASCADE_COUNT == 2
+layout(location = 2) out vec3 outputDepthVelocity[CASCADE_COUNT];
+#elif CASCADE_COUNT == 3
+layout(location = 3) out vec3 outputDepthVelocity[CASCADE_COUNT];
+#elif CASCADE_COUNT == 4
+layout(location = 4) out vec3 outputDepthVelocity[CASCADE_COUNT];
+#endif // CASCADE_COUNT
+
+vec4 marchClouds(
+  const vec3 rayOrigin,
+  const vec3 rayDirection,
+  const float maxRayDistance,
+  const float jitter,
+  const float mipLevel
+) {
+  // Setup structured volume sampling (SVS).
+  // While SVS introduces spatial aliasing, it is indeed temporally stable,
+  // which is important for lower-resolution shadow maps where a flickering
+  // single pixel can be highly noticeable.
+  vec3 normal = getStructureNormal(rayDirection, jitter);
+  float rayDistance;
+  float stepSize;
+  intersectStructuredPlanes(
+    normal,
+    rayOrigin,
+    rayDirection,
+    clamp(maxRayDistance / float(maxIterationCount), minStepSize, maxStepSize),
+    rayDistance,
+    stepSize
+  );
+
+  #ifdef TEMPORAL_JITTER
+  rayDistance -= stepSize * jitter;
+  #endif // TEMPORAL_JITTER
+
+  float extinctionSum = 0.0;
+  float maxOpticalDepth = 0.0;
+  float maxOpticalDepthTail = 0.0;
+  float transmittanceIntegral = 1.0;
+  float weightedDistanceSum = 0.0;
+  float transmittanceSum = 0.0;
+
+  int sampleCount = 0;
+  for (int i = 0; i < maxIterationCount; ++i) {
+    if (rayDistance > maxRayDistance) {
+      break; // Termination
+    }
+
+    vec3 position = rayDistance * rayDirection + rayOrigin;
+    float height = length(position) - bottomRadius;
+
+    #if !defined(DEBUG_MARCH_INTERVALS)
+    if (insideLayerIntervals(height)) {
+      rayDistance += stepSize;
+      continue;
+    }
+    #endif // !defined(DEBUG_MARCH_INTERVALS)
+
+    // Sample rough weather.
+    vec2 uv = getGlobeUv(position);
+    WeatherSample weather = sampleWeather(uv, height, mipLevel);
+
+    if (any(greaterThan(weather.density, vec4(minDensity)))) {
+      // Sample detailed participating media.
+      // Note this assumes an homogeneous medium.
+      MediaSample media = sampleMedia(weather, position, uv, mipLevel, jitter);
+      if (media.extinction > minExtinction) {
+        extinctionSum += media.extinction;
+        maxOpticalDepth += media.extinction * stepSize;
+        transmittanceIntegral *= exp(-media.extinction * stepSize);
+        weightedDistanceSum += rayDistance * transmittanceIntegral;
+        transmittanceSum += transmittanceIntegral;
+        ++sampleCount;
+      }
+    }
+
+    if (transmittanceIntegral <= minTransmittance) {
+      // A large amount of optical depth accumulates in the tail, beyond the
+      // point of minimum transmittance. The expected optical depth seems to
+      // decrease exponentially with the number of samples taken before reaching
+      // the minimum transmittance.
+      // See the discussion here: https://x.com/shotamatsuda/status/1886259549931520437
+      maxOpticalDepthTail = min(
+        opticalDepthTailScale * stepSize * exp(float(1 - sampleCount)),
+        stepSize * 0.5 // Excessive optical depth only introduces aliasing.
+      );
+      break; // Early termination
+    }
+    rayDistance += stepSize;
+  }
+
+  if (sampleCount == 0) {
+    return vec4(maxRayDistance, 0.0, 0.0, 0.0);
+  }
+  float frontDepth = min(weightedDistanceSum / transmittanceSum, maxRayDistance);
+  float meanExtinction = extinctionSum / float(sampleCount);
+  return vec4(frontDepth, meanExtinction, maxOpticalDepth, maxOpticalDepthTail);
+}
+
+void getRayNearFar(
+  const vec3 sunPosition,
+  const vec3 rayDirection,
+  out float rayNear,
+  out float rayFar
+) {
+  vec4 firstIntersections = raySphereFirstIntersection(
+    sunPosition,
+    rayDirection,
+    vec3(0.0),
+    bottomRadius + vec4(shadowTopHeight, shadowBottomHeight, 0.0, 0.0)
+  );
+  rayNear = max(0.0, firstIntersections.x);
+  rayFar = firstIntersections.y;
+  if (rayFar < 0.0) {
+    rayFar = 1e6;
+  }
+}
+
+void cascade(
+  const int cascadeIndex,
+  const float mipLevel,
+  out vec4 outputColor,
+  out vec3 outputDepthVelocity
+) {
+  vec2 clip = vUv * 2.0 - 1.0;
+  vec4 point = inverseShadowMatrices[cascadeIndex] * vec4(clip.xy, -1.0, 1.0);
+  point /= point.w;
+  vec3 sunPosition = mat3(inverseEllipsoidMatrix) * point.xyz - vEllipsoidCenter;
+
+  // The sun direction is in ECEF. Since the view matrix is constructed with the
+  // ellipsoid matrix already applied, there's no need to apply the inverse
+  // matrix here.
+  vec3 rayDirection = normalize(-sunDirection);
+  float rayNear;
+  float rayFar;
+  getRayNearFar(sunPosition, rayDirection, rayNear, rayFar);
+
+  vec3 rayOrigin = rayNear * rayDirection + sunPosition;
+  float stbn = getSTBN();
+  vec4 color = marchClouds(rayOrigin, rayDirection, rayFar - rayNear, stbn, mipLevel);
+  outputColor = color;
+
+  // Velocity for temporal resolution.
+  #ifdef TEMPORAL_PASS
+  vec3 frontPosition = color.x * rayDirection + rayOrigin;
+  vec3 frontPositionWorld = mat3(ellipsoidMatrix) * (frontPosition + vEllipsoidCenter);
+  vec4 prevClip = reprojectionMatrices[cascadeIndex] * vec4(frontPositionWorld, 1.0);
+  prevClip /= prevClip.w;
+  vec2 prevUv = prevClip.xy * 0.5 + 0.5;
+  vec2 velocity = (vUv - prevUv) * resolution;
+  outputDepthVelocity = vec3(color.x, velocity);
+  #else // TEMPORAL_PASS
+  outputDepthVelocity = vec3(0.0);
+  #endif // TEMPORAL_PASS
+}
+
+// TODO: Calculate from the main camera frustum perhaps?
+const float mipLevels[4] = float[4](0.0, 0.5, 1.0, 2.0);
+
+void main() {
+  #pragma unroll_loop_start
+  for (int i = 0; i < 4; ++i) {
+    #if UNROLLED_LOOP_INDEX < CASCADE_COUNT
+    cascade(UNROLLED_LOOP_INDEX, mipLevels[i], outputColor[i], outputDepthVelocity[i]);
+    #endif // UNROLLED_LOOP_INDEX < CASCADE_COUNT
+  }
+  #pragma unroll_loop_end
+}

package/src/shaders/shadow.vert

@@ -0,0 +1,16 @@
+precision highp float;
+
+uniform vec3 ellipsoidCenter;
+uniform vec3 altitudeCorrection;
+
+layout(location = 0) in vec3 position;
+
+out vec2 vUv;
+out vec3 vEllipsoidCenter;
+
+void main() {
+  vUv = position.xy * 0.5 + 0.5;
+  vEllipsoidCenter = ellipsoidCenter + altitudeCorrection;
+
+  gl_Position = vec4(position.xy, 1.0, 1.0);
+}

package/src/shaders/shadowResolve.frag

@@ -0,0 +1,76 @@
+precision highp float;
+precision highp sampler2DArray;
+
+#define VARIANCE_9_SAMPLES (1)
+#define VARIANCE_SAMPLER_ARRAY (1)
+
+#include "varianceClipping"
+
+uniform sampler2DArray inputBuffer;
+uniform sampler2DArray historyBuffer;
+
+uniform vec2 texelSize;
+uniform float varianceGamma;
+uniform float temporalAlpha;
+
+in vec2 vUv;
+
+layout(location = 0) out vec4 outputColor[CASCADE_COUNT];
+
+const ivec2 neighborOffsets[9] = ivec2[9](
+  ivec2(-1, -1),
+  ivec2(-1, 0),
+  ivec2(-1, 1),
+  ivec2(0, -1),
+  ivec2(0, 0),
+  ivec2(0, 1),
+  ivec2(1, -1),
+  ivec2(1, 0),
+  ivec2(1, 1)
+);
+
+vec4 getClosestFragment(const ivec3 coord) {
+  vec4 result = vec4(1e7, 0.0, 0.0, 0.0);
+  vec4 neighbor;
+  #pragma unroll_loop_start
+  for (int i = 0; i < 9; ++i) {
+    neighbor = texelFetchOffset(
+      inputBuffer,
+      coord + ivec3(0, 0, CASCADE_COUNT),
+      0,
+      neighborOffsets[i]
+    );
+    if (neighbor.r < result.r) {
+      result = neighbor;
+    }
+  }
+  #pragma unroll_loop_end
+  return result;
+}
+
+void cascade(const int cascadeIndex, out vec4 outputColor) {
+  ivec3 coord = ivec3(gl_FragCoord.xy, cascadeIndex);
+  vec4 current = texelFetch(inputBuffer, coord, 0);
+
+  vec4 depthVelocity = getClosestFragment(coord);
+  vec2 velocity = depthVelocity.gb * texelSize;
+  vec2 prevUv = vUv - velocity;
+  if (prevUv.x < 0.0 || prevUv.x > 1.0 || prevUv.y < 0.0 || prevUv.y > 1.0) {
+    outputColor = current;
+    return; // Rejection
+  }
+
+  vec4 history = texture(historyBuffer, vec3(prevUv, float(cascadeIndex)));
+  vec4 clippedHistory = varianceClipping(inputBuffer, coord, current, history, varianceGamma);
+  outputColor = mix(clippedHistory, current, temporalAlpha);
+}
+
+void main() {
+  #pragma unroll_loop_start
+  for (int i = 0; i < 4; ++i) {
+    #if UNROLLED_LOOP_INDEX < CASCADE_COUNT
+    cascade(UNROLLED_LOOP_INDEX, outputColor[i]);
+    #endif // UNROLLED_LOOP_INDEX < CASCADE_COUNT
+  }
+  #pragma unroll_loop_end
+}

package/src/shaders/shadowResolve.vert

@@ -0,0 +1,10 @@
+precision highp float;
+
+layout(location = 0) in vec3 position;
+
+out vec2 vUv;
+
+void main() {
+  vUv = position.xy * 0.5 + 0.5;
+  gl_Position = vec4(position.xy, 1.0, 1.0);
+}

package/src/shaders/structuredSampling.glsl

@@ -0,0 +1,101 @@
+// Implements Structured Volume Sampling in fragment shader:
+// https://github.com/huwb/volsample
+// Implementation reference:
+// https://www.shadertoy.com/view/ttVfDc
+
+void getIcosahedralVertices(const vec3 direction, out vec3 v1, out vec3 v2, out vec3 v3) {
+  // Normalization scalers to fit dodecahedron to unit sphere.
+  const float a = 0.85065080835204; // phi / sqrt(2 + phi)
+  const float b = 0.5257311121191336; // 1 / sqrt(2 + phi)
+
+  // Derive the vertices of icosahedron where triangle intersects the direction.
+  // See: https://www.ppsloan.org/publications/AmbientDice.pdf
+  const float kT = 0.6180339887498948; // 1 / phi
+  const float kT2 = 0.38196601125010515; // 1 / phi^2
+  vec3 absD = abs(direction);
+  float selector1 = dot(absD, vec3(1.0, kT2, -kT));
+  float selector2 = dot(absD, vec3(-kT, 1.0, kT2));
+  float selector3 = dot(absD, vec3(kT2, -kT, 1.0));
+  v1 = selector1 > 0.0 ? vec3(a, b, 0.0) : vec3(-b, 0.0, a);
+  v2 = selector2 > 0.0 ? vec3(0.0, a, b) : vec3(a, -b, 0.0);
+  v3 = selector3 > 0.0 ? vec3(b, 0.0, a) : vec3(0.0, a, -b);
+  vec3 octantSign = sign(direction);
+  v1 *= octantSign;
+  v2 *= octantSign;
+  v3 *= octantSign;
+}
+
+void swapIfBigger(inout vec4 a, inout vec4 b) {
+  if (a.w > b.w) {
+    vec4 t = a;
+    a = b;
+    b = t;
+  }
+}
+
+void sortVertices(inout vec3 a, inout vec3 b, inout vec3 c) {
+  const vec3 base = vec3(0.5, 0.5, 1.0);
+  vec4 aw = vec4(a, dot(a, base));
+  vec4 bw = vec4(b, dot(b, base));
+  vec4 cw = vec4(c, dot(c, base));
+  swapIfBigger(aw, bw);
+  swapIfBigger(bw, cw);
+  swapIfBigger(aw, bw);
+  a = aw.xyz;
+  b = bw.xyz;
+  c = cw.xyz;
+}
+
+vec3 getPentagonalWeights(const vec3 direction, const vec3 v1, const vec3 v2, const vec3 v3) {
+  float d1 = dot(v1, direction);
+  float d2 = dot(v2, direction);
+  float d3 = dot(v3, direction);
+  vec3 w = exp(vec3(d1, d2, d3) * 40.0);
+  return w / (w.x + w.y + w.z);
+}
+
+vec3 getStructureNormal(
+  const vec3 direction,
+  const float jitter,
+  out vec3 a,
+  out vec3 b,
+  out vec3 c,
+  out vec3 weights
+) {
+  getIcosahedralVertices(direction, a, b, c);
+  sortVertices(a, b, c);
+  weights = getPentagonalWeights(direction, a, b, c);
+  return jitter < weights.x
+    ? a
+    : jitter < weights.x + weights.y
+      ? b
+      : c;
+}
+
+vec3 getStructureNormal(const vec3 direction, const float jitter) {
+  vec3 a, b, c, weights;
+  return getStructureNormal(direction, jitter, a, b, c, weights);
+}
+
+// Reference: https://github.com/huwb/volsample/blob/master/src/unity/Assets/Shaders/RayMarchCore.cginc
+void intersectStructuredPlanes(
+  const vec3 normal,
+  const vec3 rayOrigin,
+  const vec3 rayDirection,
+  const float samplePeriod,
+  out float stepOffset,
+  out float stepSize
+) {
+  float NoD = dot(rayDirection, normal);
+  stepSize = samplePeriod / abs(NoD);
+
+  // Skips leftover bit to get from rayOrigin to first strata plane.
+  stepOffset = -mod(dot(rayOrigin, normal), samplePeriod) / NoD;
+
+  // mod() gives different results depending on if the arg is negative or
+  // positive. This line makes it consistent, and ensures the first sample is in
+  // front of the viewer.
+  if (stepOffset < 0.0) {
+    stepOffset += stepSize;
+  }
+}

package/src/shaders/tileableNoise.glsl

@@ -0,0 +1,88 @@
+// Based on the following work with slight modifications.
+// https://github.com/sebh/TileableVolumeNoise
+
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright(c) 2017 Sébastien Hillaire
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+float hash(const float n) {
+  return fract(sin(n + 1.951) * 43758.5453);
+}
+
+float noise(const vec3 x) {
+  vec3 p = floor(x);
+  vec3 f = fract(x);
+
+  f = f * f * (3.0 - 2.0 * f);
+  float n = p.x + p.y * 57.0 + 113.0 * p.z;
+  return mix(
+    mix(mix(hash(n + 0.0), hash(n + 1.0), f.x), mix(hash(n + 57.0), hash(n + 58.0), f.x), f.y),
+    mix(
+      mix(hash(n + 113.0), hash(n + 114.0), f.x),
+      mix(hash(n + 170.0), hash(n + 171.0), f.x),
+      f.y
+    ),
+    f.z
+  );
+}
+
+float getWorleyNoise(const vec3 p, const float cellCount) {
+  vec3 cell = p * cellCount;
+  float d = 1.0e10;
+  for (int x = -1; x <= 1; ++x) {
+    for (int y = -1; y <= 1; ++y) {
+      for (int z = -1; z <= 1; ++z) {
+        vec3 tp = floor(cell) + vec3(x, y, z);
+        tp = cell - tp - noise(mod(tp, cellCount / 1.0));
+        d = min(d, dot(tp, tp));
+      }
+    }
+  }
+  return clamp(d, 0.0, 1.0);
+}
+
+float getPerlinNoise(const vec3 point, const vec3 frequency, const int octaveCount) {
+  // Noise frequency factor between octave, forced to 2.
+  const float octaveFrequencyFactor = 2.0;
+
+  // Compute the sum for each octave.
+  float sum = 0.0;
+  float roughness = 0.5;
+  float weightSum = 0.0;
+  float weight = 1.0;
+  vec3 nextFrequency = frequency;
+  for (int i = 0; i < octaveCount; ++i) {
+    vec4 p = vec4(point.x, point.y, point.z, 0.0) * vec4(nextFrequency, 1.0);
+    float value = perlin(p, vec4(nextFrequency, 1.0));
+    sum += value * weight;
+    weightSum += weight;
+    weight *= roughness;
+    nextFrequency *= octaveFrequencyFactor;
+  }
+
+  return sum / weightSum; // Intentionally skip clamping.
+}
+
+float getPerlinNoise(const vec3 point, const float frequency, const int octaveCount) {
+  return getPerlinNoise(point, vec3(frequency), octaveCount);
+}