@cyclonium/physics-2d 0.0.100

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

@@ -0,0 +1,391 @@
+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 { Transform2DComponent, TransformChangeFlagsObserver, TransformFlag } from '@cyclonium/core/2d';
+import { designType, editable, idem, requiresComponent, serializable } from '@cyclonium/core/legacy-decorator';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { fromPx2ImplVec2, toPx2ImplVec2 } from './exchange.js';
+import { px2Impl } from './px2-impl.js';
+import { PhysicsComponent2DBase } from './physics-component-2d-base.js';
+import { markEnum } from '@cyclonium/core/utils';
+import { createCollisionEventEmitter, ContactEventListenerFlagIndex } from './shared.js';
+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';
+export var RigidBody2DType;
+(function (RigidBody2DType) {
+    RigidBody2DType["fixed"] = "fixed";
+    RigidBody2DType["dynamic"] = "dynamic";
+    RigidBody2DType["kinematicPositionBased"] = "kinematicPositionBased";
+    RigidBody2DType["kinematicVelocityBased"] = "kinematicVelocityBased";
+})(RigidBody2DType || (RigidBody2DType = {}));
+markEnum(RigidBody2DType);
+var CollisionTargetTypeFilterIndex;
+(function (CollisionTargetTypeFilterIndex) {
+    CollisionTargetTypeFilterIndex[CollisionTargetTypeFilterIndex["fixed"] = 0] = "fixed";
+    CollisionTargetTypeFilterIndex[CollisionTargetTypeFilterIndex["dynamic"] = 1] = "dynamic";
+    CollisionTargetTypeFilterIndex[CollisionTargetTypeFilterIndex["kinematic"] = 2] = "kinematic";
+})(CollisionTargetTypeFilterIndex || (CollisionTargetTypeFilterIndex = {}));
+const defaultBodyType = RigidBody2DType.dynamic;
+function getDefaultCollisionTargetTypeFilterOf(bodyType) {
+    return bodyType === RigidBody2DType.dynamic
+        ? ((1 << CollisionTargetTypeFilterIndex.dynamic) | (1 << CollisionTargetTypeFilterIndex.fixed) | (1 << CollisionTargetTypeFilterIndex.kinematic))
+        : 0;
+}
+const SYNC_POSITION_THRESHOLD = 1e-6;
+const SYNC_ROTATION_THRESHOLD = 1e-6;
+let RigidBody2D = class RigidBody2D extends PhysicsComponent2DBase {
+    onContactBegin = createCollisionEventEmitter((hasAnyListener) => {
+        this._updateListenerFlag(ContactEventListenerFlagIndex.begin, hasAnyListener);
+    });
+    onContactStay = createCollisionEventEmitter((hasAnyListener) => {
+        this._updateListenerFlag(ContactEventListenerFlagIndex.stay, hasAnyListener);
+    });
+    onContactEnd = createCollisionEventEmitter((hasAnyListener) => {
+        this._updateListenerFlag(ContactEventListenerFlagIndex.end, hasAnyListener);
+    });
+    get tags() {
+        return this._tags;
+    }
+    set tags(value) {
+        this._tags = value.slice();
+        this._rigidBodyControlBlock?.setTags(value);
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+        if (EDITOR_NOT_IN_PREVIEW) {
+            this._collisionTargetTypeFilter = getDefaultCollisionTargetTypeFilterOf(value);
+        }
+        this._updateActiveCollisionTypes();
+        this._rigidBodyControlBlock?.impl.setBodyType(toPx2ImplRigidBodyType(value), true);
+    }
+    get collisionWithDynamic() {
+        return this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.dynamic);
+    }
+    set collisionWithDynamic(value) {
+        this._setCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.dynamic, value);
+    }
+    get collisionWithFixed() {
+        return this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.fixed);
+    }
+    set collisionWithFixed(value) {
+        this._setCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.fixed, value);
+    }
+    get collisionWithKinematic() {
+        return this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.kinematic);
+    }
+    set collisionWithKinematic(value) {
+        this._setCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.kinematic, value);
+    }
+    get ccd() {
+        return this._ccd;
+    }
+    set ccd(value) {
+        this._ccd = value;
+        this._rigidBodyControlBlock?.impl.enableCcd(value);
+    }
+    get gravityScale() {
+        return this._gravityScale;
+    }
+    set gravityScale(value) {
+        this._gravityScale = value;
+        this._rigidBodyControlBlock?.impl.setGravityScale(value, true);
+    }
+    get position() {
+        return this._physicsPosition;
+    }
+    set position(value) {
+        this._setPhysicsPosition(value);
+    }
+    get rotation() {
+        return this._physicsRotation;
+    }
+    set rotation(value) {
+        this._setPhysicsRotation(to0ToPI2(value));
+    }
+    get linearVelocity() {
+        if (this._rigidBodyControlBlock) {
+            return fromPx2ImplVec2(this._rigidBodyControlBlock.impl.linvel(), this._linearVelocity);
+        }
+        else {
+            return this._linearVelocity.set(0, 0);
+        }
+    }
+    set linearVelocity(value) {
+        Vec2.assign(this._linearVelocity, value);
+        switch (this._type) {
+            default:
+                break;
+            case RigidBody2DType.dynamic:
+            case RigidBody2DType.kinematicVelocityBased: {
+                if (this._rigidBodyControlBlock) {
+                    this._rigidBodyControlBlock.impl.setLinvel(toPx2ImplVec2(value), true);
+                }
+                break;
+            }
+        }
+    }
+    hasTag(tag) {
+        return this._tags.includes(tag);
+    }
+    addTag(tag) {
+        if (!this._tags.includes(tag)) {
+            this._tags.push(tag);
+        }
+    }
+    setNextKinematicPosition(position) {
+        this._rigidBodyControlBlock?.impl.setNextKinematicTranslation(position);
+    }
+    setNextKinematicRotation(rotation) {
+        this._rigidBodyControlBlock?.impl.setNextKinematicRotation(rotation);
+    }
+    get impl() {
+        return this._rigidBodyControlBlock?.impl;
+    }
+    onDestroy() {
+        super.onDestroy();
+        this._destroyImplBody();
+    }
+    onAttachToWorld(world) {
+        const transform = this._transform;
+        this._transformChangeFlagsObserver.observe(transform);
+        this._physicsPosition.copyFrom(transform.position);
+        this._physicsRotation = transform.rotation;
+        const desc = new px2Impl.RigidBodyDesc(toPx2ImplRigidBodyType(this._type))
+            .setEnabled(this.enabled)
+            .setTranslation(this._physicsPosition.x, this._physicsPosition.y)
+            .setRotation(this._physicsRotation)
+            .setCcdEnabled(this._ccd)
+            .setLinvel(this._linearVelocity.x, this._linearVelocity.y)
+            .setGravityScale(this._gravityScale);
+        const body = world._createRigidBody(this, desc);
+        body.setTags(this._tags);
+        this._rigidBodyControlBlock = body;
+        this._updateActiveCollisionTypes();
+        body.impl.setEnabled(this.enabledInHierarchy);
+    }
+    onDetachFromWorld(_world) {
+        this._destroyImplBody();
+    }
+    onEnabled() {
+        super.onEnabled();
+        this._rigidBodyControlBlock?.impl.setEnabled(true);
+    }
+    onDisabled() {
+        this._rigidBodyControlBlock?.impl.setEnabled(false);
+    }
+    onStart() {
+        super.onStart();
+    }
+    onSyncTransforms(forceTransform, _forceScale) {
+        this._syncToPhysics(forceTransform);
+    }
+    onAfterPhysicsStep() {
+        this._syncFromPhysics();
+    }
+    _rigidBodyControlBlock = null;
+    _tags = [];
+    _type = defaultBodyType;
+    _ccd = false;
+    _gravityScale = 1.0;
+    _collisionTargetTypeFilter = getDefaultCollisionTargetTypeFilterOf(defaultBodyType);
+    _physicsPosition = new Vec2();
+    _physicsRotation = 0.0;
+    _linearVelocity = new Vec2();
+    _listenerFlags = 0;
+    _transformChangeFlagsObserver = new TransformChangeFlagsObserver();
+    get _transform() { return undefined; }
+    _getCollisionTargetTypeFilter(filterIndex) {
+        return !!(this._collisionTargetTypeFilter & (1 << filterIndex));
+    }
+    _setCollisionTargetTypeFilter(filterIndex, value) {
+        if (value) {
+            this._collisionTargetTypeFilter |= 1 << filterIndex;
+        }
+        else {
+            this._collisionTargetTypeFilter &= ~(1 << filterIndex);
+        }
+        this._updateActiveCollisionTypes();
+    }
+    _updateActiveCollisionTypes() {
+        let combined = 0;
+        switch (this._type) {
+            case RigidBody2DType.dynamic:
+                if (this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.dynamic)) {
+                    combined |= px2Impl.ActiveCollisionTypes.DYNAMIC_DYNAMIC;
+                }
+                if (this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.fixed)) {
+                    combined |= px2Impl.ActiveCollisionTypes.DYNAMIC_FIXED;
+                }
+                if (this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.kinematic)) {
+                    combined |= px2Impl.ActiveCollisionTypes.DYNAMIC_KINEMATIC;
+                }
+                break;
+            case RigidBody2DType.fixed:
+                if (this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.dynamic)) {
+                    combined |= px2Impl.ActiveCollisionTypes.DYNAMIC_FIXED;
+                }
+                if (this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.fixed)) {
+                    combined |= px2Impl.ActiveCollisionTypes.FIXED_FIXED;
+                }
+                if (this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.kinematic)) {
+                    combined |= px2Impl.ActiveCollisionTypes.KINEMATIC_FIXED;
+                }
+                break;
+            case RigidBody2DType.kinematicPositionBased:
+            case RigidBody2DType.kinematicVelocityBased:
+                if (this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.dynamic)) {
+                    combined |= px2Impl.ActiveCollisionTypes.DYNAMIC_KINEMATIC;
+                }
+                if (this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.fixed)) {
+                    combined |= px2Impl.ActiveCollisionTypes.KINEMATIC_FIXED;
+                }
+                if (this._getCollisionTargetTypeFilter(CollisionTargetTypeFilterIndex.kinematic)) {
+                    combined |= px2Impl.ActiveCollisionTypes.KINEMATIC_KINEMATIC;
+                }
+                break;
+        }
+        this._rigidBodyControlBlock?.setActiveCollisionTypes(combined);
+    }
+    _updateListenerFlag(flagIndex, hasAny) {
+        if (hasAny) {
+            this._listenerFlags |= 1 << flagIndex;
+        }
+        else {
+            this._listenerFlags &= ~(1 << flagIndex);
+        }
+        if (this._rigidBodyControlBlock) {
+            this._rigidBodyControlBlock.enableCollisionEvents(this._listenerFlags !== 0);
+        }
+    }
+    _destroyImplBody() {
+        const impl = this._rigidBodyControlBlock?.impl;
+        const world = this.world;
+        if (impl) {
+            world?._removeRigidBody(impl);
+        }
+        this._rigidBodyControlBlock = null;
+        this._physicsPosition.set(0, 0);
+        this._physicsRotation = 0.0;
+    }
+    _setPhysicsPosition(position) {
+        this._physicsPosition.copyFrom(position);
+        this._rigidBodyControlBlock?.impl.setTranslation(toPx2ImplVec2(position), true);
+    }
+    _setPhysicsRotation(rotation) {
+        this._physicsRotation = rotation;
+        this._rigidBodyControlBlock?.impl.setRotation(rotation, true);
+    }
+    _syncToPhysics(outdated) {
+        const implBody = this._rigidBodyControlBlock?.impl;
+        if (!implBody) {
+            return;
+        }
+        const transform = this._transform;
+        const changeFlags = this._transformChangeFlagsObserver.sync();
+        if (outdated || changeFlags & TransformFlag.position) {
+            if (!Vec2.equals(transform.position, this._physicsPosition, SYNC_POSITION_THRESHOLD)) {
+                this._setPhysicsPosition(transform.position);
+            }
+        }
+        if (outdated || changeFlags & TransformFlag.rotation) {
+            if (!approxEqual(transform.rotation, this._physicsRotation, SYNC_ROTATION_THRESHOLD)) {
+                this._setPhysicsRotation(transform.rotation);
+            }
+        }
+    }
+    _syncFromPhysics() {
+        if (this._type === RigidBody2DType.fixed) {
+            return;
+        }
+        const implBody = this._rigidBodyControlBlock?.impl;
+        if (!implBody) {
+            return;
+        }
+        const transform = this._transform;
+        const pxPosition = implBody.translation();
+        const positionCache = fromPx2ImplVec2(pxPosition, this._physicsPosition);
+        if (!Vec2.equals(positionCache, transform.position, SYNC_POSITION_THRESHOLD)) {
+            transform.position = positionCache;
+        }
+        const pxRotation = to0ToPI2(implBody.rotation());
+        this._physicsRotation = pxRotation;
+        if (!approxEqual(pxRotation, transform.rotation, SYNC_ROTATION_THRESHOLD)) {
+            transform.rotation = pxRotation;
+        }
+    }
+};
+__decorate([
+    editable(CCString)
+], RigidBody2D.prototype, "tags", null);
+__decorate([
+    designType(RigidBody2DType),
+    idem
+], RigidBody2D.prototype, "type", null);
+__decorate([
+    editable
+], RigidBody2D.prototype, "collisionWithDynamic", null);
+__decorate([
+    editable
+], RigidBody2D.prototype, "collisionWithFixed", null);
+__decorate([
+    editable
+], RigidBody2D.prototype, "collisionWithKinematic", null);
+__decorate([
+    editable,
+    idem
+], RigidBody2D.prototype, "ccd", null);
+__decorate([
+    editable({
+        visible() {
+            return this._type === RigidBody2DType.dynamic;
+        },
+    }),
+    idem
+], RigidBody2D.prototype, "gravityScale", null);
+__decorate([
+    idem
+], RigidBody2D.prototype, "linearVelocity", null);
+__decorate([
+    serializable
+], RigidBody2D.prototype, "_tags", void 0);
+__decorate([
+    serializable
+], RigidBody2D.prototype, "_type", void 0);
+__decorate([
+    serializable
+], RigidBody2D.prototype, "_ccd", void 0);
+__decorate([
+    serializable
+], RigidBody2D.prototype, "_gravityScale", void 0);
+__decorate([
+    serializable
+], RigidBody2D.prototype, "_collisionTargetTypeFilter", void 0);
+__decorate([
+    requiresComponent(Transform2DComponent)
+], RigidBody2D.prototype, "_transform", null);
+RigidBody2D = __decorate([
+    cycloBuiltinClass('RigidBody2D')
+], RigidBody2D);
+export { RigidBody2D };
+function toPx2ImplRigidBodyType(type) {
+    switch (type) {
+        case RigidBody2DType.fixed:
+            return px2Impl.RigidBodyType.Fixed;
+        case RigidBody2DType.dynamic:
+            return px2Impl.RigidBodyType.Dynamic;
+        case RigidBody2DType.kinematicPositionBased:
+            return px2Impl.RigidBodyType.KinematicPositionBased;
+        case RigidBody2DType.kinematicVelocityBased:
+            return px2Impl.RigidBodyType.KinematicVelocityBased;
+    }
+}
+//# sourceMappingURL=rigid-body-2d.js.map

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

