@cyclonium/physics-2d 0.0.100

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

@@ -0,0 +1,223 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { 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 { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { PhysicsComponent2DBase } from './physics-component-2d-base.js';
+import { SceneQueryFilter } from './scene-query.js';
+/**
+ * Query-only 2D physics probe used for authoring reusable scene queries.
+ *
+ * It does not create a collider, participate in simulation, or emit contact events.
+ */
+let SceneQueryProbe2D = class SceneQueryProbe2D extends PhysicsComponent2DBase {
+    /**
+     * Physics tags this probe can hit.
+     *
+     * Tags are resolved through the current PhysicsWorld2D and cached until the filter config changes.
+     * Assign a new array to change tags; in-place mutations are not supported.
+     */
+    get targetTags() {
+        return this._targetTags;
+    }
+    set targetTags(value) {
+        this._targetTags = value.slice();
+        this._invalidateFilter();
+    }
+    /**
+     * Whether dynamic rigid bodies are included in this probe's queries.
+     */
+    get dynamics() {
+        return this._dynamics;
+    }
+    set dynamics(value) {
+        this._dynamics = value;
+        this._invalidateFilter();
+    }
+    /**
+     * Whether fixed rigid bodies are included in this probe's queries.
+     */
+    get fixed() {
+        return this._fixed;
+    }
+    set fixed(value) {
+        this._fixed = value;
+        this._invalidateFilter();
+    }
+    /**
+     * Whether kinematic rigid bodies are included in this probe's queries.
+     */
+    get kinematics() {
+        return this._kinematics;
+    }
+    set kinematics(value) {
+        this._kinematics = value;
+        this._invalidateFilter();
+    }
+    /**
+     * Whether sensor colliders are included in this probe's queries.
+     */
+    get sensors() {
+        return this._sensors;
+    }
+    set sensors(value) {
+        this._sensors = value;
+        this._invalidateFilter();
+    }
+    /**
+     * Whether solid colliders are included in this probe's queries.
+     */
+    get solids() {
+        return this._solids;
+    }
+    set solids(value) {
+        this._solids = value;
+        this._invalidateFilter();
+    }
+    /**
+     * Finds colliders overlapping this probe's current world transform and filter.
+     */
+    intersect() {
+        const world = this.world;
+        if (!world) {
+            return [];
+        }
+        return [...this.intersectWithWorld(world, this._getFilter(world))];
+    }
+    /**
+     * Casts this probe from its current world transform.
+     *
+     * `direction` is normalized internally; `maxDistance` defines the sweep length.
+     */
+    sweep(direction, maxDistance, opts = {}) {
+        return this.sweepFrom({
+            position: this.queryPosition,
+            rotation: this.queryRotation,
+        }, direction, maxDistance, opts);
+    }
+    /**
+     * Casts this probe from an explicit transform without moving the node.
+     *
+     * Useful for previous-to-current authority sweeps.
+     */
+    sweepFrom(transform, direction, maxDistance, opts = {}) {
+        const world = this.world;
+        if (!world) {
+            return;
+        }
+        return this.sweepWithWorld(world, transform, direction, maxDistance, opts, this._getFilter(world));
+    }
+    get queryPosition() {
+        return this._transform.position;
+    }
+    get queryRotation() {
+        return this._transform.rotation;
+    }
+    get queryScale() {
+        return this._transform.scale;
+    }
+    onAttachToWorld(_world) {
+    }
+    onDetachFromWorld(_world) {
+        this._clearFilterCache();
+    }
+    onUpdate() {
+        if (EDITOR_NOT_IN_PREVIEW) {
+            this.drawGizmo();
+        }
+    }
+    _getFilter(world) {
+        if (!this._filterCache || this._filterWorld !== world || this._filterDirty) {
+            this._filterCache = this._createFilter(world);
+            this._filterWorld = world;
+            this._filterDirty = false;
+        }
+        return this._filterCache;
+    }
+    _createFilter(world) {
+        const filter = new SceneQueryFilter();
+        filter.dynamics = this._dynamics;
+        filter.fixed = this._fixed;
+        filter.kinematics = this._kinematics;
+        filter.sensors = this._sensors;
+        filter.solids = this._solids;
+        for (const tag of this._targetTags) {
+            filter.addTargetTag(world.getTagId(tag));
+        }
+        return filter;
+    }
+    _invalidateFilter() {
+        this._filterDirty = true;
+    }
+    _clearFilterCache() {
+        this._filterCache = undefined;
+        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)
+], SceneQueryProbe2D.prototype, "targetTags", null);
+__decorate([
+    editable,
+    idem
+], SceneQueryProbe2D.prototype, "dynamics", null);
+__decorate([
+    editable,
+    idem
+], SceneQueryProbe2D.prototype, "fixed", null);
+__decorate([
+    editable,
+    idem
+], SceneQueryProbe2D.prototype, "kinematics", null);
+__decorate([
+    editable,
+    idem
+], SceneQueryProbe2D.prototype, "sensors", null);
+__decorate([
+    editable,
+    idem
+], SceneQueryProbe2D.prototype, "solids", null);
+__decorate([
+    serializable
+], SceneQueryProbe2D.prototype, "_targetTags", void 0);
+__decorate([
+    serializable
+], SceneQueryProbe2D.prototype, "_dynamics", void 0);
+__decorate([
+    serializable
+], SceneQueryProbe2D.prototype, "_fixed", void 0);
+__decorate([
+    serializable
+], SceneQueryProbe2D.prototype, "_kinematics", void 0);
+__decorate([
+    serializable
+], SceneQueryProbe2D.prototype, "_sensors", void 0);
+__decorate([
+    serializable
+], SceneQueryProbe2D.prototype, "_solids", void 0);
+__decorate([
+    requiresComponent(Transform2DComponent)
+], SceneQueryProbe2D.prototype, "_transform", null);
+SceneQueryProbe2D = __decorate([
+    cycloBuiltinClass({ abstract: true })
+], SceneQueryProbe2D);
+export { SceneQueryProbe2D };
+//# sourceMappingURL=scene-query-probe-2d.js.map

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

@@ -0,0 +1,21 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { SceneQueryProbe2D, type SceneQueryProbeSweepOptions } from '../scene-query-probe-2d.js';
+import type { SceneQueryFilter } from '../scene-query.js';
+import type { PhysicsWorld2D, ShapeTransformDesc } from '../physics-world-2d.js';
+/**
+ * Query-only probe that uses an oriented box shape.
+ */
+export declare class BoxSceneQueryProbe2D extends SceneQueryProbe2D {
+    /**
+     * Half-size of the query box before Transform2D scale is applied.
+     */
+    get halfExtents(): Vec2;
+    set halfExtents(value: Vec2);
+    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;
+}
+//# sourceMappingURL=box-scene-query-probe-2d.d.ts.map

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

@@ -0,0 +1,62 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { drawBoxSceneQueryProbe2DGizmo } from '#gizmo';
+import { SceneQueryProbe2D } from '../scene-query-probe-2d.js';
+/**
+ * Query-only probe that uses an oriented box shape.
+ */
+let BoxSceneQueryProbe2D = class BoxSceneQueryProbe2D extends SceneQueryProbe2D {
+    /**
+     * Half-size of the query box before Transform2D scale is applied.
+     */
+    get halfExtents() {
+        return this._halfExtents;
+    }
+    set halfExtents(value) {
+        Vec2.assign(this._halfExtents, value);
+    }
+    intersectWithWorld(world, filter) {
+        return world.intersectWithBox(this.queryPosition, this._getScaledHalfExtents(), filter, this.queryRotation);
+    }
+    sweepWithWorld(world, transform, direction, maxDistance, opts, filter) {
+        return world.castRect({
+            halfExtents: this._getScaledHalfExtents(),
+            position: transform.position,
+            rotation: transform.rotation,
+        }, {
+            ...opts,
+            direction,
+            maxDistance,
+            filter,
+        });
+    }
+    drawGizmo() {
+        drawBoxSceneQueryProbe2DGizmo(this);
+    }
+    _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
+], BoxSceneQueryProbe2D.prototype, "_halfExtents", void 0);
+BoxSceneQueryProbe2D = __decorate([
+    cycloBuiltinClass('BoxSceneQueryProbe2D'),
+    executeInEditMode
+], BoxSceneQueryProbe2D);
+export { BoxSceneQueryProbe2D };
+//# sourceMappingURL=box-scene-query-probe-2d.js.map

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

