@perplexdotgg/bounce 1.0.0 → 1.0.2

package/src/shape/Ray.ts

@@ -1,81 +0,0 @@
-import { createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
-import { Vec3 } from "../math/vec3";
-import { Aabb } from "./Aabb";
-import { Isometry } from "../math/isometry";
-import { Triangle } from "./Triangle";
-
-const rayProps = {
-  origin: MonomorphType(Vec3),
-  direction: MonomorphType(Vec3),
-  length: NumberType(0.0),
-} as const satisfies PropertyDefinitionMap;
-
-export class Ray extends createClass<Ray, typeof rayProps>(rayProps) {
-  intersectsAabb(aabb: Aabb): boolean {
-    return aabb.intersectsRay(this);
-  }
-
-  transform(isometry: Isometry) {
-    this.origin.transformVectorFromMat4(this.origin, isometry.matrix);
-    isometry.matrix.multiply3x3(this.direction, this.direction);
-    return this;
-  }
-
-  transformRay(ray: Ray, isometry: Isometry) {
-    this.origin.transformVectorFromMat4(ray.origin, isometry.matrix);
-    isometry.matrix.multiply3x3(this.direction, ray.direction);
-    return this;
-  }
-
-  /**
-   * algorithm: https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
-   */
-  intersectsTriangle(outResult: { fraction: number; hit: boolean }, triangle: Triangle) {
-    ray_vector.copy(this.direction);
-
-    edge1.subtractVectors(triangle.b, triangle.a);
-    edge2.subtractVectors(triangle.c, triangle.a);
-    ray_cross_e2.crossVectors(ray_vector, edge2);
-    const det = edge1.dot(ray_cross_e2);
-
-    if (det > -epsilon && det < epsilon) {
-      outResult.hit = false; // parallel
-      return;
-    }
-
-    const inv_det = 1.0 / det;
-    s.subtractVectors(this.origin, triangle.a);
-    const u = inv_det * s.dot(ray_cross_e2);
-
-    if (u < -epsilon || u > 1 + epsilon) {
-      outResult.hit = false;
-      return;
-    }
-
-    s_cross_e1.crossVectors(s, edge1);
-    const v = inv_det * ray_vector.dot(s_cross_e1);
-
-    if (v < -epsilon || u + v > 1 + epsilon) {
-      outResult.hit = false;
-      return;
-    }
-
-    const t = inv_det * edge2.dot(s_cross_e1);
-
-    if (t > epsilon && t <= this.length + epsilon) {
-      outResult.fraction = t / this.length;
-      outResult.hit = true;
-    } else {
-      // line hit but outside the ray segment
-      outResult.hit = false;
-    }
-  }
-}
-
-const epsilon = 1e-6;
-const edge1 = /*@__PURE__*/ Vec3.create();
-const edge2 = /*@__PURE__*/ Vec3.create();
-const ray_cross_e2 = /*@__PURE__*/ Vec3.create();
-const s = /*@__PURE__*/ Vec3.create();
-const s_cross_e1 = /*@__PURE__*/ Vec3.create();
-const ray_vector = /*@__PURE__*/ Vec3.create();

package/src/shape/Segment.ts

@@ -1,25 +0,0 @@
-import { createClass, MonomorphType, PropertyDefinitionMap } from "monomorph";
-import { Vec3 } from "../math/vec3";
-import { Ray } from "./Ray";
-
-const segmentProps = {
-  pointA: MonomorphType(Vec3),
-  pointB: MonomorphType(Vec3),
-} as const satisfies PropertyDefinitionMap;
-
-export class Segment extends createClass<Segment, typeof segmentProps>(segmentProps) {
-  computeCenter(out: Vec3) {
-    out.addVectors(this.pointA, this.pointB);
-    out.scaleVector(out, 0.5);
-  }
-
-  computeHalfExtents(out: Vec3) {
-    out.subtractVectors(this.pointB, this.pointA);
-    out.scaleVector(out, 0.5);
-  }
-
-  setFromRay(ray: Ray) {
-    this.pointA.copy(ray.origin);
-    this.pointB.addScaledToVector(ray.origin, ray.direction, ray.length);
-  }
-}

package/src/shape/Shape.ts

@@ -1,77 +0,0 @@
-import { Aabb } from "./Aabb";
-import { Face } from "../physics/manifold/Face";
-import { Mat3 } from "../math/mat3";
-import { Mat4 } from "../math/mat4";
-import { Quat } from "../math/quat";
-import { Vec3 } from "../math/vec3";
-import { Sphere } from "./Sphere";
-import { Box } from "./Box";
-import { SupportMode, SupportShapeWithConvexRadius } from "./Convex";
-import { CompoundShape } from "./CompoundShape";
-import { HeightMap } from "./HeightMap";
-import ConvexHull from "./ConvexHull";
-import { Cylinder } from "./Cylinder";
-import { TriangleMesh } from "./TriangleMesh";
-import { Capsule } from "./Capsule";
-import { WithPool } from "monomorph";
-
-export const enum ShapeType {
-  box,
-  capsule,
-  compoundShape,
-  convexHull,
-  cylinder,
-  heightMap,
-  sphere,
-  triangleMesh,
-}
-
-export type ConvexShape = Box | Capsule | ConvexHull | Cylinder | Sphere;
-export type ShapeCollection = CompoundShape | HeightMap | TriangleMesh;
-export type Shape = ConvexShape | ShapeCollection;
-export type StaticShape = Shape;
-export type DynamicShape = Exclude<Shape, HeightMap>;
-export type KinematicShape = Exclude<Shape, HeightMap>;
-
-export type ConvexShapeInterface = {
-  type: ShapeType.box | ShapeType.capsule | ShapeType.convexHull | ShapeType.cylinder | ShapeType.sphere;
-
-  // for transform-dependent shape properties
-  computeSupportShape(mode: SupportMode, scale: number): SupportShapeWithConvexRadius;
-  computeSupportingFace(
-    out: Face,
-    subShapeID: number,
-    direction: Vec3,
-    scale: number,
-    centerOfMassTransform: Mat4
-  ): void;
-  computeInverseInertiaTensor(out: Mat3, mass: number): void;
-  computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat): void;
-  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void;
-
-  // for "diffing"
-  copyForDiff: WithPool<ConvexShape> | ConvexShape | null;
-  commitChanges(): void;
-  hasChanged(): boolean;
-};
-
-export type ShapeCollectionInterface = {
-  type: ShapeType.compoundShape | ShapeType.heightMap | ShapeType.triangleMesh;
-
-  // for transform-dependent shape properties
-  computeSupportingFace(
-    out: Face,
-    subShapeID: number,
-    direction: Vec3,
-    scale: number,
-    centerOfMassTransform: Mat4
-  ): void;
-  computeInverseInertiaTensor(out: Mat3, mass: number): void;
-  computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat): void;
-  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void;
-
-  // for "diffing"
-  copyForDiff: ShapeCollection | null;
-  commitChanges(): void;
-  hasChanged(): boolean;
-};

