feat(@typegpu/sdf): Add arc, capped cylinder, rhombus, and triangle shapes

Author: iwoplaza

packages/typegpu-sdf/src/2d.ts

@@ -185,3 +185,25 @@ export const sdPie = tgpu.fn(
   const m = distance(p_w, sc * clamp(dot(p_w, sc), 0, radius));
   return max(l, m * sign(sc.y * p_w.x - sc.x * p_w.y));
 });
+
+/**
+ * Signed distance function for a circular arc.
+ * The circle is centered at the origin; the arc is symmetric about the negative Y axis.
+ *
+ * @param position Point to evaluate, relative to the circle's center
+ * @param sc Sine and cosine of the arc's half-angle: `vec2f(sin(angle / 2), cos(angle / 2))`,
+ * where `angle` is the full sweep in radians, from 0 to 2 * PI
+ * @param radius Radius of the arc's centerline (non-negative)
+ * @returns Distance to the core of the arc (non-negative)
+ */
+export const sdArc = tgpu.fn(
+  [vec2f, vec2f, f32],
+  f32,
+)((position, sc, radius) => {
+  'use gpu';
+  const pos = vec2f(abs(position.x), -position.y);
+  if (sc.y * pos.x > sc.x * pos.y) {
+    return length(pos - sc * radius);
+  }
+  return abs(length(pos) - radius);
+});

packages/typegpu-sdf/src/3d.ts

@@ -1,6 +1,19 @@
 import { tgpu } from 'typegpu';
-import { f32, vec3f } from 'typegpu/data';
-import { abs, distance, dot, length, max, min, saturate } from 'typegpu/std';
+import { f32, type v2f, type v3f, vec2f, vec3f } from 'typegpu/data';
+import {
+  abs,
+  clamp,
+  cross,
+  distance,
+  dot,
+  length,
+  max,
+  min,
+  saturate,
+  select,
+  sign,
+  sqrt,
+} from 'typegpu/std';
 
 /**
  * Signed distance function for a sphere
@@ -115,3 +128,110 @@ export const sdCapsule = tgpu.fn(
   const h = saturate(dot(pa, ba) / dot(ba, ba));
   return distance(pa, ba * h) - radius;
 });
+
+/**
+ * Squared length of a vector.
+ * @param a Vector whose squared length to compute
+ */
+const dot2 = (a: v2f | v3f) => {
+  'use gpu';
+  return dot(a, a);
+};
+
+/**
+ * Unsigned distance function for a filled, zero-thickness triangle in 3D space.
+ * The vertices must be distinct and non-collinear, and may use either winding order.
+ *
+ * @param p Point to evaluate, in the same coordinate space as the vertices
+ * @param a First vertex of the triangle
+ * @param b Second vertex of the triangle
+ * @param c Third vertex of the triangle
+ * @returns Distance to the nearest point on the triangle, including its edges;
+ * zero on the triangle and positive on either side of its plane
+ */
+export const sdTriangle3d = (p: v3f, a: v3f, b: v3f, c: v3f) => {
+  'use gpu';
+  const ba = b - a;
+  const pa = p - a;
+  const cb = c - b;
+  const pb = p - b;
+  const ac = a - c;
+  const pc = p - c;
+  const nor = cross(ba, ac);
+
+  const cond =
+    sign(dot(cross(ba, nor), pa)) + sign(dot(cross(cb, nor), pb)) + sign(dot(cross(ac, nor), pc)) <
+    2;
+
+  return sqrt(
+    select(
+      // false
+      (dot(nor, pa) * dot(nor, pa)) / dot2(nor),
+      // true
+      min(
+        min(
+          dot2(ba * saturate(dot(ba, pa) / dot2(ba)) - pa),
+          dot2(cb * saturate(dot(cb, pb) / dot2(cb)) - pb),
+        ),
+        dot2(ac * saturate(dot(ac, pc) / dot2(ac)) - pc),
+      ),
+      cond,
+    ),
+  );
+};
+
+/**
+ * Signed distance function for a solid cylinder centered at the origin, along the Y axis,
+ * with flat caps at `y = -h` and `y = h`.
+ *
+ * @param p Point to evaluate, relative to the cylinder's center
+ * @param r Radius of the circular cross-section in the XZ plane (non-negative)
+ * @param h Half-height of the cylinder; its full height is `2 * h` (non-negative)
+ * @returns Negative inside the cylinder, zero on its surface, positive outside
+ */
+export const sdCappedCylinder = tgpu.fn(
+  [vec3f, f32, f32],
+  f32,
+)((p, r, h) => {
+  'use gpu';
+  const dd = abs(vec2f(length(p.xz), p.y)) - vec2f(r, h);
+  return min(max(dd.x, dd.y), 0.0) + length(max(dd, vec2f()));
+});
+
+/**
+ * Computes `a.x * b.x - a.y * b.y` for the rhombus edge projection.
+ * @param a First vector
+ * @param b Second vector
+ */
+function ndot(a: v2f, b: v2f) {
+  'use gpu';
+  return a.x * b.x - a.y * b.y;
+}
+
+/**
+ * Signed distance function for a rhombus in the XZ plane, extruded along Y and centered
+ * at the origin. Rounding expands the 2D cross-section; the caps at `y = +/-h` stay flat.
+ *
+ * @param p Point to evaluate, relative to the shape's center
+ * @param la Half-length of the unrounded rhombus's diagonal along X (positive)
+ * @param lb Half-length of the unrounded rhombus's diagonal along Z (positive)
+ * @param h Half-height of the extrusion along Y (non-negative)
+ * @param ra Outward rounding radius in the XZ plane (non-negative). Zero gives a sharp
+ * rhombus with vertices at `(x, z) = (+/-la, 0)` and `(0, +/-lb)`; rounding increases
+ * the X and Z half-extents to `la + ra` and `lb + ra`
+ * @returns Negative inside the solid, zero on its surface, positive outside
+ */
+export const sdRhombus = tgpu.fn(
+  [vec3f, f32, f32, f32, f32],
+  f32,
+)((p, la, lb, h, ra) => {
+  'use gpu';
+  const ap = abs(p);
+  const b = vec2f(la, lb);
+  const f = clamp(ndot(b, b - ap.xz * 2) / dot2(b), -1, 1);
+  const q = vec2f(
+    length(ap.xz - b * vec2f(1 - f, 1 + f) * 0.5) * sign(ap.x * b.y + ap.z * b.x - b.x * b.y) - ra,
+    ap.y - h,
+  );
+  return min(max(q.x, q.y), 0.0) + length(max(q, vec2f()));
+});

packages/typegpu-sdf/src/index.ts

@@ -1,13 +1,25 @@
-export { sdBezier, sdBezierApprox, sdBox2d, sdDisk, sdLine, sdPie, sdRoundedBox2d } from './2d.ts';
+export {
+  sdArc,
+  sdBezier,
+  sdBezierApprox,
+  sdBox2d,
+  sdDisk,
+  sdLine,
+  sdPie,
+  sdRoundedBox2d,
+} from './2d.ts';
 
 export {
   sdBox3d,
   sdBoxFrame3d,
+  sdCappedCylinder,
   sdCapsule,
   sdLine3d,
   sdPlane,
+  sdRhombus,
   sdRoundedBox3d,
   sdSphere,
+  sdTriangle3d,
 } from './3d.ts';
 
 export {