@perplexdotgg/bounce 1.0.0 → 1.0.1

package/src/shape/Capsule.ts

@@ -1,332 +0,0 @@
-import {
-  createClass,
-  LazyReferenceType,
-  MonomorphType,
-  NumberType,
-  PropertyDefinitionMap,
-  PropertyDefinitionReference,
-} from "monomorph";
-import { Vec3 } from "../math/vec3";
-import { Face } from "../physics/manifold/Face";
-import { Mat4 } from "../math/mat4";
-import { Quat } from "../math/quat";
-import { ConvexShapeInterface, ShapeType } from "./Shape";
-import type { World } from "../world";
-import { Isometry } from "../math/isometry";
-import { Mat3 } from "../math/mat3";
-import { CollisionResult } from "../collision/collide/collide";
-import { Aabb } from "./Aabb";
-import { SupportMode, SupportShapeWithConvexRadius } from "./Convex";
-import { Triangle } from "../collision/epa/structs";
-
-/// Used by (Tapered)CapsuleShape to determine when supporting face is an edge rather than a point (unit: meter)
-export const capsuleProjectionSlop = 0.02;
-
-const scaledHalfHeightOfCylinder = /*@__PURE__*/ Vec3.create();
-const tempVector = /*@__PURE__*/ Vec3.create();
-const yAxis = /*@__PURE__*/ Vec3.create();
-const extent = /*@__PURE__*/ Vec3.create();
-const radiusVector = /*@__PURE__*/ Vec3.create();
-const halfHeightOfCylinder = /*@__PURE__*/ Vec3.create();
-const isometry = /*@__PURE__*/ Isometry.create();
-const horizontalDirection = /*@__PURE__*/ Vec3.create();
-const support = /*@__PURE__*/ Vec3.create();
-const supportTop = /*@__PURE__*/ Vec3.create();
-const negatedScaledHalfHeightOfCylinder = /*@__PURE__*/ Vec3.create();
-const supportBottom = /*@__PURE__*/ Vec3.create();
-
-const capsuleNoConvexProps = {
-  halfHeightOfCylinder: MonomorphType(Vec3),
-  convexRadius: NumberType(0),
-} as const satisfies PropertyDefinitionMap;
-
-export class CapsuleNoConvex extends createClass<CapsuleNoConvex, typeof capsuleNoConvexProps>(capsuleNoConvexProps) {
-  computeSupport(out: Vec3, direction: Vec3): void {
-    if (direction.y > 0) {
-      out.copy(this.halfHeightOfCylinder);
-    } else {
-      out.negateVector(this.halfHeightOfCylinder);
-    }
-  }
-
-  getConvexRadius(): number {
-    return this.convexRadius;
-  }
-
-  computeSupportingFace(out: Face, subShapeID: number, direction: Vec3, scale: number, centerOfMassTransform: Mat4) {
-    throw new Error("Method not implemented.");
-  }
-}
-
-const capsuleWithConvexProps = {
-  halfHeightOfCylinder: MonomorphType(Vec3),
-  radius: NumberType(0),
-} as const satisfies PropertyDefinitionMap;
-
-export class CapsuleWithConvex extends createClass<CapsuleWithConvex, typeof capsuleWithConvexProps>(
-  capsuleWithConvexProps
-) {
-  computeSupport(out: Vec3, direction: Vec3): void {
-    const len = direction.length();
-
-    if (len > 0) {
-      // vec3.scaleAndAdd(out, direction, direction, this.radius / len);
-      out.scaleVector(direction, this.radius / len);
-    } else {
-      out.zero();
-    }
-
-    if (direction.y > 0) {
-      out.addVector(this.halfHeightOfCylinder);
-    } else {
-      out.subtractVector(this.halfHeightOfCylinder);
-    }
-  }
-
-  getConvexRadius(): number {
-    return 0;
-  }
-
-  computeSupportingFace(
-    out: Face,
-    subShapeID: number,
-    direction: Vec3,
-    scale: number,
-    centerOfMassTransform: Mat4
-  ): void {
-    throw new Error("Method not implemented.");
-  }
-}
-
-const capsuleProps = {
-  computedCenterOfMass: MonomorphType(Vec3, undefined, true),
-  computedVolume: NumberType(0.0, true),
-  computedAabb: MonomorphType(Aabb, undefined, true),
-  radius: NumberType(0),
-  height: NumberType(0),
-  copyForDiff: LazyReferenceType((() => Capsule) as () => never) as PropertyDefinitionReference<Capsule | null, true>,
-  capsuleNoConvex: MonomorphType(CapsuleNoConvex, undefined, true),
-  capsuleWithConvex: MonomorphType(CapsuleWithConvex, undefined, true),
-} as const satisfies PropertyDefinitionMap;
-
-const afterConstructorCode = `
-  this.world = null;
-`;
-
-export class Capsule
-  extends createClass<Capsule, typeof capsuleProps>(capsuleProps, { afterConstructorCode })
-  implements ConvexShapeInterface
-{
-  type: ShapeType.capsule = ShapeType.capsule;
-
-  declare world: World | null;
-
-  intersectsAabb(aabb: Aabb): boolean {
-    throw new Error("Method not implemented.");
-  }
-
-  computeSupport(out: Vec3, direction: Vec3): void {
-    throw new Error("Method not implemented.");
-  }
-
-  getHalfHeightOfCylinder(): number {
-    return this.height / 2;
-  }
-
-  computeSupportShape(mode: SupportMode, scale: number): SupportShapeWithConvexRadius {
-    // get scaled capsule
-    const absScale = Math.abs(scale);
-
-    scaledHalfHeightOfCylinder.set({ x: 0, y: scale * this.getHalfHeightOfCylinder(), z: 0 });
-    const scaledRadius = scale * this.radius;
-
-    switch (mode) {
-      case SupportMode.IncludeConvexRadius: {
-        this.capsuleWithConvex.halfHeightOfCylinder.copy(scaledHalfHeightOfCylinder);
-        this.capsuleWithConvex.radius = scaledRadius;
-        return this.capsuleWithConvex;
-      }
-
-      case SupportMode.ExcludeConvexRadius: {
-        this.capsuleNoConvex.halfHeightOfCylinder.copy(scaledHalfHeightOfCylinder);
-        this.capsuleNoConvex.convexRadius = scaledRadius;
-        return this.capsuleNoConvex;
-      }
-
-      default: {
-        throw new Error(`Invalid support mode: ${mode}`);
-      }
-    }
-  }
-
-  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void {
-    yAxis.set({ x: 0, y: 1, z: 0 });
-
-    if (inLocalSurfacePosition.y > this.getHalfHeightOfCylinder()) {
-      tempVector.set({ x: 0, y: this.getHalfHeightOfCylinder(), z: 0 });
-      out.subtractVectors(inLocalSurfacePosition, tempVector);
-      out.normalize();
-      return;
-    } else if (inLocalSurfacePosition.y < -this.getHalfHeightOfCylinder()) {
-      tempVector.set({ x: 0, y: -this.getHalfHeightOfCylinder(), z: 0 });
-      out.subtractVectors(inLocalSurfacePosition, tempVector);
-      out.normalize();
-      return;
-    } else {
-      out.set({ x: inLocalSurfacePosition.x, y: 0, z: inLocalSurfacePosition.z });
-      out.normalizedOr(out, yAxis);
-      return;
-    }
-  }
-
-  computeInertiaTensor(out: Mat3, mass: number): void {
-    // assumptions:
-    // 1. capsule's center-of-mass is at origin
-    // 2. capsule is not transformed
-    // 3. capsule has uniform density = 1
-    // 4. capsule is aligned with the y-axis
-    // derivation: chapter 14 of Game Engine Gems Volume I: http://www.gameenginegems.net/geg1.php
-    const { radius, height } = this;
-
-    const heightSquared = height * height;
-    const radiusSquared = radius * radius;
-
-    // common terms
-    const commonMultiplier = mass / (4 * radius + 3 * height);
-    const commonMassTerm1 = 2 * radius * commonMultiplier;
-    const commonMassTerm2 = 3 * height * commonMultiplier;
-    const commonRadiusTerm = (4 / 5) * radiusSquared;
-
-    // axis-aligned terms
-    const xxTerm1 = (3 / 4) * radius * height + (1 / 2) * heightSquared;
-    const xxTerm2 = (1 / 4) * radiusSquared + (1 / 12) * heightSquared;
-    const yyTerm = (1 / 2) * radiusSquared;
-
-    // axis-aligned inertias
-    const xxInertia = commonMassTerm1 * (commonRadiusTerm + xxTerm1) + commonMassTerm2 * xxTerm2;
-    const yyInertia = commonMassTerm1 * commonRadiusTerm + commonMassTerm2 * yyTerm;
-    const zzInertia = xxInertia;
-
-    // set inertia tensor
-    out.fromArray([xxInertia, 0, 0, 0, yyInertia, 0, 0, 0, zzInertia]);
-  }
-
-  computeInverseInertiaTensor(out: Mat3, mass: number): void {
-    this.computeInertiaTensor(out, mass);
-    out.invert();
-  }
-
-  computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat) {
-    // TODO: apply rotation if shape's center of mass is not at the origin?
-    isometry.fromRotationAndTranslation(rotation, translation);
-    out.transformAabb(this.computedAabb, isometry);
-  }
-
-  collideTriangle(result: CollisionResult, triangle: Triangle, isometry: Isometry) {
-    throw new Error("Method not implemented.");
-  }
-
-  computeSupportingFace(out: Face, subShapeID: number, direction: Vec3, scale: number, centerOfMassTransform: Mat4) {
-    out.clear();
-
-    // Get direction in horizontal plane
-
-    horizontalDirection.copy(direction);
-    horizontalDirection.y = 0;
-
-    // check zero vector, in this case we're hitting from top/bottom so there's no supporting face
-    const horizontalDirectionLength = horizontalDirection.length();
-    if (horizontalDirectionLength === 0) {
-      return;
-    }
-
-    // get scaled capsule
-    scale = Math.abs(scale);
-
-    scaledHalfHeightOfCylinder.set({ x: 0, y: scale * this.getHalfHeightOfCylinder(), z: 0 });
-    const scaledRadius = scale * this.radius;
-
-    // Get support point for top and bottom sphere in the opposite of 'direction' (including convex radius)
-
-    support.scaleVector(horizontalDirection, scaledRadius / horizontalDirectionLength);
-    supportTop.subtractVectors(scaledHalfHeightOfCylinder, support);
-    negatedScaledHalfHeightOfCylinder.negateVector(scaledHalfHeightOfCylinder);
-    supportBottom.subtractVectors(negatedScaledHalfHeightOfCylinder, support);
-
-    // get projection on inDirection
-    // Note that inDirection is not normalized, so we need to divide by inDirection.Length() to get the actual projection
-    // We've multiplied both sides of the if below with inDirection.Length()
-    const projTop = supportTop.dot(direction);
-    const projBottom = supportBottom.dot(direction);
-
-    // If projection is roughly equal then return line, otherwise we return nothing as there's only 1 point
-    if (Math.abs(projTop - projBottom) < capsuleProjectionSlop * direction.length()) {
-      supportTop.transformVectorFromMat4(supportTop, centerOfMassTransform);
-      out.pushVertex(supportTop);
-
-      supportBottom.transformVectorFromMat4(supportBottom, centerOfMassTransform);
-      out.pushVertex(supportBottom);
-      // out.log("hitting side capsule face");
-    } else {
-      // out.log("hitting non-side capsule face");
-    }
-
-    // console.log("capsule supporting face with vertex count", out.vertexCount);
-  }
-
-  get isConvex(): boolean {
-    return true;
-  }
-
-  hasChanged() {
-    return (
-      this.copyForDiff !== null && (this.radius !== this.copyForDiff.radius || this.height !== this.copyForDiff.height)
-    );
-  }
-
-  commitChanges() {
-    if (this.hasChanged()) {
-      updateShape(this);
-      // this.world?.updateBodyProperties();
-    }
-  }
-}
-
-const oldCreate = Capsule.create;
-Capsule.create = function () {
-  const shape = oldCreate.apply(this, arguments as any);
-  updateShape(shape);
-  return shape;
-};
-
-function updateCopyForDiff(shape: Capsule) {
-  if (shape.copyForDiff) {
-    shape.copyForDiff.copy(shape);
-    shape.copyForDiff.copyForDiff = null;
-  }
-}
-
-function updateCenterOfMass(shape: Capsule) {
-  shape.computedCenterOfMass.zero();
-}
-
-function updateVolume(shape: Capsule) {
-  shape.computedVolume =
-    (4 / 3) * Math.PI * shape.radius * shape.radius * shape.radius +
-    Math.PI * shape.radius * shape.radius * shape.height;
-}
-
-function updateLocalBounds(shape: Capsule) {
-  radiusVector.replicate(shape.radius);
-  halfHeightOfCylinder.set({ x: 0, y: shape.getHalfHeightOfCylinder(), z: 0 });
-  extent.addVectors(radiusVector, halfHeightOfCylinder);
-  shape.computedAabb.min.negateVector(extent);
-  shape.computedAabb.max.copy(extent);
-}
-
-function updateShape(shape: Capsule) {
-  updateCopyForDiff(shape);
-  updateCenterOfMass(shape);
-  updateVolume(shape);
-  updateLocalBounds(shape);
-}