package/src/shape/Sphere.ts

@@ -1,181 +0,0 @@
-import {
-  createClass,
-  LazyReferenceType,
-  MonomorphType,
-  NumberType,
-  PropertyDefinitionMap,
-  PropertyDefinitionReference,
-} from "monomorph";
-import { Vec3 } from "../math/vec3";
-import { Quat } from "../math/quat";
-import { Face } from "../physics/manifold/Face";
-import { Mat4 } from "../math/mat4";
-import { Mat3 } from "../math/mat3";
-import { Aabb } from "./Aabb";
-import { SupportMode, SupportShapeWithConvexRadius } from "./Convex";
-import { ConvexShapeInterface, ShapeType } from "./Shape";
-import type { World } from "../world";
-
-const sphereNoConvexProps = {
-  radius: NumberType(0.0),
-} as const satisfies PropertyDefinitionMap;
-
-export class SphereNoConvex
-  extends createClass<SphereNoConvex, typeof sphereNoConvexProps>(sphereNoConvexProps)
-  implements SupportShapeWithConvexRadius
-{
-  getConvexRadius(): number {
-    return this.radius;
-  }
-
-  computeSupport(out: Vec3, direction: Vec3): void {
-    out.zero();
-  }
-}
-
-const sphereWithConvexProps = {
-  radius: NumberType(0.0),
-} as const satisfies PropertyDefinitionMap;
-
-export class SphereWithConvex
-  extends createClass<SphereWithConvex, typeof sphereWithConvexProps>(sphereWithConvexProps)
-  implements SupportShapeWithConvexRadius
-{
-  getConvexRadius(): number {
-    return 0;
-  }
-
-  computeSupport(out: Vec3, direction: Vec3): void {
-    const directionLength = direction.length();
-    if (directionLength > 0) {
-      out.scaleVector(direction, this.radius / directionLength);
-    } else {
-      out.zero();
-    }
-  }
-}
-
-const sphereProps = {
-  computedCenterOfMass: MonomorphType(Vec3, undefined, true),
-  computedVolume: NumberType(0.0, true),
-  computedAabb: MonomorphType(Aabb, undefined, true),
-  radius: NumberType(1.0),
-  copyForDiff: LazyReferenceType((() => Sphere) as () => never) as PropertyDefinitionReference<Sphere | null, true>,
-  sphereNoConvex: MonomorphType(SphereNoConvex, undefined, true),
-  sphereWithConvex: MonomorphType(SphereWithConvex, undefined, true),
-} as const satisfies PropertyDefinitionMap;
-
-const afterConstructorCode = `
-  this.world = null;
-`;
-
-export class Sphere
-  extends createClass<Sphere, typeof sphereProps>(sphereProps, { afterConstructorCode })
-  implements ConvexShapeInterface
-{
-  type: ShapeType.sphere = ShapeType.sphere;
-
-  declare world: World | null;
-
-  computeSupportShape(mode: SupportMode, scale: number): SupportShapeWithConvexRadius {
-    const scaled_radius = this.radius * scale;
-
-    switch (mode) {
-      case SupportMode.IncludeConvexRadius: {
-        this.sphereWithConvex.radius = scaled_radius;
-        return this.sphereWithConvex;
-      }
-
-      case SupportMode.ExcludeConvexRadius: {
-        this.sphereNoConvex.radius = scaled_radius;
-        return this.sphereNoConvex;
-      }
-
-      default: {
-        throw new Error(`Invalid support mode ${mode}`);
-      }
-    }
-  }
-
-  computeSupportingFace(
-    out: Face,
-    subShapeID: number,
-    direction: Vec3,
-    scale: number,
-    centerOfMassTransform: Mat4
-  ): void {
-    // no faces for a sphere
-    out.clear();
-  }
-
-  computeInertiaTensor(out: Mat3, mass: number) {
-    // assumptions:
-    // 1. sphere's center-of-mass is at origin
-    // 2. sphere is not transformed
-    // 3. sphere has uniform density = 1
-    const inertia = (2 / 5) * mass * this.radius * this.radius;
-    out.fromArray([inertia, 0, 0, 0, inertia, 0, 0, 0, inertia]);
-  }
-
-  computeInverseInertiaTensor(out: Mat3, mass: number) {
-    this.computeInertiaTensor(out, mass);
-    out.invert();
-  }
-
-  computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat): void {
-    // TODO: apply rotation if shape's center of mass is not at the origin?
-    out.translateAabb(this.computedAabb, translation);
-  }
-
-  hasChanged() {
-    return this.copyForDiff !== null && this.radius !== this.copyForDiff.radius;
-  }
-
-  commitChanges() {
-    if (this.hasChanged()) {
-      updateShape(this);
-      // this.world?.updateBodyProperties();
-    }
-  }
-
-  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void {
-    // get the vector pointing from the center to the surface point
-    out.subtractVectors(inLocalSurfacePosition, this.computedCenterOfMass);
-    out.normalize();
-  }
-}
-
-const oldCreate = Sphere.create;
-Sphere.create = function () {
-  const shape = oldCreate.apply(this, arguments as any);
-  updateShape(shape);
-  return shape;
-};
-
-function updateVolume(shape: Sphere) {
-  shape.computedVolume = (4 / 3) * Math.PI * shape.radius * shape.radius * shape.radius;
-}
-
-function updateLocalBounds(shape: Sphere) {
-  // TODO: apply rotation if shape's center of mass is not at the origin?
-  shape.computedAabb.min.addScalarToVector(shape.computedCenterOfMass, -shape.radius);
-  shape.computedAabb.max.addScalarToVector(shape.computedCenterOfMass, +shape.radius);
-}
-
-function updateCopyForDiff(shape: Sphere) {
-  if (shape.copyForDiff) {
-    shape.copyForDiff.copy(shape);
-    shape.copyForDiff.copyForDiff = null;
-  }
-}
-
-function updateCenterOfMass(shape: Sphere) {
-  shape.computedCenterOfMass.zero();
-}
-
-function updateShape(shape: Sphere) {
-  updateCopyForDiff(shape);
-  updateCenterOfMass(shape);
-  updateVolume(shape);
-  updateLocalBounds(shape);
-}

