planck-v2 2.0.0

package/src/collision/Manifold.ts

@@ -0,0 +1,420 @@
+/*
+ * Planck.js
+ *
+ * Copyright (c) Erin Catto, Ali Shakiba
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import * as geo from "../common/Geo";
+import { Vec2Value } from "../common/Vec2";
+import { TransformValue } from "../common/Transform";
+import { EPSILON } from "../common/Math";
+
+/** @internal */ const math_sqrt = Math.sqrt;
+
+/** @internal */ const pointA = geo.vec2(0, 0);
+/** @internal */ const pointB = geo.vec2(0, 0);
+/** @internal */ const cA = geo.vec2(0, 0);
+/** @internal */ const cB = geo.vec2(0, 0);
+/** @internal */ const dist = geo.vec2(0, 0);
+/** @internal */ const planePoint = geo.vec2(0, 0);
+/** @internal */ const clipPoint = geo.vec2(0, 0);
+
+export enum ManifoldType {
+  e_unset = -1,
+  e_circles = 0,
+  e_faceA = 1,
+  e_faceB = 2,
+}
+
+export enum ContactFeatureType {
+  e_unset = -1,
+  e_vertex = 0,
+  e_face = 1,
+}
+
+/**
+ * This is used for determining the state of contact points.
+ */
+export enum PointState {
+  /** Point does not exist */
+  nullState = 0,
+  /** Point was added in the update */
+  addState = 1,
+  /** Point persisted across the update */
+  persistState = 2,
+  /** Point was removed in the update */
+  removeState = 3,
+}
+
+/**
+ * Used for computing contact manifolds.
+ */
+export class ClipVertex {
+  v = geo.vec2(0, 0);
+  id: ContactID = new ContactID();
+
+  set(o: ClipVertex): void {
+    geo.copyVec2(this.v, o.v);
+    this.id.set(o.id);
+  }
+  recycle() {
+    geo.zeroVec2(this.v);
+    this.id.recycle();
+  }
+}
+
+/**
+ * A manifold for two touching convex shapes. Manifolds are created in `evaluate`
+ * method of Contact subclasses.
+ *
+ * Supported manifold types are e_faceA or e_faceB for clip point versus plane
+ * with radius and e_circles point versus point with radius.
+ *
+ * We store contacts in this way so that position correction can account for
+ * movement, which is critical for continuous physics. All contact scenarios
+ * must be expressed in one of these types. This structure is stored across time
+ * steps, so we keep it small.
+ */
+export class Manifold {
+  type: ManifoldType;
+
+  /**
+   * Usage depends on manifold type:
+   * - circles: not used
+   * - faceA: the normal on polygonA
+   * - faceB: the normal on polygonB
+   */
+  localNormal = geo.vec2(0, 0);
+
+  /**
+   * Usage depends on manifold type:
+   * - circles: the local center of circleA
+   * - faceA: the center of faceA
+   * - faceB: the center of faceB
+   */
+  localPoint = geo.vec2(0, 0);
+
+  /** The points of contact */
+  points: ManifoldPoint[] = [new ManifoldPoint(), new ManifoldPoint()];
+
+  /** The number of manifold points */
+  pointCount: number = 0;
+
+  set(that: Manifold): void {
+    this.type = that.type;
+    geo.copyVec2(this.localNormal, that.localNormal);
+    geo.copyVec2(this.localPoint, that.localPoint);
+    this.pointCount = that.pointCount;
+    this.points[0].set(that.points[0]);
+    this.points[1].set(that.points[1]);
+  }
+
+  recycle(): void {
+    this.type = ManifoldType.e_unset;
+    geo.zeroVec2(this.localNormal);
+    geo.zeroVec2(this.localPoint);
+    this.pointCount = 0;
+    this.points[0].recycle();
+    this.points[1].recycle();
+  }
+
+  /**
+   * Evaluate the manifold with supplied transforms. This assumes modest motion
+   * from the original state. This does not change the point count, impulses, etc.
+   * The radii must come from the shapes that generated the manifold.
+   */
+  getWorldManifold(
+    wm: WorldManifold | null,
+    xfA: TransformValue,
+    radiusA: number,
+    xfB: TransformValue,
+    radiusB: number,
+  ): WorldManifold {
+    if (this.pointCount == 0) {
+      return wm;
+    }
+
+    wm = wm || new WorldManifold();
+
+    wm.pointCount = this.pointCount;
+
+    const normal = wm.normal;
+    const points = wm.points;
+    const separations = wm.separations;
+
+    switch (this.type) {
+      case ManifoldType.e_circles: {
+        geo.setVec2(normal, 1.0, 0.0);
+        const manifoldPoint = this.points[0];
+        geo.transformVec2(pointA, xfA, this.localPoint);
+        geo.transformVec2(pointB, xfB, manifoldPoint.localPoint);
+        geo.subVec2(dist, pointB, pointA);
+        const lengthSqr = geo.lengthSqrVec2(dist);
+        if (lengthSqr > EPSILON * EPSILON) {
+          const length = math_sqrt(lengthSqr);
+          geo.scaleVec2(normal, 1 / length, dist);
+        }
+        geo.combine2Vec2(cA, 1, pointA, radiusA, normal);
+        geo.combine2Vec2(cB, 1, pointB, -radiusB, normal);
+        geo.combine2Vec2(points[0], 0.5, cA, 0.5, cB);
+        separations[0] = geo.dotSubVec2(cB, cA, normal);
+        break;
+      }
+
+      case ManifoldType.e_faceA: {
+        geo.rotVec2(normal, xfA.q, this.localNormal);
+        geo.transformVec2(planePoint, xfA, this.localPoint);
+
+        for (let i = 0; i < this.pointCount; ++i) {
+          const manifoldPoint = this.points[i];
+          geo.transformVec2(clipPoint, xfB, manifoldPoint.localPoint);
+          geo.combine2Vec2(cA, 1, clipPoint, radiusA - geo.dotSubVec2(clipPoint, planePoint, normal), normal);
+          geo.combine2Vec2(cB, 1, clipPoint, -radiusB, normal);
+          geo.combine2Vec2(points[i], 0.5, cA, 0.5, cB);
+          separations[i] = geo.dotSubVec2(cB, cA, normal);
+        }
+        break;
+      }
+
+      case ManifoldType.e_faceB: {
+        geo.rotVec2(normal, xfB.q, this.localNormal);
+        geo.transformVec2(planePoint, xfB, this.localPoint);
+
+        for (let i = 0; i < this.pointCount; ++i) {
+          const manifoldPoint = this.points[i];
+          geo.transformVec2(clipPoint, xfA, manifoldPoint.localPoint);
+          geo.combine2Vec2(cB, 1, clipPoint, radiusB - geo.dotSubVec2(clipPoint, planePoint, normal), normal);
+          geo.combine2Vec2(cA, 1, clipPoint, -radiusA, normal);
+          geo.combine2Vec2(points[i], 0.5, cA, 0.5, cB);
+          separations[i] = geo.dotSubVec2(cA, cB, normal);
+        }
+        // Ensure normal points from A to B.
+        geo.negVec2(normal);
+        break;
+      }
+    }
+
+    return wm;
+  }
+
+  static clipSegmentToLine = clipSegmentToLine;
+  static ClipVertex = ClipVertex;
+  static getPointStates = getPointStates;
+  static PointState = PointState;
+}
+
+/**
+ * A manifold point is a contact point belonging to a contact manifold. It holds
+ * details related to the geometry and dynamics of the contact points.
+ *
+ * This structure is stored across time steps, so we keep it small.
+ *
+ * Note: impulses are used for internal caching and may not provide reliable
+ * contact forces, especially for high speed collisions.
+ */
+export class ManifoldPoint {
+  /**
+   * Usage depends on manifold type:
+   * - circles: the local center of circleB
+   * - faceA: the local center of circleB or the clip point of polygonB
+   * - faceB: the clip point of polygonA
+   */
+  localPoint = geo.vec2(0, 0);
+  /**
+   * The non-penetration impulse
+   */
+  normalImpulse = 0;
+  /**
+   * The friction impulse
+   */
+  tangentImpulse = 0;
+  /**
+   * Uniquely identifies a contact point between two shapes to facilitate warm starting
+   */
+  readonly id = new ContactID();
+
+  set(that: ManifoldPoint): void {
+    geo.copyVec2(this.localPoint, that.localPoint);
+    this.normalImpulse = that.normalImpulse;
+    this.tangentImpulse = that.tangentImpulse;
+    this.id.set(that.id);
+  }
+
+  recycle(): void {
+    geo.zeroVec2(this.localPoint);
+    this.normalImpulse = 0;
+    this.tangentImpulse = 0;
+    this.id.recycle();
+  }
+}
+
+/**
+ * Contact ids to facilitate warm starting.
+ *
+ * ContactFeature: The features that intersect to form the contact point.
+ */
+export class ContactID {
+  /**
+   * Used to quickly compare contact ids.
+   */
+  key = -1;
+
+  /** ContactFeature index on shapeA */
+  indexA = -1;
+
+  /** ContactFeature index on shapeB */
+  indexB = -1;
+
+  /** ContactFeature type on shapeA */
+  typeA = ContactFeatureType.e_unset;
+
+  /** ContactFeature type on shapeB */
+  typeB = ContactFeatureType.e_unset;
+
+  setFeatures(indexA: number, typeA: ContactFeatureType, indexB: number, typeB: ContactFeatureType): void {
+    this.indexA = indexA;
+    this.indexB = indexB;
+    this.typeA = typeA;
+    this.typeB = typeB;
+    this.key = this.indexA + this.indexB * 4 + this.typeA * 16 + this.typeB * 64;
+  }
+
+  set(that: ContactID): void {
+    this.indexA = that.indexA;
+    this.indexB = that.indexB;
+    this.typeA = that.typeA;
+    this.typeB = that.typeB;
+    this.key = this.indexA + this.indexB * 4 + this.typeA * 16 + this.typeB * 64;
+  }
+
+  swapFeatures(): void {
+    const indexA = this.indexA;
+    const indexB = this.indexB;
+    const typeA = this.typeA;
+    const typeB = this.typeB;
+    this.indexA = indexB;
+    this.indexB = indexA;
+    this.typeA = typeB;
+    this.typeB = typeA;
+    this.key = this.indexA + this.indexB * 4 + this.typeA * 16 + this.typeB * 64;
+  }
+
+  recycle(): void {
+    this.indexA = 0;
+    this.indexB = 0;
+    this.typeA = ContactFeatureType.e_unset;
+    this.typeB = ContactFeatureType.e_unset;
+    this.key = -1;
+  }
+}
+
+/**
+ * This is used to compute the current state of a contact manifold.
+ */
+export class WorldManifold {
+  /** World vector pointing from A to B */
+  normal = geo.vec2(0, 0);
+
+  /** World contact point (point of intersection) */
+  points = [geo.vec2(0, 0), geo.vec2(0, 0)]; // [maxManifoldPoints]
+
+  /** A negative value indicates overlap, in meters */
+  separations = [0, 0]; // [maxManifoldPoints]
+
+  /** The number of manifold points */
+  pointCount = 0;
+
+  recycle() {
+    geo.zeroVec2(this.normal);
+    geo.zeroVec2(this.points[0]);
+    geo.zeroVec2(this.points[1]);
+    this.separations[0] = 0;
+    this.separations[1] = 0;
+    this.pointCount = 0;
+  }
+}
+
+/**
+ * Compute the point states given two manifolds. The states pertain to the
+ * transition from manifold1 to manifold2. So state1 is either persist or remove
+ * while state2 is either add or persist.
+ */
+export function getPointStates(
+  state1: PointState[],
+  state2: PointState[],
+  manifold1: Manifold,
+  manifold2: Manifold,
+): void {
+  // state1, state2: PointState[Settings.maxManifoldPoints]
+
+  // for (var i = 0; i < Settings.maxManifoldPoints; ++i) {
+  // state1[i] = PointState.nullState;
+  // state2[i] = PointState.nullState;
+  // }
+
+  // Detect persists and removes.
+  for (let i = 0; i < manifold1.pointCount; ++i) {
+    const id = manifold1.points[i].id;
+
+    state1[i] = PointState.removeState;
+
+    for (let j = 0; j < manifold2.pointCount; ++j) {
+      if (manifold2.points[j].id.key === id.key) {
+        state1[i] = PointState.persistState;
+        break;
+      }
+    }
+  }
+
+  // Detect persists and adds.
+  for (let i = 0; i < manifold2.pointCount; ++i) {
+    const id = manifold2.points[i].id;
+
+    state2[i] = PointState.addState;
+
+    for (let j = 0; j < manifold1.pointCount; ++j) {
+      if (manifold1.points[j].id.key === id.key) {
+        state2[i] = PointState.persistState;
+        break;
+      }
+    }
+  }
+}
+
+/**
+ * Clipping for contact manifolds. Sutherland-Hodgman clipping.
+ */
+export function clipSegmentToLine(
+  vOut: ClipVertex[],
+  vIn: ClipVertex[],
+  normal: Vec2Value,
+  offset: number,
+  vertexIndexA: number,
+): number {
+  // Start with no output points
+  let numOut = 0;
+
+  // Calculate the distance of end points to the line
+  const distance0 = geo.dotVec2(normal, vIn[0].v) - offset;
+  const distance1 = geo.dotVec2(normal, vIn[1].v) - offset;
+
+  // If the points are behind the plane
+  if (distance0 <= 0.0) vOut[numOut++].set(vIn[0]);
+  if (distance1 <= 0.0) vOut[numOut++].set(vIn[1]);
+
+  // If the points are on different sides of the plane
+  if (distance0 * distance1 < 0.0) {
+    // Find intersection point of edge and plane
+    const interp = distance0 / (distance0 - distance1);
+    geo.combine2Vec2(vOut[numOut].v, 1 - interp, vIn[0].v, interp, vIn[1].v);
+
+    // VertexA is hitting edgeB.
+    vOut[numOut].id.setFeatures(vertexIndexA, ContactFeatureType.e_vertex, vIn[0].id.indexB, ContactFeatureType.e_face);
+    ++numOut;
+  }
+
+  return numOut;
+}