package/src/shape/CompoundShape.ts

@@ -1,288 +0,0 @@
-import {
-  createClass,
-  LazyReferenceType,
-  MonomorphType,
-  NumberType,
-  PropertyDefinitionMap,
-  PropertyDefinitionReference,
-  ReferenceListType,
-} from "monomorph";
-import { ConvexShape, ConvexShapeInterface, Shape, ShapeCollectionInterface, ShapeType } from "./Shape";
-import type { World } from "../world";
-import { Aabb } from "./Aabb";
-import { BasicTransform } from "../math/BasicTransform";
-import { Vec3 } from "../math/vec3";
-import { Sphere } from "./Sphere";
-import { Box } from "./Box";
-import { Mat4 } from "../math/mat4";
-import { Face } from "../physics/manifold/Face";
-import { Mat3 } from "../math/mat3";
-import { Isometry } from "../math/isometry";
-import { Quat } from "../math/quat";
-import { TransformedShape } from "./TransformedShape";
-import ConvexHull from "./ConvexHull";
-import { Cylinder } from "./Cylinder";
-import { Capsule } from "./Capsule";
-
-const cumulativeInertia = /*@__PURE__*/ Mat3.create();
-const inertia = /*@__PURE__*/ Mat3.create();
-const rotationMatrix = /*@__PURE__*/ Mat3.create();
-const tempMatrixA = /*@__PURE__*/ Mat3.create();
-const tempMatrixB = /*@__PURE__*/ Mat3.create();
-const tempMatrixC = /*@__PURE__*/ Mat3.create();
-
-const innerBounds = /*@__PURE__*/ Aabb.create();
-const isometry = /*@__PURE__*/ Isometry.create();
-
-const centerOfMass = /*@__PURE__*/ Vec3.create();
-const transformedCenterOfMass = /*@__PURE__*/ Vec3.create();
-
-const transformSubshapeToCompound = /*@__PURE__*/ Isometry.create();
-const subShapeDirection = /*@__PURE__*/ Vec3.create();
-const subShapeToWorld = /*@__PURE__*/ Isometry.create();
-
-const compoundShapeProps = {
-  computedCenterOfMass: MonomorphType(Vec3, {}, true),
-  computedVolume: NumberType(0.0, true),
-  computedAabb: MonomorphType(Aabb, {}, true),
-  copyForDiff: LazyReferenceType((() => CompoundShape) as () => never) as PropertyDefinitionReference<
-    CompoundShape | null,
-    true
-  >,
-  shapes: ReferenceListType(TransformedShape),
-} as const satisfies PropertyDefinitionMap;
-
-const afterConstructorCode = `
-  this.world = null;
-`;
-
-const tempTransform = /*@__PURE__*/ BasicTransform.create();
-
-export class CompoundShape
-  extends createClass<CompoundShape, typeof compoundShapeProps>(compoundShapeProps, { afterConstructorCode })
-  implements ShapeCollectionInterface
-{
-  type: ShapeType.compoundShape = ShapeType.compoundShape;
-
-  declare world: World | null;
-
-  walkShapes(onShapeFound: (shape: ConvexShape, transform: BasicTransform) => boolean) {
-    for (const shapeObj of this.shapes) {
-      const shape = shapeObj.shape as ConvexShape;
-      const transform = shapeObj.transform as BasicTransform;
-      tempTransform.copy(transform);
-      tempTransform.position.addVector(this.computedCenterOfMass);
-
-      if (onShapeFound(shape as ConvexShape, tempTransform)) {
-        return;
-      }
-    }
-  }
-
-  computeNumShapes() {
-    return this.shapes.length;
-  }
-
-  getShapeAtIndex(index: number) {
-    const shape = this.shapes.getAtIndex(index);
-    if (shape === null) {
-      throw new Error(`Shape at index ${index} not found in compound shape.`);
-    }
-    return shape;
-  }
-
-  computeSupportingFace(
-    out: Face,
-    subShapeID: number,
-    direction: Vec3,
-    scale: number,
-    transformCompoundToWorld: Mat4
-  ): void {
-    // transform the direction from compound space to subshape space. we have the subshape's translation and rotation
-    const { shape, transform } = this.getShapeAtIndex(subShapeID) as { shape: Shape; transform: BasicTransform };
-    const translation = transform.position;
-    const rotation = transform.rotation;
-    transformSubshapeToCompound.fromRotationAndTranslation(rotation, translation);
-    transformSubshapeToCompound.matrix.multiply3x3Transposed(subShapeDirection, direction);
-    // get the subShapeToWorld transform which is just the product of the compoundToWorld and subshapeToCompound transforms
-    subShapeToWorld.matrix.multiplyMatrices(transformCompoundToWorld, transformSubshapeToCompound.matrix);
-    // TODO: account for subShapeID in case we allow recursive compound shapes
-    shape.computeSupportingFace(out, subShapeID, subShapeDirection, scale, subShapeToWorld.matrix);
-  }
-
-  computeInertiaTensor(out: Mat3, totalMass: number): void {
-    // init the cumulative mass and inertia
-
-    let cumulativeMass = 0;
-    cumulativeInertia.zero();
-
-    const totalVolume = this.computedVolume;
-
-    for (const shapeObj of this.shapes) {
-      const shape = shapeObj.shape as ConvexShape;
-      const transform = shapeObj.transform;
-      const translation = transform.position;
-      const rotation = transform.rotation;
-
-      const volume = shape.computedVolume;
-      const mass = (volume / totalVolume) * totalMass;
-
-      // get the shape inertia tensor
-      shape.computeInertiaTensor(inertia, mass);
-
-      // rotate the inertia tensor
-      rotationMatrix.fromQuat(rotation);
-      inertia.multiplyMat3s(rotationMatrix, inertia);
-      inertia.multiplyMat3RightTransposed(rotationMatrix);
-
-      tempMatrixA.identity();
-      tempMatrixA.multiplyByScalar(translation.dot(translation));
-
-      tempMatrixB.outerProduct(translation, translation);
-
-      tempMatrixC.subtractMatrices(tempMatrixA, tempMatrixB);
-      tempMatrixC.multiplyByScalar(mass);
-
-      inertia.addMatrix(tempMatrixC);
-
-      // accumulate the mass and inertia
-      cumulativeMass += mass;
-      cumulativeInertia.addMatrix(inertia);
-    }
-
-    // return the cumulative inertia tensor
-    out.copy(cumulativeInertia);
-  }
-
-  computeInverseInertiaTensor(out: Mat3, mass: number): void {
-    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?
-    isometry.fromRotationAndTranslation(rotation, translation);
-    out.transformAabb(this.computedAabb, isometry);
-  }
-
-  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void {
-    if (subShapeId === undefined) {
-      throw new Error("CompoundShape.computeSurfaceNormal requires a subShapeId");
-    }
-
-    const { shape, transform } = this.getShapeAtIndex(subShapeId) as { shape: ConvexShape; transform: BasicTransform };
-
-    // transform the surface position from compound space to subshape space. we have the subshape's translation and rotation
-    transformCompoundToSubshape.fromInverseRotationAndTranslation(transform.rotation, transform.position);
-    subShapeSurfacePosition.transformVectorFromMat4(inLocalSurfacePosition, transformCompoundToSubshape.matrix);
-
-    // get the surface normal in subshape space
-    if (shape === undefined) {
-      throw new Error(`CompoundShape.setView: shapeId ${subShapeId} not found in world`); // TODO: handle this better
-    }
-    shape.computeSurfaceNormal(out, subShapeSurfacePosition, subShapeId);
-
-    // transform the surface normal from subshape space to compound space
-    transformCompoundToSubshape.matrix.multiply3x3Transposed(out, out);
-  }
-
-  hasChanged() {
-    // TODO: we don't support changes on transforms yet
-    for (const shapeObj of this.shapes) {
-      const hasChanged = (shapeObj.shape as ConvexShapeInterface).hasChanged();
-      if (hasChanged) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  update() {
-    updateShape(this);
-  }
-
-  commitChanges() {
-    if (this.hasChanged()) {
-      updateShape(this);
-      // this.world?.updateBodyProperties();
-    }
-  }
-}
-
-function updateCenterOfMass(compound: CompoundShape) {
-  // we simply average the centers of mass of the two shapes, applying the correct translation and rotation as we go
-  compound.computedCenterOfMass.zero();
-
-  for (const shapeObj of compound.shapes) {
-    const shape = shapeObj.shape as ConvexShape;
-    const transform = shapeObj.transform as BasicTransform;
-
-    const translation = transform.position;
-    const rotation = transform.rotation;
-
-    transformedCenterOfMass.applyQuatThenAddToVector(translation, rotation, shape.computedCenterOfMass);
-    // compound.computedCenterOfMass.addVectors(compound.computedCenterOfMass, transformedCenterOfMass);
-    compound.computedCenterOfMass.addVector(transformedCenterOfMass);
-  }
-
-  const numShapes = compound.computeNumShapes();
-  compound.computedCenterOfMass.scale(1 / numShapes);
-}
-
-const oldCreate = CompoundShape.create;
-CompoundShape.create = function () {
-  const shape = oldCreate.apply(this, arguments as any);
-  for (const shapeObj of shape.shapes) {
-    const transform = shapeObj.transform as BasicTransform;
-    transform.rotation.normalize();
-  }
-  updateShape(shape);
-  return shape;
-};
-
-const transformCompoundToSubshape = /*@__PURE__*/ Isometry.create();
-const subShapeSurfacePosition = /*@__PURE__*/ Vec3.create();
-
-let volume = 0;
-function addVolumeCallback(shape: Sphere | Box | ConvexHull | Cylinder | Capsule, transform: BasicTransform) {
-  volume += shape.computedVolume;
-  return false;
-}
-
-function updateVolume(shape: CompoundShape) {
-  volume = 0;
-  shape.walkShapes(addVolumeCallback);
-  shape.computedVolume = volume;
-}
-
-function updateLocalBounds(compound: CompoundShape) {
-  compound.computedAabb.min.zero();
-  compound.computedAabb.max.zero();
-
-  for (const shapeObj of compound.shapes) {
-    const shape = shapeObj.shape as ConvexShape;
-    const transform = shapeObj.transform as BasicTransform;
-
-    const translation = transform.position;
-    const rotation = transform.rotation;
-    isometry.fromRotationAndTranslation(rotation, translation);
-    innerBounds.transformAabb(shape.computedAabb, isometry);
-    compound.computedAabb.unionAabb(innerBounds);
-  }
-}
-
-function updateCopyForDiff(shape: CompoundShape) {
-  for (const shapeObj of shape.shapes) {
-    const subShape = shapeObj.shape as ConvexShape;
-    // @ts-ignore
-    subShape.copyForDiff!.copy(subShape);
-    subShape.copyForDiff!.copyForDiff = null;
-  }
-}
-
-function updateShape(shape: CompoundShape) {
-  updateCopyForDiff(shape);
-  updateCenterOfMass(shape);
-  updateVolume(shape);
-  updateLocalBounds(shape);
-}