@matboks/utilities 0.0.1 → 0.0.2

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

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

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

@@ -1,77 +1,77 @@
-export const operationsDefinition = /*glsl*/ `
-import { tile } from "@/utils";
-
-export {
-  sdfNormal,
-  combine, intersect, subtract, xor,
-  smoothCombine, smoothIntersect, smoothSubtract, smoothXOR,
-  repeatGrid
-}
-
-const float DEFAULT_SMOOTH = 0.2;
-
-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)
-  );
-}
-
-float combine(float a, float b) {
-  return min(a, b);
-}
-
-float intersect(float a, float b) {
-  return max(a, b);
-}
-
-float subtract(float a, float b) {
-  return max(a, -b);
-}
-
-float xor(float a, float b) {
-  return subtract(combine(a, b), intersect(a, b));
-}
-
-
-float smoothCombine(float d1, float d2, float k) {
-  float h = clamp(0.5 + 0.5*(d2 - d1)/k, 0.0, 1.0);
-  return mix(d2, d1, h) - k*h*(1.0 - h);
-}
-
-float smoothCombine(float d1, float d2) {
-  return smoothCombine(d1, d2, DEFAULT_SMOOTH);
-}
-
-float smoothIntersect(float d1, float d2, float k) {
-  return -smoothCombine(-d1, -d2, k);
-}
-
-float smoothIntersect(float d1, float d2) {
-  return smoothIntersect(d1, d2, DEFAULT_SMOOTH);
-}
-
-float smoothSubtract(float d1, float d2, float k) {
-  return -smoothCombine(-d1, d2, k);
-}
-
-float smoothSubtract(float d1, float d2) {
-  return smoothSubtract(d1, d2, DEFAULT_SMOOTH);
-}
-
-float smoothXOR(float d1, float d2, float k) {
-  return smoothSubtract(smoothCombine(d1, d2, k), smoothIntersect(d1, d2, k), k);
-}
-
-float smoothXOR(float d1, float d2) {
-  return smoothXOR(d1, d2, DEFAULT_SMOOTH);
-}
-
-float repeatGrid(vec3 p, float size, float sdf(vec3)) {
-  return size*sdf(tile(p, size)/size);
-}
-
+export const operationsDefinition = /*glsl*/ `
+import { tile } from "@/utils";
+
+export {
+  sdfNormal,
+  combine, intersect, subtract, xor,
+  smoothCombine, smoothIntersect, smoothSubtract, smoothXOR,
+  repeatGrid
+}
+
+const float DEFAULT_SMOOTH = 0.2;
+
+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)
+  );
+}
+
+float combine(float a, float b) {
+  return min(a, b);
+}
+
+float intersect(float a, float b) {
+  return max(a, b);
+}
+
+float subtract(float a, float b) {
+  return max(a, -b);
+}
+
+float xor(float a, float b) {
+  return subtract(combine(a, b), intersect(a, b));
+}
+
+
+float smoothCombine(float d1, float d2, float k) {
+  float h = clamp(0.5 + 0.5*(d2 - d1)/k, 0.0, 1.0);
+  return mix(d2, d1, h) - k*h*(1.0 - h);
+}
+
+float smoothCombine(float d1, float d2) {
+  return smoothCombine(d1, d2, DEFAULT_SMOOTH);
+}
+
+float smoothIntersect(float d1, float d2, float k) {
+  return -smoothCombine(-d1, -d2, k);
+}
+
+float smoothIntersect(float d1, float d2) {
+  return smoothIntersect(d1, d2, DEFAULT_SMOOTH);
+}
+
+float smoothSubtract(float d1, float d2, float k) {
+  return -smoothCombine(-d1, d2, k);
+}
+
+float smoothSubtract(float d1, float d2) {
+  return smoothSubtract(d1, d2, DEFAULT_SMOOTH);
+}
+
+float smoothXOR(float d1, float d2, float k) {
+  return smoothSubtract(smoothCombine(d1, d2, k), smoothIntersect(d1, d2, k), k);
+}
+
+float smoothXOR(float d1, float d2) {
+  return smoothXOR(d1, d2, DEFAULT_SMOOTH);
+}
+
+float repeatGrid(vec3 p, float size, float sdf(vec3)) {
+  return size*sdf(tile(p, size)/size);
+}
+
 `;

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

@@ -0,0 +1 @@
+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

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