@math.gl/culling 4.2.0-alpha.3 → 4.2.0-alpha.5

package/dist/lib/shapes/plane-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plane-shape.js","sourceRoot":"","sources":["../../../src/lib/shapes/plane-shape.ts"],"names":[],"mappings":"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"}

package/dist/lib/shapes/sphere-shape.d.ts

@@ -0,0 +1,18 @@
+import { ImplicitShapeBase, type ImplicitShape, type LocalRayIntersection } from "./implicit-shape.js";
+export type SphereShapeProps = {
+    radius?: number;
+    matrix?: readonly number[];
+};
+/** Analytic glTF sphere shape. */
+export declare class SphereShape extends ImplicitShapeBase {
+    readonly type: "sphere";
+    readonly radius: number;
+    constructor(props?: SphereShapeProps);
+    clone(): SphereShape;
+    equals(shape: ImplicitShape): boolean;
+    containsLocalPoint(point: readonly number[]): boolean;
+    distanceToLocalPoint(point: readonly number[]): number;
+    supportLocal(direction: readonly number[]): readonly number[];
+    intersectLocalRay(origin: readonly number[], direction: readonly number[]): LocalRayIntersection | undefined;
+}
+//# sourceMappingURL=sphere-shape.d.ts.map

package/dist/lib/shapes/sphere-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphere-shape.d.ts","sourceRoot":"","sources":["../../../src/lib/shapes/sphere-shape.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,iBAAiB,EAEjB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAC1B,4BAAyB;AAI1B,MAAM,MAAM,gBAAgB,GAAG;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAC,CAAC;AAE7E,kCAAkC;AAClC,qBAAa,WAAY,SAAQ,iBAAiB;IAChD,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBACZ,KAAK,GAAE,gBAAqB;IAMxC,KAAK,IAAI,WAAW;IAGX,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;IAG9C,kBAAkB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO;IAGrD,oBAAoB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM;IAGtD,YAAY,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE;IAI7D,iBAAiB,CACf,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,oBAAoB,GAAG,SAAS;CAWpC"}

package/dist/lib/shapes/sphere-shape.js

@@ -0,0 +1,43 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { ImplicitShapeBase, solveQuadratic } from "./implicit-shape.js";
+const EPSILON = 1e-6;
+/** Analytic glTF sphere shape. */
+export class SphereShape extends ImplicitShapeBase {
+    constructor(props = {}) {
+        super(props.matrix);
+        this.type = 'sphere';
+        this.radius = props.radius ?? 0.5;
+        if (!Number.isFinite(this.radius) || this.radius <= 0)
+            throw new Error('Sphere radius must be greater than zero');
+    }
+    clone() {
+        return new SphereShape({ radius: this.radius, matrix: this.matrix });
+    }
+    equals(shape) {
+        return shape instanceof SphereShape && super.equals(shape) && this.radius === shape.radius;
+    }
+    containsLocalPoint(point) {
+        return Math.hypot(...point) <= this.radius + EPSILON;
+    }
+    distanceToLocalPoint(point) {
+        return Math.max(0, Math.hypot(...point) - this.radius);
+    }
+    supportLocal(direction) {
+        const length = Math.hypot(...direction);
+        return length ? direction.map(value => (value / length) * this.radius) : [this.radius, 0, 0];
+    }
+    intersectLocalRay(origin, direction) {
+        const roots = solveQuadratic(dot(direction, direction), 2 * dot(origin, direction), dot(origin, origin) - this.radius * this.radius);
+        const distance = roots.find(value => value >= 0);
+        if (distance === undefined)
+            return undefined;
+        const point = origin.map((value, i) => value + distance * direction[i]);
+        return { distance, normal: point.map(value => value / this.radius) };
+    }
+}
+function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+//# sourceMappingURL=sphere-shape.js.map

