@matboks/utilities 0.0.1 → 0.0.2

package/dist/shader-modules/modules/noise.js

@@ -1,410 +1,450 @@
-export const noiseDefinition = /*glsl*/ `
-import { random, random2, random3, randomUnit } from "@/random";
-import { triangleWave, dot2 } from "@/utils";
-import { rotate, axisAngle } from "@/geometry";
-import { PI } from "@/constants";
-
-export {
-  valueNoise, perlinNoise, worleyNoise, voroNoise, gaboroNoise, 
-  octaveNoise1D, octaveNoise2D, octaveNoise3D
-}
-
-float valueNoise(float p, float scale, float seed) {
-  p *= scale;
-
-  float pi = floor(p);
-  float pf = fract(p);
-
-  float sf = smoothstep(0.0, 1.0, pf);
-
-  return mix(random(pi, seed), random(pi + 1.0, seed), sf);
-}
-
-float valueNoise(vec2 p, float scale, float seed) {
-  p *= scale;
-
-  vec2 pi = floor(p);
-  vec2 pf = fract(p);
-
-  vec2 sf = smoothstep(0.0, 1.0, pf);
-  vec2 o = vec2(1, 0);
-
-  return mix(
-    mix(random(pi, seed), random(pi + o.xy, seed), sf.x),
-    mix(random(pi + o.yx, seed), random(pi + o.xx, seed), sf.x),
-    sf.y
-  );
-}
-
-float valueNoise(vec3 p, float scale, float seed) {
-  p *= scale;
-
-  vec3 pi = floor(p);
-  vec3 pf = fract(p);
-
-  vec3 sf = smoothstep(0.0, 1.0, pf);
-  vec2 o = vec2(1, 0);
-
-  return mix(
-    mix(
-      mix(random(pi, seed), random(pi + o.xyy, seed), sf.x),
-      mix(random(pi + o.yxy, seed), random(pi + o.xxy, seed), sf.x),
-      sf.y
-    ),
-    mix(
-      mix(random(pi + o.yyx, seed), random(pi + o.xyx, seed), sf.x),
-      mix(random(pi + o.yxx, seed), random(pi + o.xxx, seed), sf.x),
-      sf.y
-    ), 
-    sf.z
-  );
-
-}
-
-float perlinNoise(float p, float scale, float seed) {
-  p *= scale;
-
-  float pi = floor(p);
-  float pf = fract(p);
-
-  float sf = smoothstep(0.0, 1.0, pf);
-
-  float signed = mix(random(pi, seed)*pf, random(pi + 1.0, seed)*(pf - 1.0), sf);
-  
-  // Signed is in range [-1/2, 1/2], map to [0, 1]
-  return 0.5 + signed;
-}
-
-float perlinNoise(vec2 p, float scale, float seed) {
-  p *= scale;
-
-  vec2 pi = floor(p);
-  vec2 pf = fract(p);
-
-  vec2 sf = smoothstep(0.0, 1.0, pf);
-  vec2 o = vec2(1, 0);
-
-  float signed = mix(
-    mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xy, seed), pf - o.xy), sf.x),
-    mix(dot(randomUnit(pi + o.yx, seed), pf - o.yx), dot(randomUnit(pi + o.xx, seed), pf - o.xx), sf.x),
-    sf.y
-  );
-  
-  // Signed is in range [-sqrt(2)/2, sqrt(2)/2], map to [0, 1]
-  return 0.5 + 0.70710678118654752*signed;
-}
-
-float perlinNoise(vec3 p, float scale, float seed) {
-  p *= scale;
-
-  vec3 pi = floor(p);
-  vec3 pf = fract(p);
-
-  vec3 sf = smoothstep(0.0, 1.0, pf);
-  vec2 o = vec2(1, 0);
-
-  float signed = mix(
-    mix(
-      mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xyy, seed), pf - o.xyy), sf.x),
-      mix(dot(randomUnit(pi + o.yxy, seed), pf - o.yxy), dot(randomUnit(pi + o.xxy, seed), pf - o.xxy), sf.x),
-      sf.y
-    ),
-    mix(
-      mix(dot(randomUnit(pi + o.yyx, seed), pf - o.yyx), dot(randomUnit(pi + o.xyx, seed), pf - o.xyx), sf.x),
-      mix(dot(randomUnit(pi + o.yxx, seed), pf - o.yxx), dot(randomUnit(pi + o.xxx, seed), pf - o.xxx), sf.x),
-      sf.y
-    ), 
-    sf.z
-  );
-
-  // Signed is in range [-sqrt(3/4), sqrt(3/4)], map to [0, 1]
-  return 0.5 + 0.57735026918962576*signed;
-}
-
-float worleyNoise(float p, float scale, float seed) {
-  p *= scale;
-
-  float pi = floor(p);
-  float pf = fract(p);
-
-  float minDist = 1e9;
-
-  for (int index = -1; index <= 1; index++) {
-    float fi = float(index);
-    float centerToPosition = fi + random(pi + fi, seed) - pf;
-
-    minDist = min(minDist, abs(centerToPosition));
-  }
-
-  return minDist;
-}
-
-float worleyNoise(vec2 p, float scale, float seed) {
-  p *= scale;
-
-  vec2 pi = floor(p);
-  vec2 pf = fract(p);
-
-  float minDist2 = 1e9;
-
-  for (int row = -1; row <= 1; row++) {
-    for (int col = -1; col <= 1; col++) {
-      vec2 index = vec2(col, row);
-      
-      vec2 centerToPosition = index + random2(pi + index, seed) - pf;
-      float dist2 = dot2(centerToPosition);
-
-      minDist2 = min(minDist2, dist2);
-    }
-  }
-
-  return sqrt(minDist2);
-}
-
-float worleyNoise(vec3 p, float scale, float seed) {
-  p *= scale;
-
-  vec3 pi = floor(p);
-  vec3 pf = fract(p);
-
-  float minDist2 = 1e9;
-
-  for (int row = -1; row <= 1; row++) {
-    for (int col = -1; col <= 1; col++) {
-      for (int slice = -1; slice <= 1; slice++) {
-        vec3 index = vec3(col, row, slice);
-      
-        vec3 centerToPosition = index + random3(pi + index, seed) - pf;
-        float dist2 = dot2(centerToPosition);
-
-        minDist2 = min(minDist2, dist2);
-      }
-    }
-  }
-
-  return sqrt(minDist2);
-}
-
-// Adapted version of https://iquilezles.org/articles/voronoise/
-float voroNoise(vec2 p, float scale, float disorder, float smoothness, float seed) {
-  p *= scale;
-
-  vec2 pi = floor(p);
-  vec2 pf = fract(p);
-
-  float s = 1.0;
-  int kernel = 2;
-
-  float power = 64.0 - 63.0*pow(smoothness, 0.1);
-
-  float sum = 0.0;
-  float weightSum = 0.0;
-
-  for (int row = -kernel; row <= kernel; row++) {
-    for (int col = -kernel; col <= kernel; col++) {
-      vec2 index = vec2(col, row);
-
-      // xy is cell center, z is value
-      vec3 data = random3(pi + index, seed);
-
-      vec2 centerToPosition = index + data.xy*disorder - pf;
-
-      float dist2 = dot2(centerToPosition);
-
-      float weight = pow(smoothstep(1.0, 0.0, sqrt(0.5*dist2)), power );
-
-      sum += weight*data.z;
-      weightSum += weight;
-    }
-  }
-
-  return sum / weightSum;
-}
-
-float gaboroNoise(vec2 p, float level, float scale, float radius, float freq, float hatchAmount, float hatchAngle, float seed) {
-  p *= scale;
-
-  vec2 pi = floor(p);
-  float exponent = 1. / (radius*radius);
-
-  float valueSum = 0., weightSum = 0.;
-  for (int i = -1; i <= 1; i++) {
-    for (int j = -1; j <= 1; j++) {
-      vec2 cellIndex = pi + vec2(i, j);
-      vec2 cellCenter = cellIndex + random2(cellIndex, seed);
-      
-      float se = random(cellCenter, seed);
-
-      vec2 diff = p - cellCenter;
-      float rotation = PI*random(se);
-    
-      float weight = exp(-exponent*dot(diff, diff));
-      
-      vec2 texturePosition = diff*freq;
-      
-      float value = max(triangleWave(texturePosition, rotation), hatchAmount*triangleWave(texturePosition, rotation + hatchAngle));
-      
-      weightSum += weight;
-      valueSum += weight*value;
-    }
-  }
-  
-  level = mix(level, sqrt(level), hatchAmount);
-
-  return smoothstep(0.05, -0.05, valueSum / weightSum - level);
-  //return valueSum / weightSum;
-}
-
-float idwNoise(float p, float power, float scale, float seed, int window) {
-  p *= scale;
-
-  float pi = floor(p);
-
-  float sum = 0.0;
-  float weightSum = 0.0;
-  float powerCoeff = -power;
-
-  for (int i = -window; i <= window; i++) {
-    float cellCorner = pi + i;
-    float value = random(cellCorner, seed);
-
-    float cellPosition = cellCorner + random(cellCorner, seed);
-
-    float w = pow(abs(p - cellPosition), powerCoeff);
-    
-    if (isinf(w)) return value;
-
-    sum += w*value;
-    weightSum += w; 
-  }
-
-  return sum / weightSum;
-}
-
-float idwNoise(vec2 p, float power, float scale, float seed, int window) {
-  p *= scale;
-
-  vec2 pi = floor(p);
-
-  float sum = 0.0;
-  float weightSum = 0.0;
-  float powerCoeff = -0.5*power;
-
-  for (int i = -window; i <= window; i++) {
-    for (int j = -window; j <= window; j++) {
-      vec2 cellCorner = pi + vec2(i, j);
-      float value = random(cellCorner, seed);
-
-      vec2 cellPosition = cellCorner + random2(cellCorner, seed);
-
-      float w = pow(dot2(p - cellPosition), powerCoeff);
-      
-      if (isinf(w)) return value;
-
-      sum += w*value;
-      weightSum += w;
-    }  
-  }
-
-  return sum / weightSum;
-}
-
-float idwNoise(vec3 p, float power, float scale, float seed, int window) {
-  p *= scale;
-
-  vec3 pi = floor(p);
-
-  float sum = 0.0;
-  float weightSum = 0.0;
-  float powerCoeff = -0.5*power;
-
-  for (int i = -window; i <= window; i++) {
-    for (int j = -window; j <= window; j++) {
-      for (int k = -window; k <= window; k++) {
-        vec3 cellCorner = pi + vec3(i, j, k);
-        float value = random(cellCorner, seed);
-
-        vec3 cellPosition = cellCorner + random3(cellCorner, seed);
-
-        float w = pow(dot2(p - cellPosition), powerCoeff);
-        
-        if (isinf(w)) return value;
-
-        sum += w*value;
-        weightSum += w;
-      }  
-    }  
-  }
-
-  return sum / weightSum;
-}
-
-float standardizeOctaveNoise(float value, int octaves) {
-  float norm = clamp((float(octaves) - 1.0)/9.0, 0.0, 1.0);
-  float l = 0.25*pow(norm, 0.125);
-  return (value - l)/(1.0 - 2.0*l);
-}
-
-float octaveNoise1D(float p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(float, float)) {
-  p *= scale;
-
-  float sum = 0.0;
-  float amplitude = 1.0;
-  float amplitudeSum = 0.0;
-
-  for (int i = 0; i < octaves; i++) {
-    float value = noise(p, seed + float(i));
-    sum += amplitude*value;
-    amplitudeSum += amplitude;
-
-    p = lacunarity*p + PI;
-    amplitude *= falloff;
-  }
-
-  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);
-  return sum / amplitudeSum;
-}
-
-float octaveNoise2D(vec2 p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(vec2, float)) {
-  p *= scale;
-
-  float sum = 0.0;
-  float amplitude = 1.0;
-  float amplitudeSum = 0.0;
-
-  for (int i = 0; i < octaves; i++) {
-    float value = noise(p, seed + float(i));
-    sum += amplitude*value;
-    amplitudeSum += amplitude;
-
-    p = rotate(lacunarity*p, 1.2);
-    amplitude *= falloff;
-  }
-
-  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);
-  return sum / amplitudeSum;
-}
-
-float octaveNoise3D(vec3 p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(vec3, float)) {
-  p *= scale;
-
-  float sum = 0.0;
-  float amplitude = 1.0;
-  float amplitudeSum = 0.0;
-
-  vec3 axis = vec3(0.5092382307155079, -0.23643203568934296, 0.8275121249127003);
-
-  for (int i = 0; i < octaves; i++) {
-    float value = noise(p, seed + float(i));
-    sum += amplitude*value;
-    amplitudeSum += amplitude;
-
-    p = axisAngle(lacunarity*p, axis, 1.2);
-    amplitude *= falloff;
-  }
-
-  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);
-  return sum / amplitudeSum;
-}
-
+export const noiseDefinition = /*glsl*/ `
+import { random, random2, random3, randomUnit } from "@/random";
+import { triangleWave, dot2 } from "@/utils";
+import { rotate, axisAngle } from "@/geometry";
+import { PI } from "@/constants";
+
+export {
+  valueNoise, perlinNoise, worleyNoise, voroNoise, gaboroNoise, 
+  octaveNoise1D, octaveNoise2D, octaveNoise3D
+}
+
+float valueNoise(float p, float scale, float seed) {
+  p *= scale;
+
+  float pi = floor(p);
+  float pf = fract(p);
+
+  float sf = smoothstep(0.0, 1.0, pf);
+
+  return mix(random(pi, seed), random(pi + 1.0, seed), sf);
+}
+
+float valueNoise(vec2 p, float scale, float seed) {
+  p *= scale;
+
+  vec2 pi = floor(p);
+  vec2 pf = fract(p);
+
+  vec2 sf = smoothstep(0.0, 1.0, pf);
+  vec2 o = vec2(1, 0);
+
+  return mix(
+    mix(random(pi, seed), random(pi + o.xy, seed), sf.x),
+    mix(random(pi + o.yx, seed), random(pi + o.xx, seed), sf.x),
+    sf.y
+  );
+}
+
+float valueNoise(vec3 p, float scale, float seed) {
+  p *= scale;
+
+  vec3 pi = floor(p);
+  vec3 pf = fract(p);
+
+  vec3 sf = smoothstep(0.0, 1.0, pf);
+  vec2 o = vec2(1, 0);
+
+  return mix(
+    mix(
+      mix(random(pi, seed), random(pi + o.xyy, seed), sf.x),
+      mix(random(pi + o.yxy, seed), random(pi + o.xxy, seed), sf.x),
+      sf.y
+    ),
+    mix(
+      mix(random(pi + o.yyx, seed), random(pi + o.xyx, seed), sf.x),
+      mix(random(pi + o.yxx, seed), random(pi + o.xxx, seed), sf.x),
+      sf.y
+    ), 
+    sf.z
+  );
+
+}
+
+float valueNoise(vec4 p, float scale, float seed) {
+  p *= scale;
+
+  vec4 pi = floor(p);
+  vec4 pf = fract(p);
+
+  vec4 sf = smoothstep(0.0, 1.0, pf);
+  vec2 o = vec2(1, 0);
+
+  return mix(
+    mix(
+      mix(
+        mix(random(pi, seed), random(pi + o.xyyy, seed), sf.x),
+        mix(random(pi + o.yxyy, seed), random(pi + o.xxyy, seed), sf.x),
+        sf.y
+      ),
+      mix(
+        mix(random(pi + o.yyxy, seed), random(pi + o.xyxy, seed), sf.x),
+        mix(random(pi + o.yxxy, seed), random(pi + o.xxxy, seed), sf.x),
+        sf.y
+      ), 
+      sf.z
+    ),
+    mix(
+      mix(
+        mix(random(pi + o.yyyx, seed), random(pi + o.xyyx, seed), sf.x),
+        mix(random(pi + o.yxyx, seed), random(pi + o.xxyx, seed), sf.x),
+        sf.y
+      ),
+      mix(
+        mix(random(pi + o.yyxx, seed), random(pi + o.xyxx, seed), sf.x),
+        mix(random(pi + o.yxxx, seed), random(pi + o.xxxx, seed), sf.x),
+        sf.y
+      ), 
+      sf.z
+    ),
+    sf.w
+  );
+}
+
+float perlinNoise(float p, float scale, float seed) {
+  p *= scale;
+
+  float pi = floor(p);
+  float pf = fract(p);
+
+  float sf = smoothstep(0.0, 1.0, pf);
+
+  float signed = mix(random(pi, seed)*pf, random(pi + 1.0, seed)*(pf - 1.0), sf);
+  
+  // Signed is in range [-1/2, 1/2], map to [0, 1]
+  return 0.5 + signed;
+}
+
+float perlinNoise(vec2 p, float scale, float seed) {
+  p *= scale;
+
+  vec2 pi = floor(p);
+  vec2 pf = fract(p);
+
+  vec2 sf = smoothstep(0.0, 1.0, pf);
+  vec2 o = vec2(1, 0);
+
+  float signed = mix(
+    mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xy, seed), pf - o.xy), sf.x),
+    mix(dot(randomUnit(pi + o.yx, seed), pf - o.yx), dot(randomUnit(pi + o.xx, seed), pf - o.xx), sf.x),
+    sf.y
+  );
+  
+  // Signed is in range [-sqrt(2)/2, sqrt(2)/2], map to [0, 1]
+  return 0.5 + 0.70710678118654752*signed;
+}
+
+float perlinNoise(vec3 p, float scale, float seed) {
+  p *= scale;
+
+  vec3 pi = floor(p);
+  vec3 pf = fract(p);
+
+  vec3 sf = smoothstep(0.0, 1.0, pf);
+  vec2 o = vec2(1, 0);
+
+  float signed = mix(
+    mix(
+      mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xyy, seed), pf - o.xyy), sf.x),
+      mix(dot(randomUnit(pi + o.yxy, seed), pf - o.yxy), dot(randomUnit(pi + o.xxy, seed), pf - o.xxy), sf.x),
+      sf.y
+    ),
+    mix(
+      mix(dot(randomUnit(pi + o.yyx, seed), pf - o.yyx), dot(randomUnit(pi + o.xyx, seed), pf - o.xyx), sf.x),
+      mix(dot(randomUnit(pi + o.yxx, seed), pf - o.yxx), dot(randomUnit(pi + o.xxx, seed), pf - o.xxx), sf.x),
+      sf.y
+    ), 
+    sf.z
+  );
+
+  // Signed is in range [-sqrt(3/4), sqrt(3/4)], map to [0, 1]
+  return 0.5 + 0.57735026918962576*signed;
+}
+
+float worleyNoise(float p, float scale, float seed) {
+  p *= scale;
+
+  float pi = floor(p);
+  float pf = fract(p);
+
+  float minDist = 1e9;
+
+  for (int index = -1; index <= 1; index++) {
+    float fi = float(index);
+    float centerToPosition = fi + random(pi + fi, seed) - pf;
+
+    minDist = min(minDist, abs(centerToPosition));
+  }
+
+  return minDist;
+}
+
+float worleyNoise(vec2 p, float scale, float seed) {
+  p *= scale;
+
+  vec2 pi = floor(p);
+  vec2 pf = fract(p);
+
+  float minDist2 = 1e9;
+
+  for (int row = -1; row <= 1; row++) {
+    for (int col = -1; col <= 1; col++) {
+      vec2 index = vec2(col, row);
+      
+      vec2 centerToPosition = index + random2(pi + index, seed) - pf;
+      float dist2 = dot2(centerToPosition);
+
+      minDist2 = min(minDist2, dist2);
+    }
+  }
+
+  return sqrt(minDist2);
+}
+
+float worleyNoise(vec3 p, float scale, float seed) {
+  p *= scale;
+
+  vec3 pi = floor(p);
+  vec3 pf = fract(p);
+
+  float minDist2 = 1e9;
+
+  for (int row = -1; row <= 1; row++) {
+    for (int col = -1; col <= 1; col++) {
+      for (int slice = -1; slice <= 1; slice++) {
+        vec3 index = vec3(col, row, slice);
+      
+        vec3 centerToPosition = index + random3(pi + index, seed) - pf;
+        float dist2 = dot2(centerToPosition);
+
+        minDist2 = min(minDist2, dist2);
+      }
+    }
+  }
+
+  return sqrt(minDist2);
+}
+
+// Adapted version of https://iquilezles.org/articles/voronoise/
+float voroNoise(vec2 p, float scale, float disorder, float smoothness, float seed) {
+  p *= scale;
+
+  vec2 pi = floor(p);
+  vec2 pf = fract(p);
+
+  float s = 1.0;
+  int kernel = 2;
+
+  float power = 64.0 - 63.0*pow(smoothness, 0.1);
+
+  float sum = 0.0;
+  float weightSum = 0.0;
+
+  for (int row = -kernel; row <= kernel; row++) {
+    for (int col = -kernel; col <= kernel; col++) {
+      vec2 index = vec2(col, row);
+
+      // xy is cell center, z is value
+      vec3 data = random3(pi + index, seed);
+
+      vec2 centerToPosition = index + data.xy*disorder - pf;
+
+      float dist2 = dot2(centerToPosition);
+
+      float weight = pow(smoothstep(1.0, 0.0, sqrt(0.5*dist2)), power );
+
+      sum += weight*data.z;
+      weightSum += weight;
+    }
+  }
+
+  return sum / weightSum;
+}
+
+float gaboroNoise(vec2 p, float level, float scale, float radius, float freq, float hatchAmount, float hatchAngle, float seed) {
+  p *= scale;
+
+  vec2 pi = floor(p);
+  float exponent = 1. / (radius*radius);
+
+  float valueSum = 0., weightSum = 0.;
+  for (int i = -1; i <= 1; i++) {
+    for (int j = -1; j <= 1; j++) {
+      vec2 cellIndex = pi + vec2(i, j);
+      vec2 cellCenter = cellIndex + random2(cellIndex, seed);
+      
+      float se = random(cellCenter, seed);
+
+      vec2 diff = p - cellCenter;
+      float rotation = PI*random(se);
+    
+      float weight = exp(-exponent*dot(diff, diff));
+      
+      vec2 texturePosition = diff*freq;
+      
+      float value = max(triangleWave(texturePosition, rotation), hatchAmount*triangleWave(texturePosition, rotation + hatchAngle));
+      
+      weightSum += weight;
+      valueSum += weight*value;
+    }
+  }
+  
+  level = mix(level, sqrt(level), hatchAmount);
+
+  return smoothstep(0.05, -0.05, valueSum / weightSum - level);
+  //return valueSum / weightSum;
+}
+
+float idwNoise(float p, float power, float scale, float seed, int window) {
+  p *= scale;
+
+  float pi = floor(p);
+
+  float sum = 0.0;
+  float weightSum = 0.0;
+  float powerCoeff = -power;
+
+  for (int i = -window; i <= window; i++) {
+    float cellCorner = pi + i;
+    float value = random(cellCorner, seed);
+
+    float cellPosition = cellCorner + random(cellCorner, seed);
+
+    float w = pow(abs(p - cellPosition), powerCoeff);
+    
+    if (isinf(w)) return value;
+
+    sum += w*value;
+    weightSum += w; 
+  }
+
+  return sum / weightSum;
+}
+
+float idwNoise(vec2 p, float power, float scale, float seed, int window) {
+  p *= scale;
+
+  vec2 pi = floor(p);
+
+  float sum = 0.0;
+  float weightSum = 0.0;
+  float powerCoeff = -0.5*power;
+
+  for (int i = -window; i <= window; i++) {
+    for (int j = -window; j <= window; j++) {
+      vec2 cellCorner = pi + vec2(i, j);
+      float value = random(cellCorner, seed);
+
+      vec2 cellPosition = cellCorner + random2(cellCorner, seed);
+
+      float w = pow(dot2(p - cellPosition), powerCoeff);
+      
+      if (isinf(w)) return value;
+
+      sum += w*value;
+      weightSum += w;
+    }  
+  }
+
+  return sum / weightSum;
+}
+
+float idwNoise(vec3 p, float power, float scale, float seed, int window) {
+  p *= scale;
+
+  vec3 pi = floor(p);
+
+  float sum = 0.0;
+  float weightSum = 0.0;
+  float powerCoeff = -0.5*power;
+
+  for (int i = -window; i <= window; i++) {
+    for (int j = -window; j <= window; j++) {
+      for (int k = -window; k <= window; k++) {
+        vec3 cellCorner = pi + vec3(i, j, k);
+        float value = random(cellCorner, seed);
+
+        vec3 cellPosition = cellCorner + random3(cellCorner, seed);
+
+        float w = pow(dot2(p - cellPosition), powerCoeff);
+        
+        if (isinf(w)) return value;
+
+        sum += w*value;
+        weightSum += w;
+      }  
+    }  
+  }
+
+  return sum / weightSum;
+}
+
+float standardizeOctaveNoise(float value, int octaves) {
+  float norm = clamp((float(octaves) - 1.0)/9.0, 0.0, 1.0);
+  float l = 0.25*pow(norm, 0.125);
+  return (value - l)/(1.0 - 2.0*l);
+}
+
+float octaveNoise1D(float p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(float, float)) {
+  p *= scale;
+
+  float sum = 0.0;
+  float amplitude = 1.0;
+  float amplitudeSum = 0.0;
+
+  for (int i = 0; i < octaves; i++) {
+    float value = noise(p, seed + float(i));
+    sum += amplitude*value;
+    amplitudeSum += amplitude;
+
+    p = lacunarity*p + PI;
+    amplitude *= falloff;
+  }
+
+  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);
+  return sum / amplitudeSum;
+}
+
+float octaveNoise2D(vec2 p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(vec2, float)) {
+  p *= scale;
+
+  float sum = 0.0;
+  float amplitude = 1.0;
+  float amplitudeSum = 0.0;
+
+  for (int i = 0; i < octaves; i++) {
+    float value = noise(p, seed + float(i));
+    sum += amplitude*value;
+    amplitudeSum += amplitude;
+
+    p = rotate(lacunarity*p, 1.2);
+    amplitude *= falloff;
+  }
+
+  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);
+  return sum / amplitudeSum;
+}
+
+float octaveNoise3D(vec3 p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(vec3, float)) {
+  p *= scale;
+
+  float sum = 0.0;
+  float amplitude = 1.0;
+  float amplitudeSum = 0.0;
+
+  vec3 axis = vec3(0.5092382307155079, -0.23643203568934296, 0.8275121249127003);
+
+  for (int i = 0; i < octaves; i++) {
+    float value = noise(p, seed + float(i));
+    sum += amplitude*value;
+    amplitudeSum += amplitude;
+
+    p = axisAngle(lacunarity*p, axis, 1.2);
+    amplitude *= falloff;
+  }
+
+  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);
+  return sum / amplitudeSum;
+}
+
 `;