@matboks/utilities 0.0.2 → 0.0.18

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

@@ -1 +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";
+export declare const constantsDefinition = "\n\nexport {\n  PI, TWO_PI, SQRT_2, INV_SQRT_2, SQRT_3, E, GOLDEN_RATIO, EPS\n}\n\nconst float PI           = 3.1415926535897932384626433832795;\nconst float TWO_PI       = 6.2831853071795864769252867665590;\nconst float SQRT_2       = 1.4142135623730950488016887242097;\nconst float INV_SQRT_2   = 0.7071067811865475244008443621048;\nconst float SQRT_3       = 1.7320508075688772935274463415058;\nconst float E            = 2.7182818284590452353602874713527;\nconst float GOLDEN_RATIO = 1.6180339887498948482045868343656;\nconst float EPS          = 1e-9;\n\n\n";

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

@@ -1,14 +1,17 @@
 export const constantsDefinition = /*glsl*/ `
 
 export {
-  PI, TWO_PI, SQRT_2, INV_SQRT_2, EPS
+  PI, TWO_PI, SQRT_2, INV_SQRT_2, SQRT_3, E, GOLDEN_RATIO, 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;
+const float PI           = 3.1415926535897932384626433832795;
+const float TWO_PI       = 6.2831853071795864769252867665590;
+const float SQRT_2       = 1.4142135623730950488016887242097;
+const float INV_SQRT_2   = 0.7071067811865475244008443621048;
+const float SQRT_3       = 1.7320508075688772935274463415058;
+const float E            = 2.7182818284590452353602874713527;
+const float GOLDEN_RATIO = 1.6180339887498948482045868343656;
+const float EPS          = 1e-9;
 
 
 `;

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