package/dist/lib/shapes/sphere-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphere-shape.js","sourceRoot":"","sources":["../../../src/lib/shapes/sphere-shape.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,OAAO,EACL,iBAAiB,EACjB,cAAc,EAGf,4BAAyB;AAE1B,MAAM,OAAO,GAAG,IAAI,CAAC;AAIrB,kCAAkC;AAClC,MAAM,OAAO,WAAY,SAAQ,iBAAiB;IAGhD,YAAY,QAA0B,EAAE;QACtC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAHb,SAAI,GAAG,QAAiB,CAAC;QAIhC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,GAAG,CAAC;QAClC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;IAC/D,CAAC;IACD,KAAK;QACH,OAAO,IAAI,WAAW,CAAC,EAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC,CAAC;IACrE,CAAC;IACQ,MAAM,CAAC,KAAoB;QAClC,OAAO,KAAK,YAAY,WAAW,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC;IAC7F,CAAC;IACD,kBAAkB,CAAC,KAAwB;QACzC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;IACvD,CAAC;IACD,oBAAoB,CAAC,KAAwB;QAC3C,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IACzD,CAAC;IACD,YAAY,CAAC,SAA4B;QACvC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC;QACxC,OAAO,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/F,CAAC;IACD,iBAAiB,CACf,MAAyB,EACzB,SAA4B;QAE5B,MAAM,KAAK,GAAG,cAAc,CAC1B,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,EACzB,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1B,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAChD,CAAC;QACF,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC;QACjD,IAAI,QAAQ,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC7C,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,GAAG,QAAQ,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QACxE,OAAO,EAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,EAAC,CAAC;IACrE,CAAC;CACF;AAED,SAAS,GAAG,CAAC,CAAoB,EAAE,CAAoB;IACrD,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC"}

package/package.json

@@ -6,7 +6,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "4.2.0-alpha.3",
+  "version": "4.2.0-alpha.5",
   "keywords": [
     "webgl",
     "javascript",
@@ -42,8 +42,8 @@
     "src"
   ],
   "dependencies": {
-    "@math.gl/core": "4.2.0-alpha.3",
-    "@math.gl/types": "4.2.0-alpha.3"
+    "@math.gl/core": "4.2.0-alpha.5",
+    "@math.gl/types": "4.2.0-alpha.5"
   },
-  "gitHead": "4238aa95fb38da43a65c6e5f2b8343a875666d92"
+  "gitHead": "9c13785761867748e2edb167b5f2749dce803039"
 }

package/src/index.ts

@@ -11,6 +11,18 @@ export {CullingVolume} from './lib/culling-volume';
 export {Plane} from './lib/plane';
 export {Ray} from './lib/ray';
 
+export type {ImplicitShape, RayIntersection} from './lib/shapes/implicit-shape';
+export {BoxShape} from './lib/shapes/box-shape';
+export type {BoxShapeProps} from './lib/shapes/box-shape';
+export {CapsuleShape} from './lib/shapes/capsule-shape';
+export type {CapsuleShapeProps} from './lib/shapes/capsule-shape';
+export {CylinderShape} from './lib/shapes/cylinder-shape';
+export type {CylinderShapeProps} from './lib/shapes/cylinder-shape';
+export {PlaneShape} from './lib/shapes/plane-shape';
+export type {PlaneShapeProps} from './lib/shapes/plane-shape';
+export {SphereShape} from './lib/shapes/sphere-shape';
+export type {SphereShapeProps} from './lib/shapes/sphere-shape';
+
 export {PerspectiveOffCenterFrustum as _PerspectiveOffCenterFrustum} from './lib/perspective-off-center-frustum';
 export {PerspectiveFrustum as _PerspectiveFrustum} from './lib/perspective-frustum';
 

package/src/lib/plane.ts

