@cyclonium/physics-2d 0.0.104 → 1.0.0

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

@@ -5,14 +5,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 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 { editable, executionOrder, idem, stored } from '@cyclonium/core/legacy-decorator';
+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;
@@ -33,9 +37,24 @@ let PhysicsWorld2DSceneComponent = class PhysicsWorld2DSceneComponent extends Cy
     set settings(value) {
         this._settings = value;
     }
+    get physicsWorld() {
+        return this._physicsWorld;
+    }
     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,
@@ -63,15 +82,15 @@ let PhysicsWorld2DSceneComponent = class PhysicsWorld2DSceneComponent extends Cy
     onUpdate(deltaTime) {
         this._updateFrame(deltaTime);
     }
-    get physicsWorld() {
-        return this._physicsWorld;
-    }
     _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();
     }
 };
@@ -94,10 +123,10 @@ __decorate([
     editable(Physics2DSettings)
 ], PhysicsWorld2DSceneComponent.prototype, "settings", null);
 __decorate([
-    serializable
+    stored
 ], PhysicsWorld2DSceneComponent.prototype, "_debug", void 0);
 __decorate([
-    serializable
+    stored
 ], PhysicsWorld2DSceneComponent.prototype, "_settings", void 0);
 PhysicsWorld2DSceneComponent = __decorate([
     cycloBuiltinClass('PhysicsWorld2DSceneComponent'),

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

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

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

@@ -64,23 +64,20 @@ export class PhysicsWorld2D {
         this._worldImpl.free();
         this._worldImpl = null;
     }
-    step(_deltaTime) {
-        const outdated = this._outDated;
-        this._outDated = false;
-        for (const component of this._physicsComponents) {
-            if (!component.enabled) {
-                continue;
-            }
-            invokeOnSyncTransforms(component, outdated, outdated);
-        }
-        this._worldImpl.step(this._eventQueue);
-        for (const component of this._physicsComponents) {
-            if (!component.enabled) {
-                continue;
-            }
-            invokeOnAfterStep(component);
+    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);
         }
-        this._emitEvents();
     }
     setOutdated() {
         this._outDated = true;
@@ -252,10 +249,10 @@ export class PhysicsWorld2D {
             destroy(wakeUp) {
                 this.removeCollider(wakeUp);
                 if (!world._physicsComponents.delete(component)) {
-                    logger.warn(`Collider ${component} not found in physics components`);
+                    logger.warn(`Collider ${component.name} not found in physics components`);
                 }
                 if (!world._linkManager.removeCollider(component)) {
-                    logger.warn(`Collider ${component} not found in link manager`);
+                    logger.warn(`Collider ${component.name} not found in link manager`);
                 }
             },
             get attachedRigidBody() {
@@ -301,6 +298,30 @@ export class PhysicsWorld2D {
     _physicsComponents = new Set();
     _outDated = false;
     _emitterForWillDestroy = new ManagedEventEmitter();
+    _step(stepFraction, isLastSubstep) {
+        const outdated = this._outDated;
+        this._outDated = false;
+        for (const component of this._physicsComponents) {
+            if (!component.enabled) {
+                continue;
+            }
+            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) {
+                continue;
+            }
+            invokeOnAfterStep(component);
+        }
+        this._emitEvents();
+    }
     _getTagBit(tag) {
         return this._tags[tag] ?? -1;
     }

package/lib/px2-impl.js

@@ -4,11 +4,9 @@ export { px2Impl };
 export const initializePx2Impl = (() => {
     let promise = null;
     return async () => {
-        if (!promise) {
-            promise = (async () => {
-                await px2Impl.__init__();
-            })();
-        }
+        promise ??= (async () => {
+            await px2Impl.__init__();
+        })();
         await promise;
     };
 })();

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

@@ -34,11 +34,13 @@ export declare class RigidBody2D extends PhysicsComponent2DBase {
     set rotation(value: number);
     get linearVelocity(): Vec2;
     set linearVelocity(value: Vec2);
+    get impl(): px2Impl.RigidBody | undefined;
     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;
     protected onAttachToWorld(world: PhysicsWorld2D): void;
     protected onDetachFromWorld(_world: PhysicsWorld2D): 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

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Transform2DComponent, TransformChangeFlagsObserver, TransformFlag } from '@cyclonium/core/2d';
-import { designType, editable, idem, requiresComponent, serializable } from '@cyclonium/core/legacy-decorator';
+import { designType, editable, idem, requiresComponent, stored } from '@cyclonium/core/legacy-decorator';
 import { Vec2 } from '@cyclonium/core/math/vec2';
 import { fromPx2ImplVec2, toPx2ImplVec2 } from './exchange.js';
 import { px2Impl } from './px2-impl.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";
@@ -133,6 +133,9 @@ let RigidBody2D = class RigidBody2D extends PhysicsComponent2DBase {
             }
         }
     }
+    get impl() {
+        return this._rigidBodyControlBlock?.impl;
+    }
     hasTag(tag) {
         return this._tags.includes(tag);
     }
@@ -141,14 +144,46 @@ 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() {
-        return this._rigidBodyControlBlock?.impl;
+    /** @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);
+        }
     }
     onDestroy() {
         super.onDestroy();
@@ -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);
@@ -355,19 +397,19 @@ __decorate([
     idem
 ], RigidBody2D.prototype, "linearVelocity", null);
 __decorate([
-    serializable
+    stored
 ], RigidBody2D.prototype, "_tags", void 0);
 __decorate([
-    serializable
+    stored
 ], RigidBody2D.prototype, "_type", void 0);
 __decorate([
-    serializable
+    stored
 ], RigidBody2D.prototype, "_ccd", void 0);
 __decorate([
-    serializable
+    stored
 ], RigidBody2D.prototype, "_gravityScale", void 0);
 __decorate([
-    serializable
+    stored
 ], RigidBody2D.prototype, "_collisionTargetTypeFilter", void 0);
 __decorate([
     requiresComponent(Transform2DComponent)

package/lib/scene-query-probe-2d.d.ts

@@ -84,10 +84,6 @@ export declare abstract class SceneQueryProbe2D extends PhysicsComponent2DBase {
     protected onAttachToWorld(_world: PhysicsWorld2D): void;
     protected onDetachFromWorld(_world: PhysicsWorld2D): void;
     protected onUpdate(): void;
-    private _getFilter;
-    private _createFilter;
-    private _invalidateFilter;
-    private _clearFilterCache;
     private _targetTags;
     private _dynamics;
     private _fixed;
@@ -98,5 +94,9 @@ export declare abstract class SceneQueryProbe2D extends PhysicsComponent2DBase {
     private _filterWorld;
     private _filterDirty;
     private get _transform();
+    private _getFilter;
+    private _createFilter;
+    private _invalidateFilter;
+    private _clearFilterCache;
 }
 //# sourceMappingURL=scene-query-probe-2d.d.ts.map

package/lib/scene-query-probe-2d.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { CCString } from 'cc';
 import { EDITOR_NOT_IN_PREVIEW } from 'cc/env';
 import { Transform2DComponent } from '@cyclonium/core/2d';
-import { editable, idem, requiresComponent, serializable } from '@cyclonium/core/legacy-decorator';
+import { editable, idem, requiresComponent, stored } from '@cyclonium/core/legacy-decorator';
 import { cycloBuiltinClass } from '@cyclonium/core/internal';
 import { Vec2 } from '@cyclonium/core/math/vec2';
 import { PhysicsComponent2DBase } from './physics-component-2d-base.js';
@@ -124,6 +124,7 @@ let SceneQueryProbe2D = class SceneQueryProbe2D extends PhysicsComponent2DBase {
         return this._transform.scale;
     }
     onAttachToWorld(_world) {
+        // Scene query probes do not allocate simulation objects.
     }
     onDetachFromWorld(_world) {
         this._clearFilterCache();
@@ -133,6 +134,16 @@ let SceneQueryProbe2D = class SceneQueryProbe2D extends PhysicsComponent2DBase {
             this.drawGizmo();
         }
     }
+    _targetTags = [];
+    _dynamics = true;
+    _fixed = true;
+    _kinematics = true;
+    _sensors = true;
+    _solids = true;
+    _filterCache = undefined;
+    _filterWorld = undefined;
+    _filterDirty = true;
+    get _transform() { return undefined; }
     _getFilter(world) {
         if (!this._filterCache || this._filterWorld !== world || this._filterDirty) {
             this._filterCache = this._createFilter(world);
@@ -161,16 +172,6 @@ let SceneQueryProbe2D = class SceneQueryProbe2D extends PhysicsComponent2DBase {
         this._filterWorld = undefined;
         this._filterDirty = true;
     }
-    _targetTags = [];
-    _dynamics = true;
-    _fixed = true;
-    _kinematics = true;
-    _sensors = true;
-    _solids = true;
-    _filterCache = undefined;
-    _filterWorld = undefined;
-    _filterDirty = true;
-    get _transform() { return undefined; }
 };
 __decorate([
     editable(CCString)
@@ -196,22 +197,22 @@ __decorate([
     idem
 ], SceneQueryProbe2D.prototype, "solids", null);
 __decorate([
-    serializable
+    stored
 ], SceneQueryProbe2D.prototype, "_targetTags", void 0);
 __decorate([
-    serializable
+    stored
 ], SceneQueryProbe2D.prototype, "_dynamics", void 0);
 __decorate([
-    serializable
+    stored
 ], SceneQueryProbe2D.prototype, "_fixed", void 0);
 __decorate([
-    serializable
+    stored
 ], SceneQueryProbe2D.prototype, "_kinematics", void 0);
 __decorate([
-    serializable
+    stored
 ], SceneQueryProbe2D.prototype, "_sensors", void 0);
 __decorate([
-    serializable
+    stored
 ], SceneQueryProbe2D.prototype, "_solids", void 0);
 __decorate([
     requiresComponent(Transform2DComponent)

package/lib/scene-query-probes/box-scene-query-probe-2d.d.ts

@@ -14,8 +14,8 @@ export declare class BoxSceneQueryProbe2D extends SceneQueryProbe2D {
     protected intersectWithWorld(world: PhysicsWorld2D, filter: SceneQueryFilter): Generator<import("../collider-2d.js").Collider2D, void, unknown>;
     protected sweepWithWorld(world: PhysicsWorld2D, transform: ShapeTransformDesc, direction: Vec2, maxDistance: number, opts: SceneQueryProbeSweepOptions, filter: SceneQueryFilter): import("../scene-query.js").ColliderShapeCastHit | undefined;
     protected drawGizmo(): void;
-    private _getScaledHalfExtents;
     private _halfExtents;
     private _scaledHalfExtents;
+    private _getScaledHalfExtents;
 }
 //# sourceMappingURL=box-scene-query-probe-2d.d.ts.map

package/lib/scene-query-probes/box-scene-query-probe-2d.js

@@ -4,7 +4,7 @@ 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 { editable, executeInEditMode, idem, serializable } from '@cyclonium/core/legacy-decorator';
+import { editable, executeInEditMode, idem, stored } from '@cyclonium/core/legacy-decorator';
 import { cycloBuiltinClass } from '@cyclonium/core/internal';
 import { Vec2 } from '@cyclonium/core/math/vec2';
 import { drawBoxSceneQueryProbe2DGizmo } from '#gizmo';
@@ -40,19 +40,19 @@ let BoxSceneQueryProbe2D = class BoxSceneQueryProbe2D extends SceneQueryProbe2D
     drawGizmo() {
         drawBoxSceneQueryProbe2DGizmo(this);
     }
+    _halfExtents = new Vec2(1, 1);
+    _scaledHalfExtents = new Vec2();
     _getScaledHalfExtents() {
         const scale = this.queryScale;
         return Vec2.set(this._scaledHalfExtents, this._halfExtents.x * scale.x, this._halfExtents.y * scale.y);
     }
-    _halfExtents = new Vec2(1, 1);
-    _scaledHalfExtents = new Vec2();
 };
 __decorate([
     editable,
     idem
 ], BoxSceneQueryProbe2D.prototype, "halfExtents", null);
 __decorate([
-    serializable
+    stored
 ], BoxSceneQueryProbe2D.prototype, "_halfExtents", void 0);
 BoxSceneQueryProbe2D = __decorate([
     cycloBuiltinClass('BoxSceneQueryProbe2D'),

package/lib/scene-query-probes/capsule-scene-query-probe-2d.d.ts

@@ -19,9 +19,9 @@ export declare class CapsuleSceneQueryProbe2D extends SceneQueryProbe2D {
     protected intersectWithWorld(world: PhysicsWorld2D, filter: SceneQueryFilter): Generator<import("../collider-2d.js").Collider2D, void, unknown>;
     protected sweepWithWorld(world: PhysicsWorld2D, transform: ShapeTransformDesc, direction: Vec2, maxDistance: number, opts: SceneQueryProbeSweepOptions, filter: SceneQueryFilter): import("../scene-query.js").ColliderShapeCastHit | undefined;
     protected drawGizmo(): void;
-    private _getUniformScale;
-    private _getScaledShape;
     private _radius;
     private _halfHeight;
+    private _getUniformScale;
+    private _getScaledShape;
 }
 //# sourceMappingURL=capsule-scene-query-probe-2d.d.ts.map

package/lib/scene-query-probes/capsule-scene-query-probe-2d.js

@@ -4,7 +4,7 @@ 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 { editable, executeInEditMode, idem, serializable } from '@cyclonium/core/legacy-decorator';
+import { editable, executeInEditMode, idem, stored } from '@cyclonium/core/legacy-decorator';
 import { cycloBuiltinClass } from '@cyclonium/core/internal';
 import { Vec2 } from '@cyclonium/core/math/vec2';
 import { drawCapsuleSceneQueryProbe2DGizmo } from '#gizmo';
@@ -57,6 +57,8 @@ let CapsuleSceneQueryProbe2D = class CapsuleSceneQueryProbe2D extends SceneQuery
     drawGizmo() {
         drawCapsuleSceneQueryProbe2DGizmo(this);
     }
+    _radius = 1;
+    _halfHeight = 1;
     _getUniformScale() {
         const scale = this.queryScale;
         if (scale.x !== scale.y) {
@@ -71,8 +73,6 @@ let CapsuleSceneQueryProbe2D = class CapsuleSceneQueryProbe2D extends SceneQuery
             radius: this._radius * scale,
         };
     }
-    _radius = 1;
-    _halfHeight = 1;
 };
 __decorate([
     editable({ min: 0 }),
@@ -83,10 +83,10 @@ __decorate([
     idem
 ], CapsuleSceneQueryProbe2D.prototype, "halfHeight", null);
 __decorate([
-    serializable
+    stored
 ], CapsuleSceneQueryProbe2D.prototype, "_radius", void 0);
 __decorate([
-    serializable
+    stored
 ], CapsuleSceneQueryProbe2D.prototype, "_halfHeight", void 0);
 CapsuleSceneQueryProbe2D = __decorate([
     cycloBuiltinClass('CapsuleSceneQueryProbe2D'),

package/lib/scene-query-probes/circle-scene-query-probe-2d.d.ts

@@ -14,7 +14,7 @@ export declare class CircleSceneQueryProbe2D extends SceneQueryProbe2D {
     protected intersectWithWorld(world: PhysicsWorld2D, filter: SceneQueryFilter): Generator<import("../collider-2d.js").Collider2D, void, unknown>;
     protected sweepWithWorld(world: PhysicsWorld2D, transform: ShapeTransformDesc, direction: Vec2, maxDistance: number, opts: SceneQueryProbeSweepOptions, filter: SceneQueryFilter): import("../scene-query.js").ColliderShapeCastHit | undefined;
     protected drawGizmo(): void;
-    private _getScaledRadius;
     private _radius;
+    private _getScaledRadius;
 }
 //# sourceMappingURL=circle-scene-query-probe-2d.d.ts.map

package/lib/scene-query-probes/circle-scene-query-probe-2d.js

@@ -4,7 +4,7 @@ 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 { editable, executeInEditMode, idem, serializable } from '@cyclonium/core/legacy-decorator';
+import { editable, executeInEditMode, idem, stored } from '@cyclonium/core/legacy-decorator';
 import { cycloBuiltinClass } from '@cyclonium/core/internal';
 import { Vec2 } from '@cyclonium/core/math/vec2';
 import { drawCircleSceneQueryProbe2DGizmo } from '#gizmo';
@@ -40,6 +40,7 @@ let CircleSceneQueryProbe2D = class CircleSceneQueryProbe2D extends SceneQueryPr
     drawGizmo() {
         drawCircleSceneQueryProbe2DGizmo(this);
     }
+    _radius = 1;
     _getScaledRadius() {
         const scale = this.queryScale;
         if (scale.x !== scale.y) {
@@ -47,14 +48,13 @@ let CircleSceneQueryProbe2D = class CircleSceneQueryProbe2D extends SceneQueryPr
         }
         return this._radius * scale.x;
     }
-    _radius = 1;
 };
 __decorate([
     editable({ min: 0 }),
     idem
 ], CircleSceneQueryProbe2D.prototype, "radius", null);
 __decorate([
-    serializable
+    stored
 ], CircleSceneQueryProbe2D.prototype, "_radius", void 0);
 CircleSceneQueryProbe2D = __decorate([
     cycloBuiltinClass('CircleSceneQueryProbe2D'),

package/lib/scene-query.d.ts

@@ -2,7 +2,6 @@ import { Vec2 } from '@cyclonium/core/math/vec2';
 import type { Collider2D } from './collider-2d.js';
 import { px2Impl } from './px2-impl.js';
 export declare class SceneQueryFilter {
-    constructor();
     get dynamics(): boolean;
     set dynamics(value: boolean);
     get fixed(): boolean;
@@ -13,9 +12,9 @@ export declare class SceneQueryFilter {
     set sensors(value: boolean);
     get solids(): boolean;
     set solids(value: boolean);
-    addTargetTag(tag: number): this;
     get _filterFlags_internal(): number;
     get _filterGroups_internal(): number;
+    addTargetTag(tag: number): this;
     private _filterGroupFilter;
     private _filterFlags;
     private _getIncludesFlag;

package/lib/scene-query.js

@@ -2,8 +2,6 @@ import { Vec2 } from '@cyclonium/core/math/vec2';
 import { px2Impl } from './px2-impl.js';
 import { fromPx2ImplVec2 } from './exchange.js';
 export class SceneQueryFilter {
-    constructor() {
-    }
     get dynamics() {
         return this._getIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_DYNAMIC);
     }
@@ -34,10 +32,6 @@ export class SceneQueryFilter {
     set solids(value) {
         this._setIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_SOLIDS, value);
     }
-    addTargetTag(tag) {
-        this._filterGroupFilter |= 1 << tag;
-        return this;
-    }
     get _filterFlags_internal() {
         return this._filterFlags;
     }
@@ -46,6 +40,10 @@ export class SceneQueryFilter {
         // return composeCollisionGroup(GROUP_MEMBERSHIP_ALLOW_SCENE_QUERY, this._filterGroupFilter);
         return composeCollisionGroup(0xFFFF, this._filterGroupFilter);
     }
+    addTargetTag(tag) {
+        this._filterGroupFilter |= 1 << tag;
+        return this;
+    }
     _filterGroupFilter = 0;
     _filterFlags = 0;
     _getIncludesFlag(flag) {

package/lib/wasm-binary-helper.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    source: void;
+    source: undefined;
     target: string;
 };
 export default _default;