@matboks/utilities 0.0.1

package/dist/shader-modules/modules/color/index.js

@@ -0,0 +1,135 @@
+export const colorDefinition = /*glsl*/ `
+
+export {
+  hslToRgb, rgbToHsl, shiftRgbInHsl,
+  hsvToRgb, rgbToHsv
+}
+
+vec3 hslToRgb(vec3 hsl) {
+  float h = mod(hsl.r, 360.0);
+  float s = clamp(hsl.g, 0.0, 1.0);
+  float l = clamp(hsl.b, 0.0, 1.0);
+
+  float c = s*(1.0 - abs(2.0*l - 1.0));
+  float x = c*(1.0 - abs(mod(h / 60.0, 2.0) - 1.0));
+  float m = l - c / 2.0;
+  
+  float r = 0.0;
+  float g = 0.0;
+  float b = 0.0;
+
+  if (h < 60.0) {
+    r = c;
+    g = x;
+  } else if (h < 120.0) {
+    r = x;
+    g = c;
+  } else if (h < 180.0) {
+    g = c;
+    b = x;
+  } else if (h < 240.0) {
+    g = x;
+    b = c;
+  } else if (h < 300.0) {
+    r = x;
+    b = c;
+  } else {
+    r = c;
+    b = x;
+  }
+  return vec3(r, g, b) + m;
+}
+
+vec3 hslToRgb(float h, float s, float l) {
+  return hslToRgb(vec3(h, s, l));
+}
+
+vec3 rgbToHsl(vec3 rgb) {
+  float r = rgb.r;
+  float g = rgb.g;
+  float b = rgb.b;
+
+  float cMax = max(r, max(g, b));
+  float cMin = min(r, min(g, b));
+  float delta = cMax - cMin;
+
+  float h;
+
+  if (delta == 0.0) {
+    h = 0.0;
+  } else if (r == cMax) {
+    h = mod((g - b)/delta, 6.0);
+  } else if (g == cMax) {
+    h = (b - r)/delta + 2.0;
+  } else if (b == cMax) {
+    h = (r - g)/delta + 4.0;
+  } 
+  h *= 60.0;
+	h = mod(h, 360.0);
+
+  float l = (cMax + cMin)/2.0;
+
+  float s = 0.0;
+  if (delta > 0.0) {
+    s = delta/(1.0 - abs(2.0*l - 1.0));
+  }
+
+  return vec3(h, s, l);
+}
+
+vec3 rgbToHsl(float r, float g, float b) {
+  return rgbToHsl(vec3(r, g, b));
+}
+
+vec3 shiftRgbInHsl(vec3 rgb, vec3 shift) {
+  if (shift.z > 0.0) {
+    rgb = mix(rgb, vec3(1.0), shift.z);
+  } else {
+    rgb = mix(rgb, vec3(0.0), -shift.z);
+  }
+
+  vec3 hsl = rgbToHsl(rgb);
+
+  hsl.x += shift.x;
+
+  float sShift = shift.y;
+  if (sShift > 0.0) {
+    hsl.y = (1.0 - sShift)*hsl.y + sShift;
+  } else {
+    hsl.y = (1.0 + sShift)*hsl.y;
+  }
+
+  vec3 res = hslToRgb(hsl);
+
+  return res;
+}
+
+vec3 rgbToHsv(vec3 c)
+{
+    vec4 K = vec4(0.0, -1.0/3.0, 2.0/3.0, -1.0);
+    vec4 p = mix(vec4(c.bg, K.wz),
+                 vec4(c.gb, K.xy),
+                 step(c.b, c.g));
+    vec4 q = mix(vec4(p.xyw, c.r),
+                 vec4(c.r, p.yzx),
+                 step(p.x, c.r));
+
+    float d = q.x - min(q.w, q.y);
+    float e = 1.0e-10;
+
+    return vec3(
+        abs(q.z + (q.w - q.y) / (6.0 * d + e)),
+        d / (q.x + e),                         
+        q.x                                    
+    );
+}
+
+vec3 hsv2Rgb(vec3 c)
+{
+    vec4 K = vec4(1.0, 2.0/3.0, 1.0/3.0, 3.0);
+    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+
+    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+`;

package/dist/shader-modules/modules/constants.d.ts

@@ -0,0 +1 @@
+export declare const constantsDefinition = "\n\nexport {\n  PI, TWO_PI, SQRT_2, INV_SQRT_2, EPS\n}\n\nconst float PI = 3.14159265;\nconst float TWO_PI = 2.*PI;\nconst float SQRT_2 = sqrt(2.0);\nconst float INV_SQRT_2 = 0.5*SQRT_2;\nconst float EPS = 1e-9;\n\n\n";

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

@@ -0,0 +1,14 @@
+export const constantsDefinition = /*glsl*/ `
+
+export {
+  PI, TWO_PI, SQRT_2, INV_SQRT_2, EPS
+}
+
+const float PI = 3.14159265;
+const float TWO_PI = 2.*PI;
+const float SQRT_2 = sqrt(2.0);
+const float INV_SQRT_2 = 0.5*SQRT_2;
+const float EPS = 1e-9;
+
+
+`;