@@ -93,11 +93,9 @@ export class Plane {
    *
    * @param {Ray} ray The ray.
    * @param {Vector3} [result] The object onto which to store the result.
-   * @returns {Vector3} The intersection point or undefined if there is no intersections.
+   * @returns {Vector3} The intersection point or undefined if there is no intersection.
    */
-  intersectWithRay(ray: Ray, result?: Vector3): Vector3 {
-    if (!result) result = new Vector3();
-
+  intersectWithRay(ray: Ray, result: Vector3 = new Vector3()): Vector3 | undefined {
     const origin = ray.origin;
     const direction = ray.direction;
     const normal = this.normal;
@@ -113,7 +111,6 @@ export class Plane {
       return undefined;
     }
 
-    result = result.copy(direction).multiplyByScalar(t);
-    return origin.add(result);
+    return result.copy(direction).multiplyByScalar(t).add(origin);
   }
 }

package/src/lib/shapes/box-shape.ts

@@ -0,0 +1,78 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ImplicitShapeBase, type ImplicitShape, type LocalRayIntersection} from './implicit-shape';
+
+const EPSILON = 1e-6;
+
+export type BoxShapeProps = {size?: readonly [number, number, number]; matrix?: readonly number[]};
+
+/** Analytic glTF box shape. */
+export class BoxShape extends ImplicitShapeBase {
+  readonly type = 'box' as const;
+  readonly size: readonly [number, number, number];
+  private readonly halfSize: readonly [number, number, number];
+
+  constructor(props: BoxShapeProps = {}) {
+    super(props.matrix);
+    this.size = props.size ? [...props.size] : [1, 1, 1];
+    if (this.size.some(value => !Number.isFinite(value) || value <= 0))
+      throw new Error('Box size values must be greater than zero');
+    this.halfSize = [this.size[0] / 2, this.size[1] / 2, this.size[2] / 2];
+  }
+
+  clone(): BoxShape {
+    return new BoxShape({size: this.size, matrix: this.matrix});
+  }
+  override equals(shape: ImplicitShape): boolean {
+    return (
+      shape instanceof BoxShape &&
+      super.equals(shape) &&
+      this.size.every((value, i) => value === shape.size[i])
+    );
+  }
+  containsLocalPoint(point: readonly number[]): boolean {
+    return point.every((value, i) => Math.abs(value) <= this.halfSize[i] + EPSILON);
+  }
+  distanceToLocalPoint(point: readonly number[]): number {
+    return Math.hypot(...point.map((value, i) => Math.max(0, Math.abs(value) - this.halfSize[i])));
+  }
+  supportLocal(direction: readonly number[]): readonly number[] {
+    return direction.map((value, i) => (value < 0 ? -this.halfSize[i] : this.halfSize[i]));
+  }
+  intersectLocalRay(
+    origin: readonly number[],
+    direction: readonly number[]
+  ): LocalRayIntersection | undefined {
+    let near = -Infinity;
+    let far = Infinity;
+    let nearAxis = 0;
+    let farAxis = 0;
+    for (let axis = 0; axis < 3; axis++) {
+      if (Math.abs(direction[axis]) < 1e-15) {
+        if (Math.abs(origin[axis]) > this.halfSize[axis]) return undefined;
+        continue;
+      }
+      let t1 = (-this.halfSize[axis] - origin[axis]) / direction[axis];
+      let t2 = (this.halfSize[axis] - origin[axis]) / direction[axis];
+      if (t1 > t2) [t1, t2] = [t2, t1];
+      if (t1 > near) {
+        near = t1;
+        nearAxis = axis;
+      }
+      if (t2 < far) {
+        far = t2;
+        farAxis = axis;
+      }
+      if (near > far) return undefined;
+    }
+    const distance = near >= 0 ? near : far;
+    if (distance < 0 || !Number.isFinite(distance)) return undefined;
+    const axis = near >= 0 ? nearAxis : farAxis;
+    const pointCoordinate = origin[axis] + distance * direction[axis];
+    const normal = [0, 0, 0];
+    normal[axis] = pointCoordinate < 0 ? -1 : 1;
+    return {distance, normal};
+  }
+}

package/src/lib/shapes/capsule-shape.ts

