@daneren2005/shared-memory-physics 1.2.1 → 1.2.2

package/README.md

@@ -85,10 +85,17 @@ exactly still counts as **not** overlapping, whichever pair it is, and a shape w
 anything. Which of the two sizes decides that depends on the shape: a circle with no height is a perfectly
 good circle, while a rectangle with no height is nothing at all.
 
+`contactNormal` answers the other half of a contact: the unit direction one shape is pushed off the other,
+written into a `{ x, y }` you pass in, and `false` when the two are exactly on top of each other and there is no
+such direction. It splits the same three ways off the same geometry, so the direction is the face that was
+actually hit at the angle the pair is turned to - not the nearest world axis. This is what the native bounce
+reflects around; a game reaching for its own response can use it the same way.
+
 `shapesOverlap` is exported, along with `shapeHalfWidth` / `shapeHalfHeight` (the axis-aligned box a shape is
 indexed under), `shapeRadius`, `shapeIsEmpty`, `capsuleHalfLength`, and the distance primitives underneath -
-`segmentSegmentDistanceSquared`, `segmentBoxDistanceSquared` and `pointSegmentDistanceSquared`.
-`orientedBoxesOverlap`, `boundsHalfWidth` and `boundsHalfHeight` are still there and still rectangle-only.
+`segmentSegmentDistanceSquared`, `segmentBoxDistanceSquared` and `pointSegmentDistanceSquared`, each of which
+takes an optional `out` vector and fills it with the gap it measured. `orientedBoxesOverlap`, `boundsHalfWidth`
+and `boundsHalfHeight` are still there and still rectangle-only.
 
 ## Registering
 
@@ -401,11 +408,13 @@ world.addSystem(new PhysicsSystem<Components, GameUpdateComponents>(world, {
 `createPhysicsUpdate` stamps what it needs onto the function it returns, so `optional` and the collidable
 query come across with `updateFunction` and never have to be repeated on the system.
 
-**Per entity, not per pair.** The callback fires for the entity that *moved*, once for each thing it ended up
-on top of. `self` is that entity, with every block the system asked for; `other` is what it hit, where only
-`transform` is guaranteed. Two moving entities that run into each other therefore get one call each with the
-roles swapped - which is what lets a callback act on itself and leave the other side to its own call. An
-entity with no velocity is never `self`, because the system never moves it, but it is still found as `other`.
+**Once per pair, per run.** Both sides of a contact find it - one by sweeping into it, the other by overlapping
+it on its own turn - and the callback fires once, for whichever got there first. `self` is that entity, with
+every block the system asked for; `other` is the one it hit, where only `transform` is guaranteed. **The other
+side gets no call of its own**, so a callback that only touches `self` leaves it untouched: apply damage, tag a
+kill, or raise an event for *both* entities in the one call. Which of the two is `self` follows update order
+and is not something to depend on. An entity with no velocity is never `self`, because the system never moves
+it, but it is still found as `other`.
 
 Writes go straight into shared memory, so a callback can bounce an entity by flipping its velocity, or push a
 value another thread also touches with the atomics from `@daneren2005/shared-memory-objects`. To reach past
@@ -600,8 +609,8 @@ npm start          # http://127.0.0.1:8080
 ```
 
 - **Bouncing circles** - circles with a random position and heading, reflected off each other and off the
-  walls by an `onCollision` that mirrors the velocity about the contact normal.
-- **Bouncing rectangles** - the same, on boxes of random width and height, where the normal is the axis the
+  walls by the native bounce, which mirrors the velocity about the contact normal.
+- **Bouncing rectangles** - the same, on boxes of random width and height, where the normal is the face the
   two are least through each other on rather than the line between their centres.
 - **Walking into a wall** - one unit between two boxes, turned around on a timer so it presses into each of
   them in turn. It starts on a deliberately long 100ms physics step, so turning **interpolate rendering** off is

package/dist/components/registry.d.ts

@@ -27,6 +27,7 @@ export type PhysicsUpdateComponents = {
     body?: Uint32Array;
     bounciness?: Float32Array;
     interpolation?: Float32Array;
+    entity?: Uint32Array;
 };
 export type InterpolationUpdateComponents = {
     transform: Float32Array;

package/dist/index.d.ts

@@ -15,7 +15,8 @@ export { INTERPOLATION_X_INDEX, INTERPOLATION_Y_INDEX, INTERPOLATION_PREV_X_INDE
 export type { InterpolationComponent, InterpolationConfig, SnappableEntity, } from './components/interpolation-component';
 export { physicsRegistry } from './components/registry';
 export type { PhysicsComponents, PhysicsUpdateComponents, InterpolationComponents, InterpolationUpdateComponents, } from './components/registry';
-export { shapesOverlap, shapeHalfWidth, shapeHalfHeight, shapeIsEmpty, shapeRadius, capsuleHalfLength, boundsHalfWidth, boundsHalfHeight, orientedBoxesOverlap, segmentSegmentDistanceSquared, segmentBoxDistanceSquared, pointSegmentDistanceSquared, } from './math/shapes';
+export { shapesOverlap, contactNormal, shapeHalfWidth, shapeHalfHeight, shapeIsEmpty, shapeRadius, capsuleHalfLength, boundsHalfWidth, boundsHalfHeight, orientedBoxesOverlap, segmentSegmentDistanceSquared, segmentBoxDistanceSquared, pointSegmentDistanceSquared, } from './math/shapes';
+export type { Vector } from './math/shapes';
 export { default as CollisionBroadphase, COLLIDABLE_QUERY } from './systems/collision';
 export type { CollisionComponents, CollisionEntity, CollisionFunction, MoveResult, MovingEntity, SweepResult } from './systems/collision';
 export { default as SpatialIndex } from './systems/spatial-index';