@matboks/utilities 0.0.1

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

@@ -0,0 +1,410 @@
+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;
+}
+
+`;

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

@@ -0,0 +1 @@
+export declare const randomDefinition = "\nimport { TWO_PI, PI } from \"@/constants\";\n\nexport { \n  random, random2, random3,\n  randomGauss,\n  randomUnit\n };\n\nuint hash(uint value) {\n  value ^= value >> 16;\n  value *= 569420461u;\n  value ^= value >> 15;\n  value *= 3545902487u;\n  value ^= value >> 15;\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\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\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\n\n\n";

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

@@ -0,0 +1,147 @@
+export const randomDefinition = /*glsl*/ `
+import { TWO_PI, PI } from "@/constants";
+
+export { 
+  random, random2, random3,
+  randomGauss,
+  randomUnit
+ };
+
+uint hash(uint value) {
+  value ^= value >> 16;
+  value *= 569420461u;
+  value ^= value >> 15;
+  value *= 3545902487u;
+  value ^= value >> 15;
+  return value;
+}
+
+uint hash(uvec2 v) {
+  return hash(v.x ^ hash(v.y));
+}
+
+uint hash(uvec3 v) {
+  return hash(v.x ^ hash(v.y ^ hash(v.z)));
+}
+
+uint hash(uvec4 v) {
+  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w))));
+}
+
+uint hash(uvec4 v, uint u) {
+  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w ^ hash(u)))));
+}
+
+float hashToFloat(uint u) {
+  uint mant = 8388607u;
+  uint one = 1065353216u;
+
+  u &= mant;
+  u |= one;
+
+  float f = uintBitsToFloat(u);
+  return f - 1.0;
+}
+
+float random(float p) {
+  return hashToFloat(hash(floatBitsToUint(p)));
+}
+
+float random(vec2 p) {
+  return hashToFloat(hash(floatBitsToUint(p)));
+}
+
+float random(vec3 p) {
+  return hashToFloat(hash(floatBitsToUint(p)));
+}
+
+float random(vec4 p) {
+  return hashToFloat(hash(floatBitsToUint(p)));
+}
+
+float random(float p, float seed) {
+  return random(vec2(p, seed));
+}
+
+float random(vec2 p, float seed) {
+  return random(vec3(p, seed));
+}
+
+float random(vec3 p, float seed) {
+  return random(vec4(p, seed));
+}
+
+float random(vec4 p, float seed) {
+  return hashToFloat(hash(floatBitsToUint(p), floatBitsToUint(seed)));
+}
+
+vec2 random2(float p, float seed) {
+  return vec2(random(vec3(p, seed, 0), random(vec3(p, seed, 1))));
+}
+
+vec2 random2(float p) {
+  return random2(p, 0.);
+}
+
+vec2 random2(vec2 p, float seed) {
+  return vec2(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)));
+}
+
+vec2 random2(vec2 p) {
+  return random2(p, 0.0);
+}
+
+vec2 random2(vec3 p, float seed) {
+  return vec2(random(vec4(p, seed), 0.), random(vec4(p, seed), 1.));
+}
+
+vec2 random2(vec3 p) {
+  return random2(p, 0.0);
+}
+
+vec3 random3(float p, float seed) {
+  return vec3(
+    random(vec3(p, seed, 0)), 
+    random(vec3(p, seed, 1)), 
+    random(vec3(p, seed, 2))
+  );
+}
+
+vec3 random3(float p) {
+  return random3(p, 0.0);
+}
+
+vec3 random3(vec2 p, float seed) {
+  return vec3(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)), random(vec4(p, seed, 2)));
+}
+
+vec3 random3(vec2 p) {
+  return random3(p, 0.0);
+}
+
+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));
+}
+
+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);
+}
+
+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.))
+  ));
+}
+
+
+
+`;

package/dist/shader-modules/modules/ray-marching.d.ts

@@ -0,0 +1 @@
+export declare const rayMarchingDefinition = "\n\nexport {\n  rayMarch,\n  Ray, RayMarchResult\n}\n\nstruct Ray {\n  vec3 origin;\n  vec3 direction;\n};\n\nstruct RayMarchResult {\n  vec3 position;\n  vec3 partialPosition;\n  float minimumDistance;\n  bool hit;\n};\n\nRayMarchResult rayMarch(Ray ray, float minThreshold, float maxThreshold, int partialIterations, float maxIterations, float sdf(vec3)) {\n  vec3 position;\n  float t = 0.0;\n\n  vec3 origin = ray.origin;\n  vec3 direction = ray.direction;\n  \n  vec3 partialPosition;\n  float minimumDistance = 1e20;\n  bool hit = false;\n\n  int n = int(maxIterations) + 1;\n  for (int i = 0; i <= n; i++) {\n    position = origin + direction*t;\n    float d = sdf(position);\n\n    if (i == partialIterations) partialPosition = position;\n\n    t += d*min(1.0, maxIterations - float(i));\n    minimumDistance = min(minimumDistance, d);\n\n    if (abs(d) < minThreshold) {\n      hit = true;\n      break;\n    } \n    \n    if (d > maxThreshold) {\n      break;\n    }\n  }\n  \n  return RayMarchResult(position, partialPosition, minimumDistance, hit);\n}\n\n";

package/dist/shader-modules/modules/ray-marching.js

@@ -0,0 +1,54 @@
+export const rayMarchingDefinition = /*glsl*/ `
+
+export {
+  rayMarch,
+  Ray, RayMarchResult
+}
+
+struct Ray {
+  vec3 origin;
+  vec3 direction;
+};
+
+struct RayMarchResult {
+  vec3 position;
+  vec3 partialPosition;
+  float minimumDistance;
+  bool hit;
+};
+
+RayMarchResult rayMarch(Ray ray, float minThreshold, float maxThreshold, int partialIterations, float maxIterations, float sdf(vec3)) {
+  vec3 position;
+  float t = 0.0;
+
+  vec3 origin = ray.origin;
+  vec3 direction = ray.direction;
+  
+  vec3 partialPosition;
+  float minimumDistance = 1e20;
+  bool hit = false;
+
+  int n = int(maxIterations) + 1;
+  for (int i = 0; i <= n; i++) {
+    position = origin + direction*t;
+    float d = sdf(position);
+
+    if (i == partialIterations) partialPosition = position;
+
+    t += d*min(1.0, maxIterations - float(i));
+    minimumDistance = min(minimumDistance, d);
+
+    if (abs(d) < minThreshold) {
+      hit = true;
+      break;
+    } 
+    
+    if (d > maxThreshold) {
+      break;
+    }
+  }
+  
+  return RayMarchResult(position, partialPosition, minimumDistance, hit);
+}
+
+`;

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

@@ -0,0 +1 @@
+export declare const sdfDefinition = "\n\nimport { barycentric, transformToZAxis, rotate } from \"@/geometry\";\nimport { lerp, signed, dot2 } from \"@/utils\";\nimport { PI } from \"@/constants\";\n\nexport {\n  sphere, box, rectangularCylinder, \n  discoBall, donut, boxFrame,\n  triangleSDFSquared, meshSDF, regularPolygon,\n  polygon, lineSegment\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 regularPolygon(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 polygon(vec2 p, sampler2D vertices, int startIndex, int endIndex, int total) {\n  float nf = float(total);\n  float sf = float(startIndex);\n  float ef = float(endIndex);\n  float minDistSquared = 1e9;\n  float textureStep = 1.0 / nf;\n  float winding = 0.0;   // >0 \u2192 inside for CCW, <0 \u2192 inside for CW\n\n  vec2 start = texture(vertices, vec2((sf + 0.5) * textureStep, 0.5)).xy;\n\n  for (float i = sf + 1.0; i <= ef; i++) {\n    float idx = mod(i + 0.5, nf); \n    vec2 end = texture(vertices, vec2(idx * textureStep, 0.5)).xy;\n\n    // Distance to segment (start to end)\n    vec2 seg = end - start;\n    vec2 rel = p - start;\n    float t = clamp(dot(rel, seg) / dot(seg, seg), 0.0, 1.0);\n    float d2 = dot2(rel - seg*t);\n    minDistSquared = min(minDistSquared, d2);\n\n    // Portion for finding out if point is inside polygon\n    // Equivalent to classic point-in-polygon test:\n    // Does segment cross horizontal ray to the right of p?\n    bool aboveA = start.y > p.y;\n    bool aboveB = end.y > p.y;\n    // Sign: +1 when edge crosses in one direction, -1 in the opposite\n    if (aboveA != aboveB) {\n      float xCross = (end.x - start.x) * (p.y - start.y) / (end.y - start.y) + start.x;\n      if (xCross > p.x) {\n        winding += aboveB ? -1.0 : 1.0;\n      }\n    }\n\n    start = end;\n  }\n\n  float signValue = (winding == 0.0 ? 1.0 : -1.0);\n  return signValue * sqrt(minDistSquared);\n}\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 regularPolygon(rotate(vec2(dot(p, vec3(cos(angle), sin(angle), 0)) - innerRadius, p.z), rotation + 0.25*PI), 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 = normalize(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  bool isInsideXYProjection = abs(normal.z) > 1e-5 && 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, 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\nfloat lineSegment(vec2 p, vec2 a, vec2 b, float o) {\n  vec2 ap = p - a;\n  vec2 ab = b - a;\n  \n  float t = clamp(dot(ap, ab)/dot(ab, ab), 0.0, 1.0);\n\n  return length(ap - ab*t) - o;\n}\n\nfloat lineSegment(vec2 p, vec2 a, vec2 b) {\n  return lineSegment(p, a, b, 0.0);\n}\n\nfloat lineSegment(vec3 p, vec2 a, vec2 b, float o) {\n  vec3 ap = p - a;\n  vec3 ab = b - a;\n  \n  float t = clamp(dot(ap, ab)/dot(ab, ab), 0.0, 1.0);\n\n  return length(ap - ab*t) - o;\n}\n\nfloat lineSegment(vec3 p, vec2 a, vec2 b) {\n  return lineSegment(p, a, b, 0.0);\n}\n\n";