@@ -0,0 +1,232 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {
+  closestDistanceToCircleArc2D,
+  closestDistanceToSegment2D,
+  ImplicitShapeBase,
+  solveQuadratic,
+  type ImplicitShape,
+  type LocalRayIntersection
+} from './implicit-shape';
+
+const EPSILON = 1e-6;
+
+export type CapsuleShapeProps = {
+  height?: number;
+  radiusBottom?: number;
+  radiusTop?: number;
+  matrix?: readonly number[];
+};
+
+/** Analytic glTF capsule: the convex hull of two spheres on the Y axis. */
+export class CapsuleShape extends ImplicitShapeBase {
+  readonly type = 'capsule' as const;
+  readonly height: number;
+  readonly radiusBottom: number;
+  readonly radiusTop: number;
+
+  constructor(props: CapsuleShapeProps = {}) {
+    super(props.matrix);
+    this.height = props.height ?? 1;
+    this.radiusBottom = props.radiusBottom ?? 0.5;
+    this.radiusTop = props.radiusTop ?? 0.5;
+    if (!Number.isFinite(this.height) || this.height <= 0)
+      throw new Error('Capsule height must be greater than zero');
+    if (![this.radiusBottom, this.radiusTop].every(value => Number.isFinite(value) && value >= 0))
+      throw new Error('Capsule radii must be non-negative');
+    if (this.radiusBottom === 0 && this.radiusTop === 0)
+      throw new Error('At least one capsule radius must be greater than zero');
+  }
+
+  clone(): CapsuleShape {
+    return new CapsuleShape({
+      height: this.height,
+      radiusBottom: this.radiusBottom,
+      radiusTop: this.radiusTop,
+      matrix: this.matrix
+    });
+  }
+  override equals(shape: ImplicitShape): boolean {
+    return (
+      shape instanceof CapsuleShape &&
+      super.equals(shape) &&
+      this.height === shape.height &&
+      this.radiusBottom === shape.radiusBottom &&
+      this.radiusTop === shape.radiusTop
+    );
+  }
+  containsLocalPoint(point: readonly number[]): boolean {
+    const profile = this.getProfile();
+    const radial = Math.hypot(point[0], point[2]);
+    if (profile.sphere)
+      return (
+        Math.hypot(radial, point[1] - profile.sphere.center) <= profile.sphere.radius + EPSILON
+      );
+    if (point[1] < profile.bottom.y)
+      return Math.hypot(radial, point[1] + this.height / 2) <= this.radiusBottom + EPSILON;
+    if (point[1] > profile.top.y)
+      return Math.hypot(radial, point[1] - this.height / 2) <= this.radiusTop + EPSILON;
+    const t = (point[1] - profile.bottom.y) / (profile.top.y - profile.bottom.y);
+    return (
+      radial <= profile.bottom.radius + (profile.top.radius - profile.bottom.radius) * t + EPSILON
+    );
+  }
+  distanceToLocalPoint(point: readonly number[]): number {
+    if (this.containsLocalPoint(point)) return 0;
+    const profile = this.getProfile();
+    const radial = Math.hypot(point[0], point[2]);
+    if (profile.sphere)
+      return Math.max(
+        0,
+        Math.hypot(radial, point[1] - profile.sphere.center) - profile.sphere.radius
+      );
+    const delta = this.radiusTop - this.radiusBottom;
+    const sideNormalY = -delta / this.height;
+    const bottomArc = closestDistanceToCircleArc2D(
+      radial,
+      point[1],
+      -this.height / 2,
+      this.radiusBottom,
+      -1,
+      sideNormalY
+    );
+    const topArc = closestDistanceToCircleArc2D(
+      radial,
+      point[1],
+      this.height / 2,
+      this.radiusTop,
+      sideNormalY,
+      1
+    );
+    const side = closestDistanceToSegment2D(
+      radial,
+      point[1],
+      profile.bottom.radius,
+      profile.bottom.y,
+      profile.top.radius,
+      profile.top.y
+    );
+    return Math.min(bottomArc, topArc, side);
+  }
+  supportLocal(direction: readonly number[]): readonly number[] {
+    const length = Math.hypot(...direction);
+    const unit = length ? direction.map(value => value / length) : [1, 0, 0];
+    const bottom = [
+      unit[0] * this.radiusBottom,
+      -this.height / 2 + unit[1] * this.radiusBottom,
+      unit[2] * this.radiusBottom
+    ];
+    const top = [
+      unit[0] * this.radiusTop,
+      this.height / 2 + unit[1] * this.radiusTop,
+      unit[2] * this.radiusTop
+    ];
+    return dot(top, direction) >= dot(bottom, direction) ? top : bottom;
+  }
+  intersectLocalRay(
+    origin: readonly number[],
+    direction: readonly number[]
+  ): LocalRayIntersection | undefined {
+    const profile = this.getProfile();
+    if (profile.sphere)
+      return intersectSphere(origin, direction, profile.sphere.center, profile.sphere.radius);
+    const candidates: LocalRayIntersection[] = [];
+    const slope = (profile.top.radius - profile.bottom.radius) / (profile.top.y - profile.bottom.y);
+    const intercept = profile.bottom.radius - slope * profile.bottom.y;
+    const radialAtOrigin = intercept + slope * origin[1];
+    const radialAlongRay = slope * direction[1];
+    for (const distance of solveQuadratic(
+      direction[0] ** 2 + direction[2] ** 2 - radialAlongRay ** 2,
+      2 * (origin[0] * direction[0] + origin[2] * direction[2] - radialAtOrigin * radialAlongRay),
+      origin[0] ** 2 + origin[2] ** 2 - radialAtOrigin ** 2
+    )) {
+      const y = origin[1] + distance * direction[1];
+      if (distance >= 0 && y >= profile.bottom.y - EPSILON && y <= profile.top.y + EPSILON) {
+        const x = origin[0] + distance * direction[0];
+        const z = origin[2] + distance * direction[2];
+        const radial = Math.hypot(x, z) || 1;
+        const normal = [x / radial, -slope, z / radial];
+        const length = Math.hypot(...normal);
+        candidates.push({distance, normal: normal.map(value => value / length)});
+      }
+    }
+    for (const bottomHit of intersectSphereRoots(
+      origin,
+      direction,
+      -this.height / 2,
+      this.radiusBottom
+    )) {
+      const y = origin[1] + bottomHit.distance * direction[1];
+      if (y <= profile.bottom.y + EPSILON) candidates.push(bottomHit);
+    }
+    for (const topHit of intersectSphereRoots(origin, direction, this.height / 2, this.radiusTop)) {
+      const y = origin[1] + topHit.distance * direction[1];
+      if (y >= profile.top.y - EPSILON) candidates.push(topHit);
+    }
+    return candidates.sort((a, b) => a.distance - b.distance)[0];
+  }
+
+  private getProfile(): {
+    sphere?: {center: number; radius: number};
+    bottom: {radius: number; y: number};
+    top: {radius: number; y: number};
+  } {
+    const delta = this.radiusTop - this.radiusBottom;
+    if (Math.abs(delta) >= this.height) {
+      const topWins = this.radiusTop >= this.radiusBottom;
+      return {
+        sphere: {
+          center: topWins ? this.height / 2 : -this.height / 2,
+          radius: topWins ? this.radiusTop : this.radiusBottom
+        },
+        bottom: {radius: 0, y: 0},
+        top: {radius: 0, y: 0}
+      };
+    }
+    const sinSlope = delta / this.height;
+    const radialNormal = Math.sqrt(1 - sinSlope * sinSlope);
+    const normalY = -sinSlope;
+    return {
+      bottom: {
+        radius: this.radiusBottom * radialNormal,
+        y: -this.height / 2 + this.radiusBottom * normalY
+      },
+      top: {radius: this.radiusTop * radialNormal, y: this.height / 2 + this.radiusTop * normalY}
+    };
+  }
+}
+
+function intersectSphere(
+  origin: readonly number[],
+  direction: readonly number[],
+  centerY: number,
+  radius: number
+): LocalRayIntersection | undefined {
+  return intersectSphereRoots(origin, direction, centerY, radius)[0];
+}
+
+function intersectSphereRoots(
+  origin: readonly number[],
+  direction: readonly number[],
+  centerY: number,
+  radius: number
+): LocalRayIntersection[] {
+  if (radius === 0) return [];
+  const relative = [origin[0], origin[1] - centerY, origin[2]];
+  return solveQuadratic(
+    dot(direction, direction),
+    2 * dot(relative, direction),
+    dot(relative, relative) - radius * radius
+  )
+    .filter(distance => distance >= 0)
+    .map(distance => ({
+      distance,
+      normal: relative.map((value, i) => (value + distance * direction[i]) / radius)
+    }));
+}
+
+function dot(a: readonly number[], b: readonly number[]): number {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}