package/src/shape/TransformedShape.ts

@@ -1,51 +0,0 @@
-import {
-  createClass,
-  MonomorphType,
-  NumberType,
-  PropertyDefinition,
-  PropertyDefinitionMap,
-  ReferenceType,
-} from "monomorph";
-import { Shape, ShapeType } from "./Shape";
-import { Sphere } from "./Sphere";
-import { Box } from "./Box";
-import { BasicTransform } from "../math/BasicTransform";
-import ConvexHull from "./ConvexHull";
-import { Cylinder } from "./Cylinder";
-import { Capsule } from "./Capsule";
-
-const transformedShapeProps = {
-  shapeType: NumberType(ShapeType.box) as PropertyDefinition<ShapeType, true>,
-  // we need to do "as 'shape' ..." otherwise they are just 'string' and not the actual specific keys
-  ['shape' + ShapeType.box as 'shape0']: ReferenceType(Box, undefined, true),
-  ['shape' + ShapeType.capsule as 'shape1']: ReferenceType(Capsule, undefined, true),
-  // compoundShape not supported
-  ['shape' + ShapeType.convexHull as 'shape3']: ReferenceType(ConvexHull, undefined, true),
-  ['shape' + ShapeType.cylinder as 'shape4']: ReferenceType(Cylinder, undefined, true),
-  // heightMap not supported
-  ['shape' + ShapeType.sphere as 'shape6']: ReferenceType(Sphere, undefined, true),
-  // triangleMesh not supported
-  transform: MonomorphType(BasicTransform),
-} as const satisfies PropertyDefinitionMap;
-
-const afterConstructorCode = `
-  this.world = null;
-`;
-
-export class TransformedShape extends createClass<TransformedShape, typeof transformedShapeProps>(
-  transformedShapeProps,
-  { afterConstructorCode }
-) {
-  get shape(): Shape | null {
-    return this['shape' + this.shapeType as keyof typeof this] as Shape | null;
-  }
-
-  set shape(value: Shape) {
-    (this['shape' + this.shapeType as keyof typeof this] as (Shape | null)) = null;
-    (this['shape' + value.type as keyof typeof this] as (Shape | null)) = value;
-    this.shapeType = value.type;
-    // this.computeMassProperties();
-    // computeCenterOfMassPosition(this.computedCenterOfMassPosition, this);
-    // this.computeWorldBounds(this.computedBounds);
-  }
-}