package/dist/shader-modules/modules/geometry.d.ts

@@ -0,0 +1 @@
+export declare const geometryDefinition = "\n\nexport { \n  rotate,\n  barycentric,\n  distanceToSegment,\n  axisAngle, axisAngleMatrix,\n  create2DBasisVectors,\n  transformToZAxis\n}\n\nvec2 rotate(vec2 vector, float rotation) {\n  float c = cos(rotation);\n  float s = sin(rotation);\n  return mat2(c, s, -s, c)*vector;\n}\n\nvec2 rotate(vec2 vector, vec2 center, float rotation) {\n  return center + rotate(vector - center, rotation);\n}\n\n// Rotates a vector around an axis using Rodrigues' formula\nvec3 axisAngle(vec3 vector, vec3 axis, float rotation) {\n  float c = cos(rotation);\n  float s = sin(rotation);\n  return vector*c + cross(axis, vector)*s + axis*dot(axis, vector)*(1.0 - c);\n}\n\nvec3 axisAngle(vec3 vector, vec3 origin, vec3 axis, float rotation) {\n  return axisAngle(vector - origin, axis, rotation) + origin;\n}\n\nmat3 axisAngleMatrix(vec3 axis, float rotation) {\n  mat3 K = mat3(\n    0, axis.z, -axis.y,\n    -axis.z, 0, axis.x,\n    axis.y, -axis.x, 0\n  );\n  return mat3(1.0) + sin(rotation)*K + (1.0 - cos(rotation))*K*K;\n}\n\n// Assumes first point has already been subtracted\nvec3 barycentric(vec2 p, vec2 b, vec2 c) {\n  float dbb = dot(b, b);\n  float dbc = dot(b, c);\n  float dcc = dot(c, c);\n  float dcp = dot(c, p);\n  float dbp = dot(b, p);\n\n  float denom = dbb * dcc - dbc * dbc;\n  float v = (dcc * dbp - dbc * dcp) / denom;\n  float w = (dbb * dcp - dbc * dbp) / denom;\n  return vec3(1.0 - v - w, v, w);\n}\n\nvec3 barycentric(vec2 p, vec2 a, vec2 b, vec2 c) {\n  return barycentric(p - a, b - a, c - a);\n}\n\n// Assumes first point has already been subtracted\nvec3 barycentric(vec3 p, vec3 b, vec3 c) {\n  float dbb = dot(b, b);\n  float dbc = dot(b, c);\n  float dcc = dot(c, c);\n  float dcp = dot(c, p);\n  float dbp = dot(b, p);\n\n  float denom = dbb * dcc - dbc * dbc;\n  float v = (dcc * dbp - dbc * dcp) / denom;\n  float w = (dbb * dcp - dbc * dbp) / denom;\n  return vec3(1.0 - v - w, v, w);\n}\n\nvec3 barycentric(vec3 p, vec3 a, vec3 b, vec3 c) {\n  return barycentric(p - a, b - a, c - a);\n}\n\nfloat distanceToSegment(vec3 p, vec3 a, vec3 b) {\n  vec3 ab = b - a;\n  vec3 ap = p - a;\n\n  float t = clamp(dot(ap, ab) / dot(ab, ab), 0.0, 1.0);\n\n  vec3 projection = a + t * ab;\n  return length(p - projection);\n}\n\nmat2x3 create2DBasisVectors(vec3 normal) {\n  vec3 i = normalize(cross(normal, abs(normal.z) > 0.999 ? vec3(1, 0, 0) : vec3(0, 0, 1)));\n  vec3 j = cross(normal, i);\n\n  return mat2x3(i, j);\n}\n\nmat2x3 create2DBasisVectors(vec3 normal, float rotation) {\n  mat3 rotationMatrix = axisAngleMatrix(normal, rotation);\n  mat2x3 basis = create2DBasisVectors(normal);\n  return rotationMatrix*basis;\n}\n\nvec3 transformToZAxis(vec3 pos, vec3 center, vec3 direction, float orientation) {\n  vec3 r = normalize(direction); // Normal of transformed plane\n  bool isZ = length(r.xy) < 1e-9;\n  float angle = isZ ? 0.0 : atan(r.y, r.x);\n  vec3 i = isZ ? vec3(1, 0, 0) : normalize(vec3(r.y, -r.x, 0)); // Direction of x-axis transformed plane\n  vec3 j = cross(i, r); // Direction of y-axis along transformed plane\n  return axisAngle((pos - center)*mat3(i, j, r), vec3(0, 0, 1), angle + orientation);\n}\n\n";

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

