@cyclonium/physics-2d 0.0.100

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

@@ -0,0 +1,53 @@
+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 { Asset } 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;
+    get tags() {
+        return this._tags;
+    }
+    get tags_editor() {
+        return this._tags;
+    }
+    set tags_editor(value) {
+        this._tags = { ...value };
+    }
+    get collisionMatrix() {
+        return this._collisionMatrix;
+    }
+    findTagIndex(tag) {
+        return this._tags[tag] ?? -1;
+    }
+    _tags = {};
+    _collisionMatrix = new CollisionMatrix();
+};
+__decorate([
+    serializable,
+    editable
+], Physics2DSettings.prototype, "fps", void 0);
+__decorate([
+    editable,
+    dumpRaw
+], Physics2DSettings.prototype, "tags_editor", null);
+__decorate([
+    editable
+], Physics2DSettings.prototype, "collisionMatrix", null);
+__decorate([
+    serializable
+], Physics2DSettings.prototype, "_tags", void 0);
+__decorate([
+    serializable
+], Physics2DSettings.prototype, "_collisionMatrix", void 0);
+Physics2DSettings = __decorate([
+    cycloBuiltinClass('Physics2DSettings')
+], Physics2DSettings);
+export { Physics2DSettings };
+//# sourceMappingURL=physics-2d-settings.js.map

package/lib/physics-component-2d-base.d.ts

@@ -0,0 +1,22 @@
+import { CycloComponent } from '@cyclonium/core/framework';
+import type { PhysicsWorld2D } from './physics-world-2d.js';
+export declare const invokeOnSyncTransforms: (component: PhysicsComponent2DBase, forceTransform: boolean, forceScale: boolean) => void;
+export declare const invokeOnAfterStep: (component: PhysicsComponent2DBase) => void;
+export declare abstract class PhysicsComponent2DBase extends CycloComponent {
+    protected get world(): PhysicsWorld2D | null;
+    protected abstract onAttachToWorld(world: PhysicsWorld2D): void;
+    protected abstract onDetachFromWorld(world: PhysicsWorld2D): void;
+    protected onSyncTransforms(_forceTransform: boolean, _forceScale: boolean): void;
+    protected onAfterPhysicsStep(): void;
+    protected onAwake(): void;
+    protected onStart(): void;
+    protected onDestroy(): void;
+    protected onEnabled(): void;
+    private _physicsWorld;
+    private _firstEnabled;
+    private _attached;
+    private _handleAncestorChange;
+    private _tryAttach;
+    private _tryDetach;
+}
+//# sourceMappingURL=physics-component-2d-base.d.ts.map

package/lib/physics-component-2d-base.js

@@ -0,0 +1,85 @@
+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 { Node } from 'cc';
+import { CycloComponent } from '@cyclonium/core/framework';
+import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { getPhysicsWorld } from './physics-world-registry.js';
+export const invokeOnSyncTransforms = (component, forceTransform, forceScale) => {
+    // @ts-expect-error protected hook invoker
+    return component.onSyncTransforms(forceTransform, forceScale);
+};
+export const invokeOnAfterStep = (component) => {
+    // @ts-expect-error protected hook invoker
+    return component.onAfterPhysicsStep();
+};
+let PhysicsComponent2DBase = class PhysicsComponent2DBase extends CycloComponent {
+    get world() {
+        return this._physicsWorld;
+    }
+    onSyncTransforms(_forceTransform, _forceScale) { }
+    onAfterPhysicsStep() { }
+    onAwake() {
+        if (!this._attached) {
+            this._tryAttach();
+        }
+    }
+    onStart() {
+        if (!this._attached) {
+            this._tryAttach();
+        }
+    }
+    onDestroy() {
+        super.onDestroy();
+        this._tryDetach();
+    }
+    onEnabled() {
+        if (!this._firstEnabled) {
+            return;
+        }
+        this._firstEnabled = false;
+        this.node.on(Node.EventType.PARENT_CHANGED, this._handleAncestorChange, this);
+        this._tryAttach();
+    }
+    _physicsWorld = null;
+    _firstEnabled = true;
+    _attached = false;
+    _handleAncestorChange() {
+        if (this.node) {
+            this._tryAttach();
+        }
+        else {
+            this._tryDetach();
+        }
+    }
+    _tryAttach() {
+        const node = this.node;
+        const physicsWorld = getPhysicsWorld(node.scene);
+        if (physicsWorld === this._physicsWorld) {
+            return;
+        }
+        this._tryDetach();
+        if (physicsWorld) {
+            this._physicsWorld = physicsWorld;
+            this._attached = true;
+            this.onAttachToWorld(physicsWorld);
+            physicsWorld.listenersOnWillDestroy.add(() => this._tryDetach(), { signal: this.destroyingSignal });
+        }
+    }
+    _tryDetach() {
+        if (!this._physicsWorld) {
+            return;
+        }
+        this._attached = false;
+        this.onDetachFromWorld(this._physicsWorld);
+        this._physicsWorld = null;
+    }
+};
+PhysicsComponent2DBase = __decorate([
+    cycloBuiltinClass({ abstract: true })
+], PhysicsComponent2DBase);
+export { PhysicsComponent2DBase };
+//# sourceMappingURL=physics-component-2d-base.js.map

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