@@ -0,0 +1,102 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { PhysicsComponent2DBase } from './physics-component-2d-base.js';
+import { SceneQueryFilter, type ColliderShapeCastHit } from './scene-query.js';
+import type { Collider2D } from './collider-2d.js';
+import type { PhysicsWorld2D, ShapeTransformDesc } from './physics-world-2d.js';
+/**
+ * Options applied when a SceneQueryProbe2D performs a shape cast.
+ */
+export interface SceneQueryProbeSweepOptions {
+    /**
+     * The allowed distance between the swept shape and a hit at the target position.
+     */
+    targetDistance?: number;
+    /**
+     * Whether the sweep should stop immediately when the start shape already overlaps a collider.
+     */
+    stopAtPenetration?: boolean;
+    /**
+     * Colliders skipped by the sweep, usually the querying object's own collider.
+     */
+    excludeColliders?: Iterable<Collider2D>;
+}
+/**
+ * Query-only 2D physics probe used for authoring reusable scene queries.
+ *
+ * It does not create a collider, participate in simulation, or emit contact events.
+ */
+export declare abstract 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(): readonly string[];
+    set targetTags(value: readonly string[]);
+    /**
+     * Whether dynamic rigid bodies are included in this probe's queries.
+     */
+    get dynamics(): boolean;
+    set dynamics(value: boolean);
+    /**
+     * Whether fixed rigid bodies are included in this probe's queries.
+     */
+    get fixed(): boolean;
+    set fixed(value: boolean);
+    /**
+     * Whether kinematic rigid bodies are included in this probe's queries.
+     */
+    get kinematics(): boolean;
+    set kinematics(value: boolean);
+    /**
+     * Whether sensor colliders are included in this probe's queries.
+     */
+    get sensors(): boolean;
+    set sensors(value: boolean);
+    /**
+     * Whether solid colliders are included in this probe's queries.
+     */
+    get solids(): boolean;
+    set solids(value: boolean);
+    /**
+     * Finds colliders overlapping this probe's current world transform and filter.
+     */
+    intersect(): Collider2D[];
+    /**
+     * Casts this probe from its current world transform.
+     *
+     * `direction` is normalized internally; `maxDistance` defines the sweep length.
+     */
+    sweep(direction: Vec2, maxDistance: number, opts?: SceneQueryProbeSweepOptions): ColliderShapeCastHit | undefined;
+    /**
+     * Casts this probe from an explicit transform without moving the node.
+     *
+     * Useful for previous-to-current authority sweeps.
+     */
+    sweepFrom(transform: ShapeTransformDesc, direction: Vec2, maxDistance: number, opts?: SceneQueryProbeSweepOptions): ColliderShapeCastHit | undefined;
+    protected get queryPosition(): Vec2;
+    protected get queryRotation(): number;
+    protected get queryScale(): Vec2;
+    protected abstract intersectWithWorld(world: PhysicsWorld2D, filter: SceneQueryFilter): Iterable<Collider2D>;
+    protected abstract sweepWithWorld(world: PhysicsWorld2D, transform: ShapeTransformDesc, direction: Vec2, maxDistance: number, opts: SceneQueryProbeSweepOptions, filter: SceneQueryFilter): ColliderShapeCastHit | undefined;
+    protected abstract drawGizmo(): void;
+    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;
+    private _kinematics;
+    private _sensors;
+    private _solids;
+    private _filterCache;
+    private _filterWorld;
+    private _filterDirty;
+    private get _transform();
+}
+//# sourceMappingURL=scene-query-probe-2d.d.ts.map