@@ -0,0 +1,110 @@
+export const geometryDefinition = /*glsl*/ `
+
+export { 
+  rotate,
+  barycentric,
+  distanceToSegment,
+  axisAngle, axisAngleMatrix,
+  create2DBasisVectors,
+  transformToZAxis
+}
+
+vec2 rotate(vec2 vector, float rotation) {
+  float c = cos(rotation);
+  float s = sin(rotation);
+  return mat2(c, s, -s, c)*vector;
+}
+
+vec2 rotate(vec2 vector, vec2 center, float rotation) {
+  return center + rotate(vector - center, rotation);
+}
+
+// Rotates a vector around an axis using Rodrigues' formula
+vec3 axisAngle(vec3 vector, vec3 axis, float rotation) {
+  float c = cos(rotation);
+  float s = sin(rotation);
+  return vector*c + cross(axis, vector)*s + axis*dot(axis, vector)*(1.0 - c);
+}
+
+vec3 axisAngle(vec3 vector, vec3 origin, vec3 axis, float rotation) {
+  return axisAngle(vector - origin, axis, rotation) + origin;
+}
+
+mat3 axisAngleMatrix(vec3 axis, float rotation) {
+  mat3 K = mat3(
+    0, axis.z, -axis.y,
+    -axis.z, 0, axis.x,
+    axis.y, -axis.x, 0
+  );
+  return mat3(1.0) + sin(rotation)*K + (1.0 - cos(rotation))*K*K;
+}
+
+// Assumes first point has already been subtracted
+vec3 barycentric(vec2 p, vec2 b, vec2 c) {
+  float dbb = dot(b, b);
+  float dbc = dot(b, c);
+  float dcc = dot(c, c);
+  float dcp = dot(c, p);
+  float dbp = dot(b, p);
+
+  float denom = dbb * dcc - dbc * dbc;
+  float v = (dcc * dbp - dbc * dcp) / denom;
+  float w = (dbb * dcp - dbc * dbp) / denom;
+  return vec3(1.0 - v - w, v, w);
+}
+
+vec3 barycentric(vec2 p, vec2 a, vec2 b, vec2 c) {
+  return barycentric(p - a, b - a, c - a);
+}
+
+// Assumes first point has already been subtracted
+vec3 barycentric(vec3 p, vec3 b, vec3 c) {
+  float dbb = dot(b, b);
+  float dbc = dot(b, c);
+  float dcc = dot(c, c);
+  float dcp = dot(c, p);
+  float dbp = dot(b, p);
+
+  float denom = dbb * dcc - dbc * dbc;
+  float v = (dcc * dbp - dbc * dcp) / denom;
+  float w = (dbb * dcp - dbc * dbp) / denom;
+  return vec3(1.0 - v - w, v, w);
+}
+
+vec3 barycentric(vec3 p, vec3 a, vec3 b, vec3 c) {
+  return barycentric(p - a, b - a, c - a);
+}
+
+float distanceToSegment(vec3 p, vec3 a, vec3 b) {
+  vec3 ab = b - a;
+  vec3 ap = p - a;
+
+  float t = clamp(dot(ap, ab) / dot(ab, ab), 0.0, 1.0);
+
+  vec3 projection = a + t * ab;
+  return length(p - projection);
+}
+
+mat2x3 create2DBasisVectors(vec3 normal) {
+  vec3 i = normalize(cross(normal, abs(normal.z) > 0.999 ? vec3(1, 0, 0) : vec3(0, 0, 1)));
+  vec3 j = cross(normal, i);
+
+  return mat2x3(i, j);
+}
+
+mat2x3 create2DBasisVectors(vec3 normal, float rotation) {
+  mat3 rotationMatrix = axisAngleMatrix(normal, rotation);
+  mat2x3 basis = create2DBasisVectors(normal);
+  return rotationMatrix*basis;
+}
+
+vec3 transformToZAxis(vec3 pos, vec3 center, vec3 direction, float orientation) {
+  vec3 r = normalize(direction); // Normal of transformed plane
+  bool isZ = length(r.xy) < 1e-9;
+  float angle = isZ ? 0.0 : atan(r.y, r.x);
+  vec3 i = isZ ? vec3(1, 0, 0) : normalize(vec3(r.y, -r.x, 0)); // Direction of x-axis transformed plane
+  vec3 j = cross(i, r); // Direction of y-axis along transformed plane
+  return axisAngle((pos - center)*mat3(i, j, r), vec3(0, 0, 1), angle + orientation);
+}
+
+`;

package/dist/shader-modules/modules/math.d.ts

@@ -0,0 +1 @@
+export declare const mathDefinition = "\n\nexport { binom }\n\n// Computes the binomial coefficient (\"n choose k\")\nint binom(int n, int k) {\n  float nf = float(n);\n  float kf = float(min(k, n - k));\n  float result = 1.0;\n\n  for (float i = 0; i < kf; i++) {\n    result *= (nf - i)/(i + 1);\n  }\n\n  return int(result);\n}\n\n\n";

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

@@ -0,0 +1,19 @@
+export const mathDefinition = /*glsl*/ `
+
+export { binom }
+
+// Computes the binomial coefficient ("n choose k")
+int binom(int n, int k) {
+  float nf = float(n);
+  float kf = float(min(k, n - k));
+  float result = 1.0;
+
+  for (float i = 0; i < kf; i++) {
+    result *= (nf - i)/(i + 1);
+  }
+
+  return int(result);
+}
+
+
+`;

package/dist/shader-modules/modules/noise.d.ts

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