@@ -0,0 +1,20 @@
+import { CycloComponent } from '@cyclonium/core/framework';
+import { PhysicsWorld2D } from './physics-world-2d.js';
+import { Physics2DSettings } from './physics-2d-settings.js';
+export declare class PhysicsWorld2DSceneComponent extends CycloComponent {
+    get debug(): boolean;
+    set debug(v: boolean);
+    get settings(): Physics2DSettings | null;
+    set settings(value: Physics2DSettings | null);
+    protected onAwake(): void;
+    protected onDestroy(): void;
+    protected onUpdate(deltaTime: number): void;
+    get physicsWorld(): PhysicsWorld2D | null;
+    private _physicsWorld;
+    private _physicsDebugger;
+    private _lastUpdateFrame;
+    private _debug;
+    private _settings;
+    private _updateFrame;
+}
+//# sourceMappingURL=physics-world-2d-scene-component.d.ts.map

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

@@ -0,0 +1,107 @@
+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 { 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 { director } from 'cc';
+import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { Physics2DSettings } from './physics-2d-settings.js';
+let PhysicsWorld2DSceneComponent = class PhysicsWorld2DSceneComponent extends CycloComponent {
+    get debug() {
+        return this._debug;
+    }
+    set debug(v) {
+        this._debug = v;
+        if (this._physicsDebugger) {
+            this._physicsDebugger.destroy();
+            this._physicsDebugger = undefined;
+        }
+        if (v && this._physicsWorld) {
+            this._physicsDebugger = new Physics2DDebugger(this._physicsWorld.impl, this.node.scene);
+        }
+    }
+    get settings() {
+        return this._settings;
+    }
+    set settings(value) {
+        this._settings = value;
+    }
+    onAwake() {
+        if (!EDITOR_NOT_IN_PREVIEW) {
+            const settings = this._settings ?? new Physics2DSettings();
+            this._physicsWorld = new PhysicsWorld2D({
+                scene: this.node.scene,
+                tags: settings.tags,
+                collisionMatrix: settings.collisionMatrix,
+                solverMatrix: settings.collisionMatrix,
+            });
+            if (this._debug) {
+                this._physicsDebugger = new Physics2DDebugger(this._physicsWorld.impl, this.node.scene);
+            }
+            // addFrameTask({
+            //   fn: this._updateFrame,
+            //   thisArg: this,
+            //   priority: TaskPriority.after(TaskPriority.predefined.componentsLateUpdate),
+            // });
+        }
+    }
+    onDestroy() {
+        if (!EDITOR_NOT_IN_PREVIEW) {
+            this._physicsDebugger?.destroy();
+            this._physicsDebugger = undefined;
+            this._physicsWorld?.destroy();
+            this._physicsWorld = null;
+        }
+    }
+    onUpdate(deltaTime) {
+        this._updateFrame(deltaTime);
+    }
+    get physicsWorld() {
+        return this._physicsWorld;
+    }
+    _physicsWorld = null;
+    _physicsDebugger = undefined;
+    _lastUpdateFrame = -1;
+    _debug = false;
+    _settings = null;
+    _updateFrame(_deltaTime) {
+        const world = this._physicsWorld;
+        if (!world) {
+            return;
+        }
+        const syncedFrame = ++this._lastUpdateFrame;
+        const actualFrame = director.getTotalFrames();
+        if (syncedFrame !== actualFrame) {
+            this._lastUpdateFrame = actualFrame;
+            world.setOutdated();
+        }
+        world.step(1 / 60);
+        this._physicsDebugger?.render();
+    }
+};
+__decorate([
+    editable,
+    idem
+], PhysicsWorld2DSceneComponent.prototype, "debug", null);
+__decorate([
+    editable(Physics2DSettings)
+], PhysicsWorld2DSceneComponent.prototype, "settings", null);
+__decorate([
+    serializable
+], PhysicsWorld2DSceneComponent.prototype, "_debug", void 0);
+__decorate([
+    serializable
+], PhysicsWorld2DSceneComponent.prototype, "_settings", void 0);
+PhysicsWorld2DSceneComponent = __decorate([
+    cycloBuiltinClass('PhysicsWorld2DSceneComponent'),
+    executionOrder(PredefinedExecutionOrder.physics)
+], PhysicsWorld2DSceneComponent);
+export { PhysicsWorld2DSceneComponent };
+//# sourceMappingURL=physics-world-2d-scene-component.js.map

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

@@ -0,0 +1,103 @@
+import { Scene } from 'cc';
+import type { Collider2D } from './collider-2d.js';
+import { CollisionMatrix } from './collision-matrix.js';
+import { px2Impl } from './px2-impl.js';
+import { RigidBody2D } from './rigid-body-2d.js';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { Ray2D } from '@cyclonium/core/math/ray';
+import { ColliderShapeCastHit, RayColliderIntersection, type SceneQueryFilter, type ShapeCastQueryOptions } from './scene-query.js';
+export declare class RaycastResult {
+    constructor(ray: Ray2D, collider: Collider2D, distance: number);
+    get collider(): Collider2D;
+    get distance(): number;
+    get position(): Vec2;
+    private _ray;
+    private _collider;
+    private _distance;
+}
+export interface CircleShapeDesc {
+    radius: number;
+}
+export interface CapsuleShapeDesc {
+    halfHeight: number;
+    radius: number;
+}
+export interface RectShapeDesc {
+    halfExtents: Vec2;
+}
+export interface ShapeTransformDesc {
+    position: Vec2;
+    rotation?: number;
+}
+export declare class PhysicsWorld2D {
+    static of(scene: Scene): PhysicsWorld2D;
+    static ofUndefined(scene: Scene): PhysicsWorld2D | undefined;
+    constructor({ scene, tags, collisionMatrix, solverMatrix, }: {
+        scene: Scene;
+        tags: Record<string, number>;
+        collisionMatrix: CollisionMatrix;
+        solverMatrix: CollisionMatrix;
+    });
+    get listenersOnWillDestroy(): import("@cyclonium/event").EventListenerRegistry<[]>;
+    get impl(): px2Impl.World;
+    destroy(): void;
+    step(_deltaTime: number): void;
+    setOutdated(): void;
+    getTagId(tag: string): number;
+    intersectionWithPoint(point: Vec2, filter: SceneQueryFilter): Generator<Collider2D, void, unknown>;
+    intersectionWithCollider(collider: Collider2D, filter: SceneQueryFilter): Generator<Collider2D, void, unknown>;
+    intersectWithCircle(center: Vec2, radius: number, filter: SceneQueryFilter, rotation?: number): Generator<Collider2D, void, unknown>;
+    intersectWithBox(center: Vec2, halfExtents: Vec2, filter: SceneQueryFilter, rotation?: number): Generator<Collider2D, void, unknown>;
+    /**
+     * Finds colliders overlapping a capsule shape.
+     */
+    intersectWithCapsule(capsule: CapsuleShapeDesc & ShapeTransformDesc, filter: SceneQueryFilter): Generator<Collider2D, void, unknown>;
+    intersectWithRay(ray: Ray2D, maxDistance: number, filter: SceneQueryFilter): Generator<RayColliderIntersection, void, unknown>;
+    castRay(ray: Ray2D, maxDistance: number, filter: SceneQueryFilter): RaycastResult | undefined;
+    castCircle(circle: CircleShapeDesc & ShapeTransformDesc, opts: ShapeCastQueryOptions): ColliderShapeCastHit | undefined;
+    castRect(rect: RectShapeDesc & ShapeTransformDesc, opts: ShapeCastQueryOptions): ColliderShapeCastHit | undefined;
+    castCapsule(capsule: CapsuleShapeDesc & ShapeTransformDesc, opts: ShapeCastQueryOptions): ColliderShapeCastHit | undefined;
+    /**
+     * Pushes current scene graph transforms to the physics backend without stepping simulation.
+     */
+    syncTransforms(): void;
+    _createRigidBody(component: RigidBody2D, desc: px2Impl.RigidBodyDesc): RigidBody2DControlBlock;
+    _removeRigidBody(impl: px2Impl.RigidBody): void;
+    _addColliderHandle(component: Collider2D): Collider2DHandle;
+    _getCollider(impl: px2Impl.Collider): Collider2D | undefined;
+    getColliderWithWarn_internal(impl: px2Impl.Collider): Collider2D | undefined;
+    private _tags;
+    private _collisionMatrix;
+    private _solverMatrix;
+    private _worldImpl;
+    private _eventQueue;
+    private _linkManager;
+    private _rigidBodies;
+    private _colliders;
+    private _collisionRecords;
+    private _physicsComponents;
+    private _outDated;
+    private _emitterForWillDestroy;
+    private _getTagBit;
+    private _createImplCollider;
+    private _removeImplCollider;
+    private _emitEvents;
+    private _emitCollisionEvent;
+    private _intersectWithShape;
+    private _castShape;
+}
+export interface RigidBody2DControlBlock {
+    impl: px2Impl.RigidBody;
+    enableCollisionEvents(value: boolean): void;
+    setTags(tags: string[]): void;
+    setActiveCollisionTypes(collisionTypeFilter: number): void;
+}
+export interface Collider2DHandle {
+    component: Collider2D;
+    destroy(wakeUp: boolean): void;
+    attachedRigidBody: RigidBody2D | null;
+    impl: px2Impl.Collider | null;
+    createCollider(desc: px2Impl.ColliderDesc): px2Impl.Collider;
+    removeCollider(wakeUp: boolean): void;
+}
+//# sourceMappingURL=physics-world-2d.d.ts.map