@@ -0,0 +1,27 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { SceneQueryProbe2D, type SceneQueryProbeSweepOptions } from '../scene-query-probe-2d.js';
+import type { SceneQueryFilter } from '../scene-query.js';
+import type { PhysicsWorld2D, ShapeTransformDesc } from '../physics-world-2d.js';
+/**
+ * Query-only probe that uses a vertical capsule shape.
+ */
+export declare class CapsuleSceneQueryProbe2D extends SceneQueryProbe2D {
+    /**
+     * Radius of the capsule caps before Transform2D scale is applied.
+     */
+    get radius(): number;
+    set radius(value: number);
+    /**
+     * Half length of the capsule center segment before Transform2D scale is applied.
+     */
+    get halfHeight(): number;
+    set halfHeight(value: number);
+    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;
+}
+//# sourceMappingURL=capsule-scene-query-probe-2d.d.ts.map

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

@@ -0,0 +1,96 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { drawCapsuleSceneQueryProbe2DGizmo } from '#gizmo';
+import { SceneQueryProbe2D } from '../scene-query-probe-2d.js';
+/**
+ * Query-only probe that uses a vertical capsule shape.
+ */
+let CapsuleSceneQueryProbe2D = class CapsuleSceneQueryProbe2D extends SceneQueryProbe2D {
+    /**
+     * Radius of the capsule caps before Transform2D scale is applied.
+     */
+    get radius() {
+        return this._radius;
+    }
+    set radius(value) {
+        this._radius = value;
+    }
+    /**
+     * Half length of the capsule center segment before Transform2D scale is applied.
+     */
+    get halfHeight() {
+        return this._halfHeight;
+    }
+    set halfHeight(value) {
+        this._halfHeight = value;
+    }
+    intersectWithWorld(world, filter) {
+        const shape = this._getScaledShape();
+        return world.intersectWithCapsule({
+            halfHeight: shape.halfHeight,
+            radius: shape.radius,
+            position: this.queryPosition,
+            rotation: this.queryRotation,
+        }, filter);
+    }
+    sweepWithWorld(world, transform, direction, maxDistance, opts, filter) {
+        const shape = this._getScaledShape();
+        return world.castCapsule({
+            halfHeight: shape.halfHeight,
+            radius: shape.radius,
+            position: transform.position,
+            rotation: transform.rotation,
+        }, {
+            ...opts,
+            direction,
+            maxDistance,
+            filter,
+        });
+    }
+    drawGizmo() {
+        drawCapsuleSceneQueryProbe2DGizmo(this);
+    }
+    _getUniformScale() {
+        const scale = this.queryScale;
+        if (scale.x !== scale.y) {
+            console.warn('CapsuleSceneQueryProbe2D should have uniform scale');
+        }
+        return scale.x;
+    }
+    _getScaledShape() {
+        const scale = this._getUniformScale();
+        return {
+            halfHeight: this._halfHeight * scale,
+            radius: this._radius * scale,
+        };
+    }
+    _radius = 1;
+    _halfHeight = 1;
+};
+__decorate([
+    editable({ min: 0 }),
+    idem
+], CapsuleSceneQueryProbe2D.prototype, "radius", null);
+__decorate([
+    editable({ min: 0 }),
+    idem
+], CapsuleSceneQueryProbe2D.prototype, "halfHeight", null);
+__decorate([
+    serializable
+], CapsuleSceneQueryProbe2D.prototype, "_radius", void 0);
+__decorate([
+    serializable
+], CapsuleSceneQueryProbe2D.prototype, "_halfHeight", void 0);
+CapsuleSceneQueryProbe2D = __decorate([
+    cycloBuiltinClass('CapsuleSceneQueryProbe2D'),
+    executeInEditMode
+], CapsuleSceneQueryProbe2D);
+export { CapsuleSceneQueryProbe2D };
+//# sourceMappingURL=capsule-scene-query-probe-2d.js.map

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