package/src/collision/Raycast.ts

@@ -0,0 +1,30 @@
+/*
+ * Planck.js
+ *
+ * Copyright (c) Erin Catto, Ali Shakiba
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { Vec2Value } from "../common/Vec2";
+
+/**
+ * Ray-cast input data. The ray extends from `p1` to `p1 + maxFraction * (p2 - p1)`.
+ */
+export interface RayCastInput {
+  p1: Vec2Value;
+  p2: Vec2Value;
+  maxFraction: number;
+}
+
+export type RayCastCallback = (subInput: RayCastInput, id: number) => number;
+
+/**
+ * Ray-cast output data. The ray hits at `p1 + fraction * (p2 - p1)`,
+ * where `p1` and `p2` come from RayCastInput.
+ */
+export interface RayCastOutput {
+  normal: Vec2Value;
+  fraction: number;
+}

package/src/collision/Shape.ts

@@ -0,0 +1,114 @@
+/*
+ * Planck.js
+ *
+ * Copyright (c) Erin Catto, Ali Shakiba
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type { MassData } from "../dynamics/Body";
+import { AABBValue } from "./AABB";
+import { RayCastOutput, RayCastInput } from "./Raycast";
+import { DistanceProxy } from "./Distance";
+import type { TransformValue } from "../common/Transform";
+import type { Vec2Value } from "../common/Vec2";
+import { Style } from "../util/Testbed";
+
+// todo make shape an interface
+
+/**
+ * A shape is used for collision detection. You can create a shape however you
+ * like. Shapes used for simulation in World are created automatically when a
+ * Fixture is created. Shapes may encapsulate one or more child shapes.
+ */
+export abstract class Shape {
+  /** @hidden */ m_type: ShapeType;
+
+  /**
+   * @hidden
+   * Radius of a shape. For polygonal shapes this must be b2_polygonRadius.
+   * There is no support for making rounded polygons.
+   */
+  m_radius: number;
+
+  /** Styling for dev-tools. */
+  style: Style = {};
+
+  /** @hidden @experimental Similar to userData, but used by dev-tools or runtime environment. */
+  appData: Record<string, any> = {};
+
+  /** @hidden */
+  abstract _reset(): void;
+
+  static isValid(obj: any): boolean {
+    if (obj === null || typeof obj === "undefined") {
+      return false;
+    }
+    return typeof obj.m_type === "string" && typeof obj.m_radius === "number";
+  }
+
+  abstract getRadius(): number;
+
+  /**
+   * Get the type of this shape. You can use this to down cast to the concrete
+   * shape.
+   *
+   * @return the shape type.
+   */
+  abstract getType(): ShapeType;
+
+  /**
+   * @internal @deprecated Shapes should be treated as immutable.
+   *
+   * clone the concrete shape.
+   */
+  abstract _clone(): Shape;
+
+  /**
+   * Get the number of child primitives.
+   */
+  abstract getChildCount(): number;
+
+  /**
+   * Test a point for containment in this shape. This only works for convex
+   * shapes.
+   *
+   * @param xf The shape world transform.
+   * @param p A point in world coordinates.
+   */
+  abstract testPoint(xf: TransformValue, p: Vec2Value): boolean;
+
+  /**
+   * Cast a ray against a child shape.
+   *
+   * @param output The ray-cast results.
+   * @param input The ray-cast input parameters.
+   * @param xf The transform to be applied to the shape.
+   * @param childIndex The child shape index
+   */
+  abstract rayCast(output: RayCastOutput, input: RayCastInput, xf: TransformValue, childIndex: number): boolean;
+
+  /**
+   * Given a transform, compute the associated axis aligned bounding box for a
+   * child shape.
+   *
+   * @param aabb Returns the axis aligned box.
+   * @param xf The world transform of the shape.
+   * @param childIndex The child shape
+   */
+  abstract computeAABB(aabb: AABBValue, xf: TransformValue, childIndex: number): void;
+
+  /**
+   * Compute the mass properties of this shape using its dimensions and density.
+   * The inertia tensor is computed about the local origin.
+   *
+   * @param massData Returns the mass data for this shape.
+   * @param density The density in kilograms per meter squared.
+   */
+  abstract computeMass(massData: MassData, density?: number): void;
+
+  abstract computeDistanceProxy(proxy: DistanceProxy, childIndex: number): void;
+}
+
+export type ShapeType = "circle" | "edge" | "polygon" | "chain";