package/src/shape/Triangle.ts

@@ -1,122 +0,0 @@
-import { createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
-import { Vec3 } from "../math/vec3";
-import { Mat4 } from "../math/mat4";
-import { Aabb } from "./Aabb";
-import { SupportMode, SupportShapeWithConvexRadius } from "./Convex";
-import { Face } from "../physics/manifold/Face";
-import { Ray } from "./Ray";
-
-const triangleProps = {
-  computedBounds: MonomorphType(Aabb, undefined, true),
-  normal: MonomorphType(Vec3, undefined, true),
-  a: MonomorphType(Vec3),
-  b: MonomorphType(Vec3),
-  c: MonomorphType(Vec3),
-  subShapeId: NumberType(0, true),
-  activeEdges: NumberType(0, true),
-  // aabb: { struct: Aabb, readOnly: true },
-  // activeEdges: { struct: Uint32, optional: true },
-  // translation: { struct: Vec3, optional: true },
-} as const satisfies PropertyDefinitionMap;
-
-const ab = /*@__PURE__*/ Vec3.create();
-const ac = /*@__PURE__*/ Vec3.create();
-
-export class Triangle extends createClass<Triangle, typeof triangleProps>(triangleProps) {
-  // type: ShapeType.triangle = ShapeType.triangle;
-
-  computeNormal(out: Vec3): void {
-    ab.subtractVectors(this.b, this.a);
-    ac.subtractVectors(this.c, this.a);
-    out.crossVectors(ab, ac);
-    out.normalize();
-  }
-
-  computeCentroid(out: Vec3): void {
-    out
-      .addVectors(this.a, this.b)
-      .addVector(this.c)
-      .scale(1 / 3);
-  }
-
-  computeUnnormalizedNormal(out: Vec3): void {
-    ab.subtractVectors(this.b, this.a);
-    ac.subtractVectors(this.c, this.a);
-    out.crossVectors(ab, ac);
-  }
-
-  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void {
-    // TODO: take into account surface position for backfaces?
-    this.computeNormal(out);
-  }
-
-  transform(isometry: Mat4) {
-    this.a.transformByMat4(isometry);
-    this.b.transformByMat4(isometry);
-    this.c.transformByMat4(isometry);
-  }
-
-  computeLocalBounds(out: Aabb) {
-    out.min.x = Math.min(this.a.x, this.b.x, this.c.x);
-    out.min.y = Math.min(this.a.y, this.b.y, this.c.y);
-    out.min.z = Math.min(this.a.z, this.b.z, this.c.z);
-
-    out.max.x = Math.max(this.a.x, this.b.x, this.c.x);
-    out.max.y = Math.max(this.a.y, this.b.y, this.c.y);
-    out.max.z = Math.max(this.a.z, this.b.z, this.c.z);
-
-    out.computeCentroid(out.centroid);
-  }
-
-  computeSupport(out: Vec3, direction: Vec3): void {
-    const dotA = this.a.dot(direction);
-    const dotB = this.b.dot(direction);
-    const dotC = this.c.dot(direction);
-
-    if (dotA > dotB) {
-      if (dotA > dotC) {
-        out.copy(this.a);
-      } else {
-        out.copy(this.c);
-      }
-    } else {
-      if (dotB > dotC) {
-        out.copy(this.b);
-      } else {
-        out.copy(this.c);
-      }
-    }
-  }
-
-  getConvexRadius(): number {
-    return 0;
-  }
-
-  computeSupportShape(mode: SupportMode, scale: number): SupportShapeWithConvexRadius {
-    // TODO: account for mode and scale not being supported like the other shapes
-    // 1. either adjust the method signature to make mode and scale optional
-    // 2. or add support for mode and scale
-    return this;
-  }
-
-  toObject() {
-    return {
-      a: this.a.toObject(),
-      b: this.b.toObject(),
-      c: this.c.toObject(),
-      normal: this.normal.toObject(),
-    };
-  }
-
-  computeSupportingFace(out: Face, subShapeID: number, direction: Vec3, scale: number, centerOfMassTransform: Mat4) {
-    // TODO: prescale transform
-
-    // TODO: flip triangle if scaled inside out
-
-    out.clear();
-    out.pushVertex(this.a);
-    out.pushVertex(this.b);
-    out.pushVertex(this.c);
-    out.transform(centerOfMassTransform);
-  }
-}