@@ -0,0 +1,20 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { SceneQueryProbe2D, type SceneQueryProbeSweepOptions } from '../scene-query-probe-2d.js';
+import type { SceneQueryFilter } from '../scene-query.js';
+import type { PhysicsWorld2D, ShapeTransformDesc } from '../physics-world-2d.js';
+/**
+ * Query-only probe that uses a circle shape.
+ */
+export declare class CircleSceneQueryProbe2D extends SceneQueryProbe2D {
+    /**
+     * Radius of the query circle before Transform2D scale is applied.
+     */
+    get radius(): number;
+    set radius(value: number);
+    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;
+}
+//# sourceMappingURL=circle-scene-query-probe-2d.d.ts.map

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

@@ -0,0 +1,64 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { drawCircleSceneQueryProbe2DGizmo } from '#gizmo';
+import { SceneQueryProbe2D } from '../scene-query-probe-2d.js';
+/**
+ * Query-only probe that uses a circle shape.
+ */
+let CircleSceneQueryProbe2D = class CircleSceneQueryProbe2D extends SceneQueryProbe2D {
+    /**
+     * Radius of the query circle before Transform2D scale is applied.
+     */
+    get radius() {
+        return this._radius;
+    }
+    set radius(value) {
+        this._radius = value;
+    }
+    intersectWithWorld(world, filter) {
+        return world.intersectWithCircle(this.queryPosition, this._getScaledRadius(), filter, this.queryRotation);
+    }
+    sweepWithWorld(world, transform, direction, maxDistance, opts, filter) {
+        return world.castCircle({
+            radius: this._getScaledRadius(),
+            position: transform.position,
+            rotation: transform.rotation,
+        }, {
+            ...opts,
+            direction,
+            maxDistance,
+            filter,
+        });
+    }
+    drawGizmo() {
+        drawCircleSceneQueryProbe2DGizmo(this);
+    }
+    _getScaledRadius() {
+        const scale = this.queryScale;
+        if (scale.x !== scale.y) {
+            console.warn('CircleSceneQueryProbe2D should have uniform scale');
+        }
+        return this._radius * scale.x;
+    }
+    _radius = 1;
+};
+__decorate([
+    editable({ min: 0 }),
+    idem
+], CircleSceneQueryProbe2D.prototype, "radius", null);
+__decorate([
+    serializable
+], CircleSceneQueryProbe2D.prototype, "_radius", void 0);
+CircleSceneQueryProbe2D = __decorate([
+    cycloBuiltinClass('CircleSceneQueryProbe2D'),
+    executeInEditMode
+], CircleSceneQueryProbe2D);
+export { CircleSceneQueryProbe2D };
+//# sourceMappingURL=circle-scene-query-probe-2d.js.map