@@ -1 +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 valueNoise(vec4 p, float scale, float seed) {\n  p *= scale;\n\n  vec4 pi = floor(p);\n  vec4 pf = fract(p);\n\n  vec4 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  return mix(\n    mix(\n      mix(\n        mix(random(pi, seed), random(pi + o.xyyy, seed), sf.x),\n        mix(random(pi + o.yxyy, seed), random(pi + o.xxyy, seed), sf.x),\n        sf.y\n      ),\n      mix(\n        mix(random(pi + o.yyxy, seed), random(pi + o.xyxy, seed), sf.x),\n        mix(random(pi + o.yxxy, seed), random(pi + o.xxxy, seed), sf.x),\n        sf.y\n      ), \n      sf.z\n    ),\n    mix(\n      mix(\n        mix(random(pi + o.yyyx, seed), random(pi + o.xyyx, seed), sf.x),\n        mix(random(pi + o.yxyx, seed), random(pi + o.xxyx, seed), sf.x),\n        sf.y\n      ),\n      mix(\n        mix(random(pi + o.yyxx, seed), random(pi + o.xyxx, seed), sf.x),\n        mix(random(pi + o.yxxx, seed), random(pi + o.xxxx, seed), sf.x),\n        sf.y\n      ), \n      sf.z\n    ),\n    sf.w\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";
+export declare const noiseDefinition = "\nimport { random, random2, random3, random4, randomUnit } from \"@/random\";\nimport { triangleWave, dot2, signed } from \"@/utils\";\nimport { rotate, axisAngle } from \"@/geometry\";\nimport { PI, SQRT_2 } from \"@/constants\";\n\nexport {\n  valueNoise, perlinNoise, worleyNoise, voroNoise, gaboroNoise,\n  idwNoise, simplexNoise,\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 valueNoise(vec4 p, float scale, float seed) {\n  p *= scale;\n\n  vec4 pi = floor(p);\n  vec4 pf = fract(p);\n\n  vec4 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  return mix(\n    mix(\n      mix(\n        mix(random(pi, seed), random(pi + o.xyyy, seed), sf.x),\n        mix(random(pi + o.yxyy, seed), random(pi + o.xxyy, seed), sf.x),\n        sf.y\n      ),\n      mix(\n        mix(random(pi + o.yyxy, seed), random(pi + o.xyxy, seed), sf.x),\n        mix(random(pi + o.yxxy, seed), random(pi + o.xxxy, seed), sf.x),\n        sf.y\n      ), \n      sf.z\n    ),\n    mix(\n      mix(\n        mix(random(pi + o.yyyx, seed), random(pi + o.xyyx, seed), sf.x),\n        mix(random(pi + o.yxyx, seed), random(pi + o.xxyx, seed), sf.x),\n        sf.y\n      ),\n      mix(\n        mix(random(pi + o.yyxx, seed), random(pi + o.xyxx, seed), sf.x),\n        mix(random(pi + o.yxxx, seed), random(pi + o.xxxx, seed), sf.x),\n        sf.y\n      ), \n      sf.z\n    ),\n    sf.w\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 value = mix(signed(random(pi, seed))*pf, signed(random(pi + 1.0, seed))*(pf - 1.0), sf);\n  \n  return 0.5 + value;\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 value = 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  return 0.5 + 0.70710678118654752*value;\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 value = 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  return 0.5 + 0.75*value;\n}\n\nfloat perlinNoise(vec4 p, float scale, float seed) {\n  p *= scale;\n\n  vec4 pi = floor(p);\n  vec4 pf = fract(p);\n\n  vec4 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  float value = mix(\n    mix(\n      mix(\n        mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xyyy, seed), pf - o.xyyy), sf.x),\n        mix(dot(randomUnit(pi + o.yxyy, seed), pf - o.yxyy), dot(randomUnit(pi + o.xxyy, seed), pf - o.xxyy), sf.x),\n        sf.y\n      ),\n      mix(\n        mix(dot(randomUnit(pi + o.yyxy, seed), pf - o.yyxy), dot(randomUnit(pi + o.xyxy, seed), pf - o.xyxy), sf.x),\n        mix(dot(randomUnit(pi + o.yxxy, seed), pf - o.yxxy), dot(randomUnit(pi + o.xxxy, seed), pf - o.xxxy), sf.x),\n        sf.y\n      ), \n      sf.z\n    ),\n    mix(\n      mix(\n        mix(dot(randomUnit(pi + o.yyyx, seed), pf - o.yyyx), dot(randomUnit(pi + o.xyyx, seed), pf - o.xyyx), sf.x),\n        mix(dot(randomUnit(pi + o.yxyx, seed), pf - o.yxyx), dot(randomUnit(pi + o.xxyx, seed), pf - o.xxyx), sf.x),\n        sf.y\n      ),\n      mix(\n        mix(dot(randomUnit(pi + o.yyxx, seed), pf - o.yyxx), dot(randomUnit(pi + o.xyxx, seed), pf - o.xyxx), sf.x),\n        mix(dot(randomUnit(pi + o.yxxx, seed), pf - o.yxxx), dot(randomUnit(pi + o.xxxx, seed), pf - o.xxxx), sf.x),\n        sf.y\n      ), \n      sf.z\n    ),\n    sf.w\n  );\n\n  return 0.5 + value;\n}\n\nfloat worleyNoise(float p, float scale, float seed) {\n  p *= scale;\n\n  float pi = floor(p);\n\n  float minDist = 1e9;\n\n  for (int index = -1; index <= 1; index++) {\n    float fi = pi + float(index);\n    float centerToPosition = fi + random(fi, seed) - p;\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\n  float minDist2 = 1e9;\n\n  for (int row = -1; row <= 1; row++) {\n    for (int col = -1; col <= 1; col++) {\n      vec2 index = pi + vec2(col, row);\n      \n      vec2 centerToPosition = index + random2(index, seed) - p;\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\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 = pi + vec3(col, row, slice);\n      \n        vec3 centerToPosition = index + random3(index, seed) - p;\n        float dist2 = dot2(centerToPosition);\n\n        minDist2 = min(minDist2, dist2);\n      }\n    }\n  }\n\n  return sqrt(minDist2);\n}\n\nfloat worleyNoise(vec4 p, float scale, float seed) {\n  p *= scale;\n\n  vec4 pi = floor(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        for (int depth = -1; depth <= 1; depth++) {\n          vec4 index = pi + vec4(col, row, slice, depth);\n      \n          vec4 centerToPosition = index + random4(index, seed) - p;\n          float dist2 = dot(centerToPosition, centerToPosition);\n\n          minDist2 = min(minDist2, dist2);\n        }\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\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 = pi + vec2(col, row);\n\n      // xy is cell center, z is value\n      vec3 data = random3(index, seed);\n\n      vec2 centerToPosition = index + data.xy*disorder - p;\n\n      float dist = length(centerToPosition);\n\n      float weight = pow(smoothstep(SQRT_2, 0.0, dist), power);\n\n      sum += weight*data.z;\n      weightSum += weight;\n    }\n  }\n\n  return sum / weightSum;\n}\n\n\nfloat voroNoise(vec3 p, float scale, float disorder, float smoothness, float seed) {\n  p *= scale;\n\n  vec3 pi = floor(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      for (int slice = -kernel; slice < kernel; slice++) {\n        vec3 index = pi + vec3(col, row, slice);\n\n        vec3 cellPosition = random3(index, seed);\n        float value = random(index, seed);\n\n        vec3 centerToPosition = index + cellPosition*disorder - p;\n\n        float dist = length(centerToPosition);\n\n        float weight = pow(smoothstep(SQRT_2, 0.0, dist), power);\n\n        sum += weight*value;\n        weightSum += weight;\n      }\n    }\n  }\n\n  return sum / weightSum;\n}\n\nfloat voroNoise(vec4 p, float scale, float disorder, float smoothness, float seed) {\n  p *= scale;\n\n  vec4 pi = floor(p);\n\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      for (int slice = -kernel; slice < kernel; slice++) {\n        for (int depth = -kernel; depth < kernel; depth++) {\n          vec4 index = pi + vec4(col, row, slice, depth);\n\n          vec4 cellPosition = random4(index, seed);\n          float value = random(index, seed);\n\n          vec4 centerToPosition = index + cellPosition*disorder - p;\n\n          float dist = length(centerToPosition);\n\n          float weight = pow(smoothstep(1.2, 0.0, dist), power);\n\n          sum += weight*value;\n          weightSum += weight;\n        }\n      }\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 + float(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 idwNoise(vec4 p, float power, float scale, float seed, int window) {\n  p *= scale;\n\n  vec4 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        for (int l = -window; l <= window; l++) {\n          vec4 cellCorner = pi + vec4(i, j, k, l);\n          float value = random(cellCorner, seed);\n\n          vec4 cellPosition = cellCorner + random4(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\n  return sum / weightSum;\n}\n\nmat2 ISOMETRIC_TO_SQUARE = mat2(\n  1.0 + sqrt(3.0),\n  1.0 - sqrt(3.0),\n  1.0 - sqrt(3.0),\n  1.0 + sqrt(3.0)\n) / (2.0*sqrt(2.0));\n\nmat2 SQUARE_TO_ISOMETRIC = mat2(\n  sqrt(3.0) + 1.0,\n  sqrt(3.0) - 1.0,\n  sqrt(3.0) - 1.0,\n  sqrt(3.0) + 1.0\n) / sqrt(6.0);\n\n\nfloat simplexNoise(vec2 p, float scale, float seed) {\n  p *= scale;\n  \n  vec2 pt = SQUARE_TO_ISOMETRIC*p;\n  vec2 pi = floor(pt);\n  vec2 pf = fract(pt);\n\n  vec2 a = ISOMETRIC_TO_SQUARE*pi;\n  vec2 b = ISOMETRIC_TO_SQUARE*(pi + vec2(1, 1));\n  vec2 c = ISOMETRIC_TO_SQUARE*(pi + (pf.x > pf.y ? vec2(1, 0) : vec2(0, 1)));\n\n  float weightFn = (vec2 p, vec2 v) => pow(1.0 - dot2(p - v), 4.);\n  \n  float w0 = weightFn(p, a);\n  float w1 = weightFn(p, b);\n  float w2 = weightFn(p, c);\n  \n  float v0 = dot(randomUnit(a, seed), p - a);\n  float v1 = dot(randomUnit(b, seed), p - b);\n  float v2 = dot(randomUnit(c, seed), p - c);\n  \n  float v = (w0*v0 + w1*v1 + w2*v2)/(w0 + w1 + w2);\n\n  return 0.5 + 0.9*v;\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";

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

@@ -1,11 +1,12 @@
 export const noiseDefinition = /*glsl*/ `
-import { random, random2, random3, randomUnit } from "@/random";
-import { triangleWave, dot2 } from "@/utils";
+import { random, random2, random3, random4, randomUnit } from "@/random";
+import { triangleWave, dot2, signed } from "@/utils";
 import { rotate, axisAngle } from "@/geometry";
-import { PI } from "@/constants";
+import { PI, SQRT_2 } from "@/constants";
 
 export {
-  valueNoise, perlinNoise, worleyNoise, voroNoise, gaboroNoise, 
+  valueNoise, perlinNoise, worleyNoise, voroNoise, gaboroNoise,
+  idwNoise, simplexNoise,
   octaveNoise1D, octaveNoise2D, octaveNoise3D
 }
 
@@ -109,10 +110,9 @@ float perlinNoise(float p, float scale, float seed) {
 
   float sf = smoothstep(0.0, 1.0, pf);
 
-  float signed = mix(random(pi, seed)*pf, random(pi + 1.0, seed)*(pf - 1.0), sf);
+  float value = mix(signed(random(pi, seed))*pf, signed(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;
+  return 0.5 + value;
 }
 
 float perlinNoise(vec2 p, float scale, float seed) {
@@ -124,14 +124,13 @@ float perlinNoise(vec2 p, float scale, float seed) {
   vec2 sf = smoothstep(0.0, 1.0, pf);
   vec2 o = vec2(1, 0);
 
-  float signed = mix(
+  float value = 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;
+  return 0.5 + 0.70710678118654752*value;
 }
 
 float perlinNoise(vec3 p, float scale, float seed) {
@@ -143,7 +142,7 @@ float perlinNoise(vec3 p, float scale, float seed) {
   vec3 sf = smoothstep(0.0, 1.0, pf);
   vec2 o = vec2(1, 0);
 
-  float signed = mix(
+  float value = 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),
@@ -157,21 +156,61 @@ float perlinNoise(vec3 p, float scale, float seed) {
     sf.z
   );
 
-  // Signed is in range [-sqrt(3/4), sqrt(3/4)], map to [0, 1]
-  return 0.5 + 0.57735026918962576*signed;
+  return 0.5 + 0.75*value;
+}
+
+float perlinNoise(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);
+
+  float value = mix(
+    mix(
+      mix(
+        mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xyyy, seed), pf - o.xyyy), sf.x),
+        mix(dot(randomUnit(pi + o.yxyy, seed), pf - o.yxyy), dot(randomUnit(pi + o.xxyy, seed), pf - o.xxyy), sf.x),
+        sf.y
+      ),
+      mix(
+        mix(dot(randomUnit(pi + o.yyxy, seed), pf - o.yyxy), dot(randomUnit(pi + o.xyxy, seed), pf - o.xyxy), sf.x),
+        mix(dot(randomUnit(pi + o.yxxy, seed), pf - o.yxxy), dot(randomUnit(pi + o.xxxy, seed), pf - o.xxxy), sf.x),
+        sf.y
+      ), 
+      sf.z
+    ),
+    mix(
+      mix(
+        mix(dot(randomUnit(pi + o.yyyx, seed), pf - o.yyyx), dot(randomUnit(pi + o.xyyx, seed), pf - o.xyyx), sf.x),
+        mix(dot(randomUnit(pi + o.yxyx, seed), pf - o.yxyx), dot(randomUnit(pi + o.xxyx, seed), pf - o.xxyx), sf.x),
+        sf.y
+      ),
+      mix(
+        mix(dot(randomUnit(pi + o.yyxx, seed), pf - o.yyxx), dot(randomUnit(pi + o.xyxx, seed), pf - o.xyxx), sf.x),
+        mix(dot(randomUnit(pi + o.yxxx, seed), pf - o.yxxx), dot(randomUnit(pi + o.xxxx, seed), pf - o.xxxx), sf.x),
+        sf.y
+      ), 
+      sf.z
+    ),
+    sf.w
+  );
+
+  return 0.5 + value;
 }
 
 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;
+    float fi = pi + float(index);
+    float centerToPosition = fi + random(fi, seed) - p;
 
     minDist = min(minDist, abs(centerToPosition));
   }
@@ -183,15 +222,14 @@ 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 index = pi + vec2(col, row);
       
-      vec2 centerToPosition = index + random2(pi + index, seed) - pf;
+      vec2 centerToPosition = index + random2(index, seed) - p;
       float dist2 = dot2(centerToPosition);
 
       minDist2 = min(minDist2, dist2);
@@ -205,16 +243,15 @@ 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 index = pi + vec3(col, row, slice);
       
-        vec3 centerToPosition = index + random3(pi + index, seed) - pf;
+        vec3 centerToPosition = index + random3(index, seed) - p;
         float dist2 = dot2(centerToPosition);
 
         minDist2 = min(minDist2, dist2);
@@ -225,12 +262,36 @@ float worleyNoise(vec3 p, float scale, float seed) {
   return sqrt(minDist2);
 }
 
+float worleyNoise(vec4 p, float scale, float seed) {
+  p *= scale;
+
+  vec4 pi = floor(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++) {
+        for (int depth = -1; depth <= 1; depth++) {
+          vec4 index = pi + vec4(col, row, slice, depth);
+      
+          vec4 centerToPosition = index + random4(index, seed) - p;
+          float dist2 = dot(centerToPosition, 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;
@@ -242,16 +303,16 @@ float voroNoise(vec2 p, float scale, float disorder, float smoothness, float see
 
   for (int row = -kernel; row <= kernel; row++) {
     for (int col = -kernel; col <= kernel; col++) {
-      vec2 index = vec2(col, row);
+      vec2 index = pi + vec2(col, row);
 
       // xy is cell center, z is value
-      vec3 data = random3(pi + index, seed);
+      vec3 data = random3(index, seed);
 
-      vec2 centerToPosition = index + data.xy*disorder - pf;
+      vec2 centerToPosition = index + data.xy*disorder - p;
 
-      float dist2 = dot2(centerToPosition);
+      float dist = length(centerToPosition);
 
-      float weight = pow(smoothstep(1.0, 0.0, sqrt(0.5*dist2)), power );
+      float weight = pow(smoothstep(SQRT_2, 0.0, dist), power);
 
       sum += weight*data.z;
       weightSum += weight;
@@ -261,6 +322,80 @@ float voroNoise(vec2 p, float scale, float disorder, float smoothness, float see
   return sum / weightSum;
 }
 
+
+float voroNoise(vec3 p, float scale, float disorder, float smoothness, float seed) {
+  p *= scale;
+
+  vec3 pi = floor(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++) {
+      for (int slice = -kernel; slice < kernel; slice++) {
+        vec3 index = pi + vec3(col, row, slice);
+
+        vec3 cellPosition = random3(index, seed);
+        float value = random(index, seed);
+
+        vec3 centerToPosition = index + cellPosition*disorder - p;
+
+        float dist = length(centerToPosition);
+
+        float weight = pow(smoothstep(SQRT_2, 0.0, dist), power);
+
+        sum += weight*value;
+        weightSum += weight;
+      }
+    }
+  }
+
+  return sum / weightSum;
+}
+
+float voroNoise(vec4 p, float scale, float disorder, float smoothness, float seed) {
+  p *= scale;
+
+  vec4 pi = floor(p);
+
+  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++) {
+      for (int slice = -kernel; slice < kernel; slice++) {
+        for (int depth = -kernel; depth < kernel; depth++) {
+          vec4 index = pi + vec4(col, row, slice, depth);
+
+          vec4 cellPosition = random4(index, seed);
+          float value = random(index, seed);
+
+          vec4 centerToPosition = index + cellPosition*disorder - p;
+
+          float dist = length(centerToPosition);
+
+          float weight = pow(smoothstep(1.2, 0.0, dist), power);
+
+          sum += weight*value;
+          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;
 
@@ -305,7 +440,7 @@ float idwNoise(float p, float power, float scale, float seed, int window) {
   float powerCoeff = -power;
 
   for (int i = -window; i <= window; i++) {
-    float cellCorner = pi + i;
+    float cellCorner = pi + float(i);
     float value = random(cellCorner, seed);
 
     float cellPosition = cellCorner + random(cellCorner, seed);
@@ -379,6 +514,79 @@ float idwNoise(vec3 p, float power, float scale, float seed, int window) {
   return sum / weightSum;
 }
 
+float idwNoise(vec4 p, float power, float scale, float seed, int window) {
+  p *= scale;
+
+  vec4 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++) {
+        for (int l = -window; l <= window; l++) {
+          vec4 cellCorner = pi + vec4(i, j, k, l);
+          float value = random(cellCorner, seed);
+
+          vec4 cellPosition = cellCorner + random4(cellCorner, seed);
+
+          float w = pow(dot2(p - cellPosition), powerCoeff);
+          
+          if (isinf(w)) return value;
+
+          sum += w*value;
+          weightSum += w;
+        }
+      }  
+    }  
+  }
+
+  return sum / weightSum;
+}
+
+mat2 ISOMETRIC_TO_SQUARE = mat2(
+  1.0 + sqrt(3.0),
+  1.0 - sqrt(3.0),
+  1.0 - sqrt(3.0),
+  1.0 + sqrt(3.0)
+) / (2.0*sqrt(2.0));
+
+mat2 SQUARE_TO_ISOMETRIC = mat2(
+  sqrt(3.0) + 1.0,
+  sqrt(3.0) - 1.0,
+  sqrt(3.0) - 1.0,
+  sqrt(3.0) + 1.0
+) / sqrt(6.0);
+
+
+float simplexNoise(vec2 p, float scale, float seed) {
+  p *= scale;
+  
+  vec2 pt = SQUARE_TO_ISOMETRIC*p;
+  vec2 pi = floor(pt);
+  vec2 pf = fract(pt);
+
+  vec2 a = ISOMETRIC_TO_SQUARE*pi;
+  vec2 b = ISOMETRIC_TO_SQUARE*(pi + vec2(1, 1));
+  vec2 c = ISOMETRIC_TO_SQUARE*(pi + (pf.x > pf.y ? vec2(1, 0) : vec2(0, 1)));
+
+  float weightFn = (vec2 p, vec2 v) => pow(1.0 - dot2(p - v), 4.);
+  
+  float w0 = weightFn(p, a);
+  float w1 = weightFn(p, b);
+  float w2 = weightFn(p, c);
+  
+  float v0 = dot(randomUnit(a, seed), p - a);
+  float v1 = dot(randomUnit(b, seed), p - b);
+  float v2 = dot(randomUnit(c, seed), p - c);
+  
+  float v = (w0*v0 + w1*v1 + w2*v2)/(w0 + w1 + w2);
+
+  return 0.5 + 0.9*v;
+}
+
 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);

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

@@ -1 +1 @@
-export declare const randomDefinition = "\nimport { TWO_PI, PI } from \"@/constants\";\n\nexport { \n  random, random2, random3, random4,\n  randomGauss,\n  randomUnit\n };\n\nuint hash(uint value) {\n  value += 2127912214u;\n  value ^= value >> 12;\n  value *= 3345072700u;\n  value ^= value >> 19;\n\n  return value;\n}\n\nuint hash(uvec2 v) {\n  return hash(v.x ^ hash(v.y));\n}\n\nuint hash(uvec3 v) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z)));\n}\n\nuint hash(uvec4 v) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w))));\n}\n\nuint hash(uvec4 v, uint u) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w ^ hash(u)))));\n}\n\nfloat hashToFloat(uint u) {\n  uint mant = 8388607u;\n  uint one = 1065353216u;\n\n  u &= mant;\n  u |= one;\n\n  float f = uintBitsToFloat(u);\n  return f - 1.0;\n}\n\nfloat random(float p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec2 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec3 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec4 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(float p, float seed) {\n  return random(vec2(p, seed));\n}\n\nfloat random(vec2 p, float seed) {\n  return random(vec3(p, seed));\n}\n\nfloat random(vec3 p, float seed) {\n  return random(vec4(p, seed));\n}\n\nfloat random(vec4 p, float seed) {\n  return hashToFloat(hash(floatBitsToUint(p), floatBitsToUint(seed)));\n}\n\nvec2 random2(float p, float seed) {\n  return vec2(random(vec3(p, seed, 0), random(vec3(p, seed, 1))));\n}\n\nvec2 random2(float p) {\n  return random2(p, 0.);\n}\n\nvec2 random2(vec2 p, float seed) {\n  return vec2(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)));\n}\n\nvec2 random2(vec2 p) {\n  return random2(p, 0.0);\n}\n\nvec2 random2(vec3 p, float seed) {\n  return vec2(random(vec4(p, seed), 0.), random(vec4(p, seed), 1.));\n}\n\nvec2 random2(vec3 p) {\n  return random2(p, 0.0);\n}\n\nvec3 random3(float p, float seed) {\n  return vec3(\n    random(vec3(p, seed, 0)), \n    random(vec3(p, seed, 1)), \n    random(vec3(p, seed, 2))\n  );\n}\n\nvec3 random3(float p) {\n  return random3(p, 0.0);\n}\n\nvec3 random3(vec2 p, float seed) {\n  return vec3(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)), random(vec4(p, seed, 2)));\n}\n\nvec3 random3(vec2 p) {\n  return random3(p, 0.0);\n}\n\nvec3 random3(vec3 p, float seed) {\n  return vec3(random(vec4(p, seed), 0.0), random(vec4(p, seed), 1.0), random(vec4(p, seed), 2.0));\n}\n\nvec4 random4(vec4 p, float seed) {\n  return vec4(\n    random(p, seed),\n    random(p, random(seed, 1.0)),\n    random(p, random(seed, 2.0)),\n    random(p, random(seed, 3.0))\n  );\n}\n\nvec4 random4(vec4 p, float seed) {\n  return random4(p, 0.0);\n}\n\nfloat randomGaussian(vec3 p, float seed) {\n  float u1 = random(vec4(p, 1), seed);\n  float u2 = random(vec4(p, 2), seed);\n  return sqrt(-2.0 * log(u1)) * cos(TWO_PI * u2);\n}\n\nfloat randomGaussian(vec4 p, float seed) {\n  float u1 = random(p, seed);\n  float u2 = random(p, random(seed));\n  return sqrt(-2.0 * log(u1)) * cos(TWO_PI * u2);\n}\n\nvec2 randomUnit(vec2 p, float seed) {\n  float direction = TWO_PI*random(p, seed);\n  return vec2(cos(direction), sin(direction));\n}\n\nvec3 randomUnit(vec3 p, float seed) {\n  return normalize(vec3(\n    randomGaussian(p, seed),\n    randomGaussian(p, random(seed, 1.)),\n    randomGaussian(p, random(seed, 2.))\n  ));\n}\n\nvec4 randomUnit(vec4 p, float seed) {\n  return normalize(vec4(\n    randomGaussian(p, seed),\n    randomGaussian(p, random(seed, 1.)),\n    randomGaussian(p, random(seed, 2.)),\n    randomGaussian(p, random(seed, 3.))\n  ));\n}\n\n";
+export declare const randomDefinition = "\nimport { TWO_PI, PI } from \"@/constants\";\n\nexport { \n  random, random2, random3, random4,\n  randomUnit\n };\n\nconst float SEED_OFFSET = 2123.1415926535897932384626433832795;\n\nuint hash(uint x) {\n  x += 2127912214u;\n  x ^= x >> 15;\n  x *= 3545902487u;\n  return x;\n}\n\nuint hash(uvec2 v) {\n  return hash(v.x ^ hash(v.y));\n}\n\nuint hash(uvec3 v) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z)));\n}\n\nuint hash(uvec4 v) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w))));\n}\n\nuint hash(uvec4 v, uint u) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w ^ hash(u)))));\n}\n\nfloat hashToFloat(uint u) {\n  uint mant = 8388607u;\n  uint one = 1065353216u;\n\n  u &= mant;\n  u |= one;\n\n  float f = uintBitsToFloat(u);\n  return f - 1.0;\n}\n\nfloat random(float p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec2 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec3 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec4 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(float p, float seed) {\n  return random(vec2(p, seed));\n}\n\nfloat random(vec2 p, float seed) {\n  return random(vec3(p, seed));\n}\n\nfloat random(vec3 p, float seed) {\n  return random(vec4(p, seed));\n}\n\nfloat random(vec4 p, float seed) {\n  return hashToFloat(hash(floatBitsToUint(p), floatBitsToUint(seed)));\n}\n\nvec2 random2(float p, float seed) {\n  return vec2(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec2 random2(float p) {\n  return random2(p, 0.);\n}\n\nvec2 random2(vec2 p, float seed) {\n  return vec2(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec2 random2(vec2 p) {\n  return random2(p, 0.0);\n}\n\nvec2 random2(vec3 p, float seed) {\n  return vec2(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec2 random2(vec3 p) {\n  return random2(p, 0.0);\n}\n\nvec3 random3(float p, float seed) {\n  return vec3(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec3 random3(float p) {\n  return random3(p, 0.0);\n}\n\nvec3 random3(vec2 p, float seed) {\n  return vec3(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec3 random3(vec2 p) {\n  return random3(p, 0.0);\n}\n\nvec3 random3(vec3 p, float seed) {\n  return vec3(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec4 random4(vec4 p, float seed) {\n  return vec4(\n    random(p, seed),\n    random(p, seed += SEED_OFFSET),\n    random(p, seed += SEED_OFFSET),\n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec4 random4(vec4 p) {\n  return random4(p, 0.0);\n}\n\nvec2 randomUnit(vec2 p, float seed) {\n  float direction = TWO_PI*random(p, seed);\n  return vec2(cos(direction), sin(direction));\n}\n\nvec3 randomUnit(vec3 p, float seed) {\n  float z = -1.0 + 2.0*random(p, seed);\n  float theta = TWO_PI*random(p, seed += SEED_OFFSET);\n  float r = sqrt(1.0 - z*z);\n  return vec3(\n    r*cos(theta),\n    r*sin(theta),\n    z\n  );\n}\n\nvec4 randomUnit(vec4 p, float seed) {\n  float a1 = TWO_PI*random(p, seed);\n  float a2 = TWO_PI*random(p, seed += SEED_OFFSET);\n  float u = random(p, seed += SEED_OFFSET);\n  float r1 = sqrt(u);        \n  float r2 = sqrt(1.0 - u);\n\n  return vec4(\n    cos(a1) * r1,\n    sin(a1) * r1, \n    cos(a2) * r2, \n    sin(a2) * r2\n  );\n}\n\n";

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

@@ -3,17 +3,16 @@ import { TWO_PI, PI } from "@/constants";
 
 export { 
   random, random2, random3, random4,
-  randomGauss,
   randomUnit
  };
 
-uint hash(uint value) {
-  value += 2127912214u;
-  value ^= value >> 12;
-  value *= 3345072700u;
-  value ^= value >> 19;
+const float SEED_OFFSET = 2123.1415926535897932384626433832795;
 
-  return value;
+uint hash(uint x) {
+  x += 2127912214u;
+  x ^= x >> 15;
+  x *= 3545902487u;
+  return x;
 }
 
 uint hash(uvec2 v) {
@@ -76,7 +75,10 @@ float random(vec4 p, float seed) {
 }
 
 vec2 random2(float p, float seed) {
-  return vec2(random(vec3(p, seed, 0), random(vec3(p, seed, 1))));
+  return vec2(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET)
+  );
 }
 
 vec2 random2(float p) {
@@ -84,7 +86,10 @@ vec2 random2(float p) {
 }
 
 vec2 random2(vec2 p, float seed) {
-  return vec2(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)));
+  return vec2(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET)
+  );
 }
 
 vec2 random2(vec2 p) {
@@ -92,7 +97,10 @@ vec2 random2(vec2 p) {
 }
 
 vec2 random2(vec3 p, float seed) {
-  return vec2(random(vec4(p, seed), 0.), random(vec4(p, seed), 1.));
+  return vec2(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET)
+  );
 }
 
 vec2 random2(vec3 p) {
@@ -101,9 +109,9 @@ vec2 random2(vec3 p) {
 
 vec3 random3(float p, float seed) {
   return vec3(
-    random(vec3(p, seed, 0)), 
-    random(vec3(p, seed, 1)), 
-    random(vec3(p, seed, 2))
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET), 
+    random(p, seed += SEED_OFFSET)
   );
 }
 
@@ -112,7 +120,11 @@ vec3 random3(float p) {
 }
 
 vec3 random3(vec2 p, float seed) {
-  return vec3(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)), random(vec4(p, seed, 2)));
+  return vec3(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET), 
+    random(p, seed += SEED_OFFSET)
+  );
 }
 
 vec3 random3(vec2 p) {
@@ -120,54 +132,55 @@ vec3 random3(vec2 p) {
 }
 
 vec3 random3(vec3 p, float seed) {
-  return vec3(random(vec4(p, seed), 0.0), random(vec4(p, seed), 1.0), random(vec4(p, seed), 2.0));
+  return vec3(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET), 
+    random(p, seed += SEED_OFFSET)
+  );
 }
 
 vec4 random4(vec4 p, float seed) {
   return vec4(
     random(p, seed),
-    random(p, random(seed, 1.0)),
-    random(p, random(seed, 2.0)),
-    random(p, random(seed, 3.0))
+    random(p, seed += SEED_OFFSET),
+    random(p, seed += SEED_OFFSET),
+    random(p, seed += SEED_OFFSET)
   );
 }
 
-vec4 random4(vec4 p, float seed) {
+vec4 random4(vec4 p) {
   return random4(p, 0.0);
 }
 
-float randomGaussian(vec3 p, float seed) {
-  float u1 = random(vec4(p, 1), seed);
-  float u2 = random(vec4(p, 2), seed);
-  return sqrt(-2.0 * log(u1)) * cos(TWO_PI * u2);
-}
-
-float randomGaussian(vec4 p, float seed) {
-  float u1 = random(p, seed);
-  float u2 = random(p, random(seed));
-  return sqrt(-2.0 * log(u1)) * cos(TWO_PI * u2);
-}
-
 vec2 randomUnit(vec2 p, float seed) {
   float direction = TWO_PI*random(p, seed);
   return vec2(cos(direction), sin(direction));
 }
 
 vec3 randomUnit(vec3 p, float seed) {
-  return normalize(vec3(
-    randomGaussian(p, seed),
-    randomGaussian(p, random(seed, 1.)),
-    randomGaussian(p, random(seed, 2.))
-  ));
+  float z = -1.0 + 2.0*random(p, seed);
+  float theta = TWO_PI*random(p, seed += SEED_OFFSET);
+  float r = sqrt(1.0 - z*z);
+  return vec3(
+    r*cos(theta),
+    r*sin(theta),
+    z
+  );
 }
 
 vec4 randomUnit(vec4 p, float seed) {
-  return normalize(vec4(
-    randomGaussian(p, seed),
-    randomGaussian(p, random(seed, 1.)),
-    randomGaussian(p, random(seed, 2.)),
-    randomGaussian(p, random(seed, 3.))
-  ));
+  float a1 = TWO_PI*random(p, seed);
+  float a2 = TWO_PI*random(p, seed += SEED_OFFSET);
+  float u = random(p, seed += SEED_OFFSET);
+  float r1 = sqrt(u);        
+  float r2 = sqrt(1.0 - u);
+
+  return vec4(
+    cos(a1) * r1,
+    sin(a1) * r1, 
+    cos(a2) * r2, 
+    sin(a2) * r2
+  );
 }
 
 `;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matboks/utilities",
-  "version": "0.0.2",
+  "version": "0.0.18",
   "main": "./dist/index.js",
   "files": [
     "dist"

package/dist/constants 2.js

@@ -1 +0,0 @@
-export const EPS = 1e-9;

package/dist/constants 3.js

@@ -1 +0,0 @@
-export const EPS = 1e-9;

package/dist/constants.d 2.ts

@@ -1 +0,0 @@
-export declare const EPS = 1e-9;

package/dist/constants.d 3.ts

@@ -1 +0,0 @@
-export declare const EPS = 1e-9;

package/dist/index 2.js

@@ -1,11 +0,0 @@
-export * from "./geometry/index.js";
-export * from "./math/index.js";
-export * from "./utilities/index.js";
-export * from "./noise/index.js";
-export * from "./constants.js";
-export * from "./tilings/index.js";
-export * from "./transformations/index.js";
-export * from "./types.js";
-export * from "./shader-renderer/index.js";
-export * from "./shader-modules/index.js";
-export * from "./constants.js";

package/dist/index 3.js

@@ -1,11 +0,0 @@
-export * from "./geometry/index.js";
-export * from "./math/index.js";
-export * from "./utilities/index.js";
-export * from "./noise/index.js";
-export * from "./constants.js";
-export * from "./tilings/index.js";
-export * from "./transforms/index.js";
-export * from "./types.js";
-export * from "./shader-renderer/index.js";
-export * from "./shader-modules/index.js";
-export * from "./constants.js";

package/dist/index.d 2.ts

@@ -1,11 +0,0 @@
-export * from "./geometry/index.js";
-export * from "./math/index.js";
-export * from "./utilities/index.js";
-export * from "./noise/index.js";
-export * from "./constants.js";
-export * from "./tilings/index.js";
-export * from "./transformations/index.js";
-export * from "./types.js";
-export * from "./shader-renderer/index.js";
-export * from "./shader-modules/index.js";
-export * from "./constants.js";

package/dist/index.d 3.ts

@@ -1,11 +0,0 @@
-export * from "./geometry/index.js";
-export * from "./math/index.js";
-export * from "./utilities/index.js";
-export * from "./noise/index.js";
-export * from "./constants.js";
-export * from "./tilings/index.js";
-export * from "./transforms/index.js";
-export * from "./types.js";
-export * from "./shader-renderer/index.js";
-export * from "./shader-modules/index.js";
-export * from "./constants.js";

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

@@ -1 +0,0 @@
-export declare const sdfDefinition = "\n\nimport { barycentric, transformToZAxis } from \"@/geometry\";\nimport { lerp, signed } from \"@/utils\";\n\nexport {\n  sphere, box, rectangularCylinder, \n  discoBall, polygon, donut, boxFrame,\n  triangleSDFSquared, meshSDF, sdfNormal\n}\n\nfloat sphere(vec3 p, vec3 center, float radius) {\n  return length(p - center) - radius;\n}\n\nfloat box(vec3 p, vec3 center, vec3 direction, vec3 size) {\n  p = transformToZAxis(p, center, direction, 0.0);\n  p = abs(p) - size/2.0;\n\n  // First part gives distance inside box, second part outside\n  return min(max(max(p.x, p.y), p.z), 0.0) + length(max(p, vec3(0)));\n}\n\nfloat rectangularCylinder(vec3 p, vec3 center, vec3 direction, vec2 size, float height, bool offsetCenter, float rotation) {\n  if (offsetCenter) center += 0.5*height*normalize(direction);\n  p = transformToZAxis(p, center, direction, rotation);\n  return box(p, vec3(0), vec3(0, 0, 1), vec3(size, height));\n}\n\nfloat discoBall(vec3 p, vec3 center, float radius, float n, float o) {\n  p -= center;\n  float phi = -PI + 2.0*PI*(round(lerp(atan(p.y, p.x), -PI, PI)*n)/n + o);\n  float theta = PI*(round(lerp(acos(p.z/length(p)), 0.0, PI)*n)/n + o);\n\n  vec3 bp = vec3(sin(theta)*cos(phi), sin(theta)*sin(phi), cos(theta));\n\n  return dot(bp, p - radius*bp);\n}\n\nfloat discoBall(vec3 p, vec3 center, float radius, float n) {\n  return discoBall(p, center, radius, n, 0.0);\n}\n\nfloat polygon(vec2 p, float radius, float n) {\n  float theta = PI*signed((floor(lerp(atan(p.y, p.x), -PI, PI)*n) + .5)/n);\n  vec2 pp = vec2(cos(theta), sin(theta));\n  return dot(pp, p - radius*pp);\n}\n\nfloat donut(vec3 p, vec3 center, vec3 direction, float innerRadius, float outerRadius, float rotation, float sections, float sides) {\n  p = transformToZAxis(p, center, direction, 0.0);\n\n  vec3 xy = normalize(vec3(p.xy, 0));\n  float angle = mod(atan(xy.y, xy.x), 2.*PI);\n\n  angle = 2.*PI*round(sections*angle/(2.*PI))/sections;\n  innerRadius *= sqrt(PI/(sections*tan(PI/sections)));\n  outerRadius *= sqrt(PI/(sides*tan(PI/sides)));\n  return polygon(rotate(vec2(dot(p, vec3(cos(angle), sin(angle), 0)) - innerRadius, p.z), rotation + PI/4.), outerRadius, sides);\n}\n\nfloat boxFrame(vec3 p, vec3 center, vec3 direction, vec3 size, float thickness) {\n  float dBox = box(p, center, direction, size);\n\n  p = transformToZAxis(p, center, direction, 0.0);\n\n  vec3 o = 2.0*vec3(thickness, thickness, -1e9);\n  float dX = box(p, vec3(0), vec3(1, 0, 0), size.yzx - o);\n  float dY = box(p, vec3(0), vec3(0, 1, 0), size.zxy - o);\n  float dZ = box(p, vec3(0), vec3(0, 0, 1), size.xyz - o);\n\n  float dInner = min(dX, min(dY, dZ));\n  return max(dBox, -dInner);\n}\n\n// x is distance squared, y indicates which side of triangle p is on \n// (relative to normal: positive if p is above, negative if below)\nvec2 triangleSDFSquared(vec3 p, vec3 a, vec3 b, vec3 c) {\n  vec3 ab = b - a;\n  vec3 ca = a - c;\n  vec3 bc = c - b;\n\n  vec3 ap = p - a;\n  vec3 bp = p - b;\n  vec3 cp = p - c;\n\n  vec3 normal = cross(ab, -ca); // Negate to make cross(ab, ac), follows right-hand rule assuming abc is CCW\n  \n  bool isInsideTriangle = all(greaterThan(barycentric(p, a, b, c), vec3(0)));\n  \n  float dot2 = (vec3 v) => dot(v, v);  \n\n  bool isInsideXYProjection = all(greaterThan(barycentric(p.xy, a.xy, b.xy, c.xy), vec3(0)));\n\n  float distSquared;\n  bool isAboveXYProjection;\n\n  // If p is above XY projection, then dist = dot(ap, normal) > 0 when normal points upwards\n  // and dist < 0 when it points downwards. sign(normal.z)*dist > 0.0 then tells us if p is above \n  if (isInsideTriangle) {\n    float dist = dot(ap, normalize(normal));\n    distSquared = dist*dist;\n    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dist > 0.0;\n  } else {\n    distSquared = min(min(\n      dot2(ap - ab*clamp(dot(ap, ab) / dot2(ab), 0.0, 1.0)),\n      dot2(bp - bc*clamp(dot(bp, bc) / dot2(bc), 0.0, 1.0))),\n      dot2(cp - ca*clamp(dot(cp, ca) / dot2(ca), 0.0, 1.0))\n    );\n    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dot(ap, normal) > 0.0;\n  }\n\n  return vec2(distSquared, isAboveXYProjection ? -1.0 : 1.0);\n}\n\nvec3 sdfNormal(vec3 p, float sdf(vec3), float h) {\n  vec2 o = vec2(1, -1)*h;\n  return normalize( \n    o.xyy*sdf(p + o.xyy) +                     \n    o.yyx*sdf(p + o.yyx) + \n    o.yxy*sdf(p + o.yxy) + \n    o.xxx*sdf(p + o.xxx)\n  );\n}\n\n";

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

@@ -1,126 +0,0 @@
-export const sdfDefinition = /*glsl*/ `
-
-import { barycentric, transformToZAxis } from "@/geometry";
-import { lerp, signed } from "@/utils";
-
-export {
-  sphere, box, rectangularCylinder, 
-  discoBall, polygon, donut, boxFrame,
-  triangleSDFSquared, meshSDF, sdfNormal
-}
-
-float sphere(vec3 p, vec3 center, float radius) {
-  return length(p - center) - radius;
-}
-
-float box(vec3 p, vec3 center, vec3 direction, vec3 size) {
-  p = transformToZAxis(p, center, direction, 0.0);
-  p = abs(p) - size/2.0;
-
-  // First part gives distance inside box, second part outside
-  return min(max(max(p.x, p.y), p.z), 0.0) + length(max(p, vec3(0)));
-}
-
-float rectangularCylinder(vec3 p, vec3 center, vec3 direction, vec2 size, float height, bool offsetCenter, float rotation) {
-  if (offsetCenter) center += 0.5*height*normalize(direction);
-  p = transformToZAxis(p, center, direction, rotation);
-  return box(p, vec3(0), vec3(0, 0, 1), vec3(size, height));
-}
-
-float discoBall(vec3 p, vec3 center, float radius, float n, float o) {
-  p -= center;
-  float phi = -PI + 2.0*PI*(round(lerp(atan(p.y, p.x), -PI, PI)*n)/n + o);
-  float theta = PI*(round(lerp(acos(p.z/length(p)), 0.0, PI)*n)/n + o);
-
-  vec3 bp = vec3(sin(theta)*cos(phi), sin(theta)*sin(phi), cos(theta));
-
-  return dot(bp, p - radius*bp);
-}
-
-float discoBall(vec3 p, vec3 center, float radius, float n) {
-  return discoBall(p, center, radius, n, 0.0);
-}
-
-float polygon(vec2 p, float radius, float n) {
-  float theta = PI*signed((floor(lerp(atan(p.y, p.x), -PI, PI)*n) + .5)/n);
-  vec2 pp = vec2(cos(theta), sin(theta));
-  return dot(pp, p - radius*pp);
-}
-
-float donut(vec3 p, vec3 center, vec3 direction, float innerRadius, float outerRadius, float rotation, float sections, float sides) {
-  p = transformToZAxis(p, center, direction, 0.0);
-
-  vec3 xy = normalize(vec3(p.xy, 0));
-  float angle = mod(atan(xy.y, xy.x), 2.*PI);
-
-  angle = 2.*PI*round(sections*angle/(2.*PI))/sections;
-  innerRadius *= sqrt(PI/(sections*tan(PI/sections)));
-  outerRadius *= sqrt(PI/(sides*tan(PI/sides)));
-  return polygon(rotate(vec2(dot(p, vec3(cos(angle), sin(angle), 0)) - innerRadius, p.z), rotation + PI/4.), outerRadius, sides);
-}
-
-float boxFrame(vec3 p, vec3 center, vec3 direction, vec3 size, float thickness) {
-  float dBox = box(p, center, direction, size);
-
-  p = transformToZAxis(p, center, direction, 0.0);
-
-  vec3 o = 2.0*vec3(thickness, thickness, -1e9);
-  float dX = box(p, vec3(0), vec3(1, 0, 0), size.yzx - o);
-  float dY = box(p, vec3(0), vec3(0, 1, 0), size.zxy - o);
-  float dZ = box(p, vec3(0), vec3(0, 0, 1), size.xyz - o);
-
-  float dInner = min(dX, min(dY, dZ));
-  return max(dBox, -dInner);
-}
-
-// x is distance squared, y indicates which side of triangle p is on 
-// (relative to normal: positive if p is above, negative if below)
-vec2 triangleSDFSquared(vec3 p, vec3 a, vec3 b, vec3 c) {
-  vec3 ab = b - a;
-  vec3 ca = a - c;
-  vec3 bc = c - b;
-
-  vec3 ap = p - a;
-  vec3 bp = p - b;
-  vec3 cp = p - c;
-
-  vec3 normal = cross(ab, -ca); // Negate to make cross(ab, ac), follows right-hand rule assuming abc is CCW
-  
-  bool isInsideTriangle = all(greaterThan(barycentric(p, a, b, c), vec3(0)));
-  
-  float dot2 = (vec3 v) => dot(v, v);  
-
-  bool isInsideXYProjection = all(greaterThan(barycentric(p.xy, a.xy, b.xy, c.xy), vec3(0)));
-
-  float distSquared;
-  bool isAboveXYProjection;
-
-  // If p is above XY projection, then dist = dot(ap, normal) > 0 when normal points upwards
-  // and dist < 0 when it points downwards. sign(normal.z)*dist > 0.0 then tells us if p is above 
-  if (isInsideTriangle) {
-    float dist = dot(ap, normalize(normal));
-    distSquared = dist*dist;
-    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dist > 0.0;
-  } else {
-    distSquared = min(min(
-      dot2(ap - ab*clamp(dot(ap, ab) / dot2(ab), 0.0, 1.0)),
-      dot2(bp - bc*clamp(dot(bp, bc) / dot2(bc), 0.0, 1.0))),
-      dot2(cp - ca*clamp(dot(cp, ca) / dot2(ca), 0.0, 1.0))
-    );
-    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dot(ap, normal) > 0.0;
-  }
-
-  return vec2(distSquared, isAboveXYProjection ? -1.0 : 1.0);
-}
-
-vec3 sdfNormal(vec3 p, float sdf(vec3), float h) {
-  vec2 o = vec2(1, -1)*h;
-  return normalize( 
-    o.xyy*sdf(p + o.xyy) +                     
-    o.yyx*sdf(p + o.yyx) + 
-    o.yxy*sdf(p + o.yxy) + 
-    o.xxx*sdf(p + o.xxx)
-  );
-}
-
-`;

package/dist/tilings/tiler.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tilings/tiler.js

@@ -1,4 +0,0 @@
-// abstract class Tiler {
-export {};
-//   abstract tileSingleShape(shape: )
-// } 

package/dist/types 2.js

@@ -1 +0,0 @@
-export {};

package/dist/types 3.js

@@ -1 +0,0 @@
-export {};

package/dist/types.d 2.ts

@@ -1 +0,0 @@
-export {};

package/dist/types.d 3.ts

@@ -1 +0,0 @@
-export {};