@cyclonium/physics-2d 0.0.103 → 0.1.0

package/lib/character-controller-2d.js

@@ -156,8 +156,7 @@ let KinematicCharacterController2D = class KinematicCharacterController2D extend
         else {
             const currentPosition = fromPx2ImplVec2(rigidBody.impl.nextTranslation());
             const newPosition = fromPx2ImplVec2(currentPosition).add(movement);
-            Transform2DComponent.of(collider).position = newPosition;
-            rigidBody.impl.setNextKinematicTranslation(toPx2ImplVec2(newPosition));
+            rigidBody.setNextKinematicPosition(newPosition);
         }
         this._emitCharacterCollisionEvents(impl, world);
     }

package/lib/collider-2d.d.ts

@@ -12,37 +12,12 @@ export declare abstract class Collider2D extends PhysicsComponent2DBase {
     get center(): Vec2;
     set center(value: Vec2);
     get bounds(): Bounds2D;
-    /**
-     * Test only.
-     * @internal
-     */
-    get impl_internal(): px2Impl.Collider | undefined;
     onContactBegin: import("@cyclonium/event").ManagedEventEmitter<[Collider2D, Collider2D, Contact2DInfo]>;
     onContactStay: import("@cyclonium/event").ManagedEventEmitter<[Collider2D, Collider2D, Contact2DInfo]>;
     onContactEnd: import("@cyclonium/event").ManagedEventEmitter<[Collider2D, Collider2D, Contact2DInfo]>;
     intersect(opts: ShapeIntersectionQueryOptions): ColliderShapeIntersection | undefined;
     cast(opts: ShapeCastQueryOptions): ColliderShapeCastHit | undefined;
     castRay(ray: Ray2D, maxDistance: number, solid?: boolean): RayColliderIntersection | undefined;
-    /**
-     * @internal
-     */
-    _enableCollisionEventsSinceBody(value: boolean): void;
-    /**
-     * @internal
-     */
-    _responseToBodyActiveCollisionTypes(value: number): void;
-    /**
-     * @internal
-     */
-    _responseToBodyCollisionGroups(value: number): void;
-    /**
-     * @internal
-     */
-    _responseToBodySolverGroups(value: number): void;
-    /**
-     * @internal
-     */
-    _responseToAttachedRigidBodyChanged(): void;
     protected get _implCollider(): px2Impl.Collider | undefined;
     protected recreateCollider(): void;
     protected onAttachToWorld(): void;

package/lib/physics-2d-settings.d.ts

@@ -2,6 +2,7 @@ import { Asset } from 'cc';
 import { CollisionMatrix } from './collision-matrix.js';
 export declare class Physics2DSettings extends Asset {
     fps: number;
+    maxSubsteps: number;
     get tags(): Record<string, number>;
     private get tags_editor();
     private set tags_editor(value);

package/lib/physics-2d-settings.js

@@ -4,13 +4,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Asset } from 'cc';
+import { Asset, CCInteger } from 'cc';
 import { editable, serializable } from '@cyclonium/core/legacy-decorator';
 import { cycloBuiltinClass } from '@cyclonium/core/internal';
 import { CollisionMatrix } from './collision-matrix.js';
 import { dumpRaw } from '@cyclonium/core/utils';
 let Physics2DSettings = class Physics2DSettings extends Asset {
     fps = 60;
+    maxSubsteps = 4;
     get tags() {
         return this._tags;
     }
@@ -31,8 +32,12 @@ let Physics2DSettings = class Physics2DSettings extends Asset {
 };
 __decorate([
     serializable,
-    editable
+    editable({ min: 1 })
 ], Physics2DSettings.prototype, "fps", void 0);
+__decorate([
+    serializable,
+    editable({ type: CCInteger, min: 1, step: 1 })
+], Physics2DSettings.prototype, "maxSubsteps", void 0);
 __decorate([
     editable,
     dumpRaw

package/lib/physics-world-2d-scene-component.d.ts

@@ -1,6 +1,6 @@
 import { CycloComponent } from '@cyclonium/core/framework';
-import { PhysicsWorld2D } from './physics-world-2d.js';
 import { Physics2DSettings } from './physics-2d-settings.js';
+import { PhysicsWorld2D } from './physics-world-2d.js';
 export declare class PhysicsWorld2DSceneComponent extends CycloComponent {
     get debug(): boolean;
     set debug(v: boolean);
@@ -13,6 +13,9 @@ export declare class PhysicsWorld2DSceneComponent extends CycloComponent {
     private _physicsWorld;
     private _physicsDebugger;
     private _lastUpdateFrame;
+    private _maxSubsteps;
+    private _timeAccumulator;
+    private _overloading;
     private _debug;
     private _settings;
     private _updateFrame;

package/lib/physics-world-2d-scene-component.js

@@ -6,13 +6,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { EDITOR_NOT_IN_PREVIEW } from 'cc/env';
 import { editable, executionOrder, idem, serializable } from '@cyclonium/core/legacy-decorator';
-import { CycloComponent } from '@cyclonium/core/framework';
-import { PhysicsWorld2D } from './physics-world-2d.js';
-import { Physics2DDebugger } from '#physics-2d-debugger';
-import { PredefinedExecutionOrder } from '@cyclonium/core/framework';
+import { CycloComponent, PredefinedExecutionOrder } from '@cyclonium/core/framework';
 import { director } from 'cc';
-import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { cycloBuiltinClass, TimeAccumulator } from '@cyclonium/core/internal';
+import { logger } from '@cyclonium/core/log';
+import { Physics2DDebugger } from '#physics-2d-debugger';
 import { Physics2DSettings } from './physics-2d-settings.js';
+import { PhysicsWorld2D } from './physics-world-2d.js';
+const getDefaultSettings = (() => {
+    let defaultSettings;
+    return () => defaultSettings ??= new Physics2DSettings();
+})();
 let PhysicsWorld2DSceneComponent = class PhysicsWorld2DSceneComponent extends CycloComponent {
     get debug() {
         return this._debug;
@@ -35,7 +39,19 @@ let PhysicsWorld2DSceneComponent = class PhysicsWorld2DSceneComponent extends Cy
     }
     onAwake() {
         if (!EDITOR_NOT_IN_PREVIEW) {
-            const settings = this._settings ?? new Physics2DSettings();
+            const settings = this._settings ?? getDefaultSettings();
+            let fps = settings.fps;
+            let maxSubsteps = settings.maxSubsteps;
+            if (!Number.isFinite(fps) || fps <= 0) {
+                logger.error(`Invalid Physics2DSettings.fps (${fps});`);
+                fps = getDefaultSettings().fps;
+            }
+            if (!Number.isInteger(maxSubsteps) || maxSubsteps <= 0) {
+                logger.error(`Invalid Physics2DSettings.maxSubsteps (${maxSubsteps});`);
+                maxSubsteps = getDefaultSettings().maxSubsteps;
+            }
+            this._timeAccumulator = new TimeAccumulator(1 / fps);
+            this._maxSubsteps = maxSubsteps;
             this._physicsWorld = new PhysicsWorld2D({
                 scene: this.node.scene,
                 tags: settings.tags,
@@ -69,9 +85,12 @@ let PhysicsWorld2DSceneComponent = class PhysicsWorld2DSceneComponent extends Cy
     _physicsWorld = null;
     _physicsDebugger = undefined;
     _lastUpdateFrame = -1;
+    _maxSubsteps = 4;
+    _timeAccumulator = new TimeAccumulator(1 / 60);
+    _overloading = false;
     _debug = false;
     _settings = null;
-    _updateFrame(_deltaTime) {
+    _updateFrame(deltaTime) {
         const world = this._physicsWorld;
         if (!world) {
             return;
@@ -82,7 +101,17 @@ let PhysicsWorld2DSceneComponent = class PhysicsWorld2DSceneComponent extends Cy
             this._lastUpdateFrame = actualFrame;
             world.setOutdated();
         }
-        world.step(1 / 60);
+        const timeAccumulator = this._timeAccumulator;
+        const fixedDeltaTime = timeAccumulator.timeStep;
+        const maxSubsteps = this._maxSubsteps;
+        const actualSubsteps = timeAccumulator.advance(deltaTime, maxSubsteps);
+        const maximumDeltaTime = maxSubsteps * fixedDeltaTime;
+        const overloading = deltaTime > maximumDeltaTime;
+        if (overloading && !this._overloading) {
+            logger.warn(`PhysicsWorld2D clamped an update to the ${maxSubsteps}-substep limit.`);
+        }
+        this._overloading = overloading;
+        world.advanceSubsteps_internal(fixedDeltaTime, actualSubsteps);
         this._physicsDebugger?.render();
     }
 };

package/lib/physics-world-2d.d.ts

@@ -41,7 +41,8 @@ export declare class PhysicsWorld2D {
     get listenersOnWillDestroy(): import("@cyclonium/event").EventListenerRegistry<[]>;
     get impl(): px2Impl.World;
     destroy(): void;
-    step(_deltaTime: number): void;
+    step(deltaTime: number): void;
+    private _step;
     setOutdated(): void;
     getTagId(tag: string): number;
     intersectionWithPoint(point: Vec2, filter: SceneQueryFilter): Generator<Collider2D, void, unknown>;

package/lib/physics-world-2d.js

@@ -64,7 +64,22 @@ export class PhysicsWorld2D {
         this._worldImpl.free();
         this._worldImpl = null;
     }
-    step(_deltaTime) {
+    step(deltaTime) {
+        this.advanceSubsteps_internal(deltaTime, 1);
+    }
+    /**
+     * Advances a batch of physics steps where `deltaTime` is the length of each substep.
+     * @internal
+     */
+    advanceSubsteps_internal(deltaTime, substepCount) {
+        this._worldImpl.timestep = deltaTime;
+        for (let i = 0; i < substepCount; i++) {
+            const remainingSubsteps = substepCount - i;
+            const stepFraction = 1 / remainingSubsteps;
+            this._step(stepFraction, remainingSubsteps === 1);
+        }
+    }
+    _step(stepFraction, isLastSubstep) {
         const outdated = this._outDated;
         this._outDated = false;
         for (const component of this._physicsComponents) {
@@ -73,6 +88,12 @@ export class PhysicsWorld2D {
             }
             invokeOnSyncTransforms(component, outdated, outdated);
         }
+        for (const { component } of this._rigidBodies.values()) {
+            if (!component.enabled) {
+                continue;
+            }
+            component.applyKinematicTargetForStep_internal(stepFraction, isLastSubstep);
+        }
         this._worldImpl.step(this._eventQueue);
         for (const component of this._physicsComponents) {
             if (!component.enabled) {

package/lib/rigid-body-2d.d.ts

@@ -36,7 +36,9 @@ export declare class RigidBody2D extends PhysicsComponent2DBase {
     set linearVelocity(value: Vec2);
     hasTag(tag: string): boolean;
     addTag(tag: string): void;
+    /** Sets the position target reached across the next physics step batch. */
     setNextKinematicPosition(position: Vec2): void;
+    /** Sets the rotation target reached across the next physics step batch. */
     setNextKinematicRotation(rotation: number): void;
     get impl(): px2Impl.RigidBody | undefined;
     protected onDestroy(): void;
@@ -56,6 +58,11 @@ export declare class RigidBody2D extends PhysicsComponent2DBase {
     private _physicsPosition;
     private _physicsRotation;
     private _linearVelocity;
+    private _kinematicPositionTarget;
+    private _substepKinematicPositionTarget;
+    private _kinematicRotationTarget;
+    private _hasKinematicPositionTarget;
+    private _hasKinematicRotationTarget;
     private _listenerFlags;
     private _transformChangeFlagsObserver;
     private get _transform();

package/lib/rigid-body-2d.js

@@ -15,8 +15,8 @@ import { createCollisionEventEmitter, ContactEventListenerFlagIndex } from './sh
 import { CCString } from 'cc';
 import { EDITOR_NOT_IN_PREVIEW } from 'cc/env';
 import { cycloBuiltinClass } from '@cyclonium/core/internal';
-import { approxEqual } from '@cyclonium/core/math/number';
-import { to0ToPI2 } from '@cyclonium/core/math/trigonometry';
+import { approxEqual, lerp } from '@cyclonium/core/math/number';
+import { lerpAngle, to0ToPI2 } from '@cyclonium/core/math/trigonometry';
 export var RigidBody2DType;
 (function (RigidBody2DType) {
     RigidBody2DType["fixed"] = "fixed";
@@ -141,10 +141,16 @@ let RigidBody2D = class RigidBody2D extends PhysicsComponent2DBase {
             this._tags.push(tag);
         }
     }
+    /** Sets the position target reached across the next physics step batch. */
     setNextKinematicPosition(position) {
+        this._kinematicPositionTarget.copyFrom(position);
+        this._hasKinematicPositionTarget = true;
         this._rigidBodyControlBlock?.impl.setNextKinematicTranslation(position);
     }
+    /** Sets the rotation target reached across the next physics step batch. */
     setNextKinematicRotation(rotation) {
+        this._kinematicRotationTarget = rotation;
+        this._hasKinematicRotationTarget = true;
         this._rigidBodyControlBlock?.impl.setNextKinematicRotation(rotation);
     }
     get impl() {
@@ -188,6 +194,35 @@ let RigidBody2D = class RigidBody2D extends PhysicsComponent2DBase {
     onSyncTransforms(forceTransform, _forceScale) {
         this._syncToPhysics(forceTransform);
     }
+    /** @internal */
+    applyKinematicTargetForStep_internal(stepFraction, isLastSubstep) {
+        const implBody = this._rigidBodyControlBlock?.impl;
+        if (!implBody || this._type !== RigidBody2DType.kinematicPositionBased) {
+            return;
+        }
+        if (this._hasKinematicPositionTarget) {
+            const substepTarget = this._substepKinematicPositionTarget;
+            if (isLastSubstep) {
+                substepTarget.copyFrom(this._kinematicPositionTarget);
+                this._hasKinematicPositionTarget = false;
+            }
+            else {
+                const position = this._physicsPosition;
+                const target = this._kinematicPositionTarget;
+                substepTarget.set(lerp(position.x, target.x, stepFraction), lerp(position.y, target.y, stepFraction));
+            }
+            implBody.setNextKinematicTranslation(substepTarget);
+        }
+        if (this._hasKinematicRotationTarget) {
+            const substepTarget = isLastSubstep
+                ? this._kinematicRotationTarget
+                : lerpAngle(this._physicsRotation, this._kinematicRotationTarget, stepFraction);
+            if (isLastSubstep) {
+                this._hasKinematicRotationTarget = false;
+            }
+            implBody.setNextKinematicRotation(substepTarget);
+        }
+    }
     onAfterPhysicsStep() {
         this._syncFromPhysics();
     }
@@ -200,6 +235,11 @@ let RigidBody2D = class RigidBody2D extends PhysicsComponent2DBase {
     _physicsPosition = new Vec2();
     _physicsRotation = 0.0;
     _linearVelocity = new Vec2();
+    _kinematicPositionTarget = new Vec2();
+    _substepKinematicPositionTarget = new Vec2();
+    _kinematicRotationTarget = 0;
+    _hasKinematicPositionTarget = false;
+    _hasKinematicRotationTarget = false;
     _listenerFlags = 0;
     _transformChangeFlagsObserver = new TransformChangeFlagsObserver();
     get _transform() { return undefined; }
@@ -275,6 +315,8 @@ let RigidBody2D = class RigidBody2D extends PhysicsComponent2DBase {
         this._rigidBodyControlBlock = null;
         this._physicsPosition.set(0, 0);
         this._physicsRotation = 0.0;
+        this._hasKinematicPositionTarget = false;
+        this._hasKinematicRotationTarget = false;
     }
     _setPhysicsPosition(position) {
         this._physicsPosition.copyFrom(position);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyclonium/physics-2d",
-  "version": "0.0.103",
+  "version": "0.1.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/shrinktofit/cyclonium",
@@ -25,13 +25,13 @@
   },
   "dependencies": {
     "@cyclonium/algorithm": "1.0.0",
-    "@cyclonium/debug-draw": "0.0.103",
+    "@cyclonium/debug-draw": "0.0.105",
     "@cyclonium/event": "0.0.103",
     "@cyclonium/rapier2d": "0.0.102",
     "@cyclonium/web-assembly": "0.0.102"
   },
   "peerDependencies": {
-    "@cyclonium/core": "0.0.103"
+    "@cyclonium/core": "0.0.105"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",