package/lib/scene-query.d.ts

@@ -0,0 +1,67 @@
+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;
+    set fixed(value: boolean);
+    get kinematics(): boolean;
+    set kinematics(value: boolean);
+    get sensors(): boolean;
+    set sensors(value: boolean);
+    get solids(): boolean;
+    set solids(value: boolean);
+    addTargetTag(tag: number): this;
+    get _filterFlags_internal(): number;
+    get _filterGroups_internal(): number;
+    private _filterGroupFilter;
+    private _filterFlags;
+    private _getIncludesFlag;
+    private _setIncludesFlag;
+}
+export interface ShapeCastQueryOptions {
+    direction: Vec2;
+    maxDistance: number;
+    targetDistance?: number;
+    stopAtPenetration?: boolean;
+    filter?: SceneQueryFilter;
+    /**
+     * Colliders skipped by the shape cast, usually the querying object's own collider.
+     */
+    excludeColliders?: Iterable<Collider2D>;
+}
+export declare class ColliderShapeCastHit {
+    constructor(impl: px2Impl.ColliderShapeCastHit, startPosition: Vec2, direction: Vec2, collider: Collider2D);
+    get collider(): Collider2D;
+    get impl(): px2Impl.ColliderShapeCastHit;
+    get point(): Vec2;
+    get distance(): number;
+    get localPoint1(): Vec2;
+    get localPoint2(): Vec2;
+    get localNormal1(): Vec2;
+    get localNormal2(): Vec2;
+    private _impl;
+    private _startPosition;
+    private _direction;
+    private _collider;
+}
+export interface ShapeIntersectionQueryOptions {
+    filter?: SceneQueryFilter;
+}
+export declare class ColliderShapeIntersection {
+    private _collider;
+    constructor(_collider: Collider2D);
+    get collider(): Collider2D;
+}
+export declare class RayColliderIntersection {
+    constructor(collider: Collider2D, timeOfImpact: number, normal: Vec2);
+    get collider(): Collider2D;
+    get timeOfImpact(): number;
+    get normal(): Vec2;
+    private _collider;
+    private _timeOfImpact;
+    private _normal;
+}
+//# sourceMappingURL=scene-query.d.ts.map