package/src/lib/shapes/cylinder-shape.ts

@@ -0,0 +1,133 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {
+  closestDistanceToSegment2D,
+  ImplicitShapeBase,
+  solveQuadratic,
+  type ImplicitShape,
+  type LocalRayIntersection
+} from './implicit-shape';
+
+const EPSILON = 1e-6;
+
+export type CylinderShapeProps = {
+  height?: number;
+  radiusBottom?: number;
+  radiusTop?: number;
+  matrix?: readonly number[];
+};
+
+/** Analytic closed, Y-aligned glTF cylinder shape, including tapered cylinders. */
+export class CylinderShape extends ImplicitShapeBase {
+  readonly type = 'cylinder' as const;
+  readonly height: number;
+  readonly radiusBottom: number;
+  readonly radiusTop: number;
+
+  constructor(props: CylinderShapeProps = {}) {
+    super(props.matrix);
+    this.height = props.height ?? 2;
+    this.radiusBottom = props.radiusBottom ?? 0.5;
+    this.radiusTop = props.radiusTop ?? 0.5;
+    if (!Number.isFinite(this.height) || this.height <= 0)
+      throw new Error('Cylinder height must be greater than zero');
+    if (![this.radiusBottom, this.radiusTop].every(value => Number.isFinite(value) && value >= 0))
+      throw new Error('Cylinder radii must be non-negative');
+    if (this.radiusBottom === 0 && this.radiusTop === 0)
+      throw new Error('At least one cylinder radius must be greater than zero');
+  }
+
+  clone(): CylinderShape {
+    return new CylinderShape({
+      height: this.height,
+      radiusBottom: this.radiusBottom,
+      radiusTop: this.radiusTop,
+      matrix: this.matrix
+    });
+  }
+  override equals(shape: ImplicitShape): boolean {
+    return (
+      shape instanceof CylinderShape &&
+      super.equals(shape) &&
+      this.height === shape.height &&
+      this.radiusBottom === shape.radiusBottom &&
+      this.radiusTop === shape.radiusTop
+    );
+  }
+  containsLocalPoint(point: readonly number[]): boolean {
+    const half = this.height / 2;
+    if (point[1] < -half - EPSILON || point[1] > half + EPSILON) return false;
+    const t = (point[1] + half) / this.height;
+    const radius = this.radiusBottom + (this.radiusTop - this.radiusBottom) * t;
+    return Math.hypot(point[0], point[2]) <= radius + EPSILON;
+  }
+  distanceToLocalPoint(point: readonly number[]): number {
+    if (this.containsLocalPoint(point)) return 0;
+    const radial = Math.hypot(point[0], point[2]);
+    const half = this.height / 2;
+    const side = closestDistanceToSegment2D(
+      radial,
+      point[1],
+      this.radiusBottom,
+      -half,
+      this.radiusTop,
+      half
+    );
+    const bottom = closestDistanceToSegment2D(radial, point[1], 0, -half, this.radiusBottom, -half);
+    const top = closestDistanceToSegment2D(radial, point[1], 0, half, this.radiusTop, half);
+    return Math.min(side, bottom, top);
+  }
+  supportLocal(direction: readonly number[]): readonly number[] {
+    const radialLength = Math.hypot(direction[0], direction[2]);
+    const x = radialLength ? direction[0] / radialLength : 1;
+    const z = radialLength ? direction[2] / radialLength : 0;
+    const half = this.height / 2;
+    const bottomValue = radialLength * this.radiusBottom - direction[1] * half;
+    const topValue = radialLength * this.radiusTop + direction[1] * half;
+    return topValue >= bottomValue
+      ? [x * this.radiusTop, half, z * this.radiusTop]
+      : [x * this.radiusBottom, -half, z * this.radiusBottom];
+  }
+  intersectLocalRay(
+    origin: readonly number[],
+    direction: readonly number[]
+  ): LocalRayIntersection | undefined {
+    const half = this.height / 2;
+    const slope = (this.radiusTop - this.radiusBottom) / this.height;
+    const intercept = (this.radiusTop + this.radiusBottom) / 2;
+    const radialAtOrigin = intercept + slope * origin[1];
+    const radialAlongRay = slope * direction[1];
+    const candidates: LocalRayIntersection[] = [];
+    const roots = solveQuadratic(
+      direction[0] ** 2 + direction[2] ** 2 - radialAlongRay ** 2,
+      2 * (origin[0] * direction[0] + origin[2] * direction[2] - radialAtOrigin * radialAlongRay),
+      origin[0] ** 2 + origin[2] ** 2 - radialAtOrigin ** 2
+    );
+    for (const distance of roots) {
+      const y = origin[1] + distance * direction[1];
+      if (distance >= 0 && y >= -half - EPSILON && y <= half + EPSILON) {
+        const x = origin[0] + distance * direction[0];
+        const z = origin[2] + distance * direction[2];
+        const radial = Math.hypot(x, z) || 1;
+        const normal = [x / radial, -slope, z / radial];
+        const length = Math.hypot(...normal);
+        candidates.push({distance, normal: normal.map(value => value / length)});
+      }
+    }
+    if (Math.abs(direction[1]) > 1e-15) {
+      for (const [y, radius, normalY] of [
+        [-half, this.radiusBottom, -1],
+        [half, this.radiusTop, 1]
+      ]) {
+        const distance = (y - origin[1]) / direction[1];
+        const x = origin[0] + distance * direction[0];
+        const z = origin[2] + distance * direction[2];
+        if (distance >= 0 && Math.hypot(x, z) <= radius + EPSILON)
+          candidates.push({distance, normal: [0, normalY, 0]});
+      }
+    }
+    return candidates.sort((a, b) => a.distance - b.distance)[0];
+  }
+}