@cyclonium/physics-2d 0.0.100

package/lib/scene-query.js

@@ -0,0 +1,128 @@
+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);
+    }
+    set dynamics(value) {
+        this._setIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_DYNAMIC, value);
+    }
+    get fixed() {
+        return this._getIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_FIXED);
+    }
+    set fixed(value) {
+        this._setIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_FIXED, value);
+    }
+    get kinematics() {
+        return this._getIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_KINEMATIC);
+    }
+    set kinematics(value) {
+        this._setIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_KINEMATIC, value);
+    }
+    get sensors() {
+        return this._getIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_SENSORS);
+    }
+    set sensors(value) {
+        this._setIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_SENSORS, value);
+    }
+    get solids() {
+        return this._getIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_SOLIDS);
+    }
+    set solids(value) {
+        this._setIncludesFlag(px2Impl.QueryFilterFlags.EXCLUDE_SOLIDS, value);
+    }
+    addTargetTag(tag) {
+        this._filterGroupFilter |= 1 << tag;
+        return this;
+    }
+    get _filterFlags_internal() {
+        return this._filterFlags;
+    }
+    get _filterGroups_internal() {
+        // TODO
+        // return composeCollisionGroup(GROUP_MEMBERSHIP_ALLOW_SCENE_QUERY, this._filterGroupFilter);
+        return composeCollisionGroup(0xFFFF, this._filterGroupFilter);
+    }
+    _filterGroupFilter = 0;
+    _filterFlags = 0;
+    _getIncludesFlag(flag) {
+        return (this._filterFlags & flag) === 0;
+    }
+    _setIncludesFlag(flag, value) {
+        this._filterFlags = value ? this._filterFlags & ~flag : this._filterFlags | flag;
+    }
+}
+function composeCollisionGroup(membership, filter) {
+    // Per https://rapier.rs/docs/user_guides/javascript/colliders#collision-groups-and-solver-groups
+    // > The membership and filter are both 16-bit bit masks packed into a single 32-bits value.
+    // > The 16 left-most bits contain the memberships whereas the 16 right-most bits contain the filter.
+    return (membership << 16) | filter;
+}
+export class ColliderShapeCastHit {
+    constructor(impl, startPosition, direction, collider) {
+        this._impl = impl;
+        this._startPosition = new Vec2(startPosition.x, startPosition.y);
+        this._direction = new Vec2(direction.x, direction.y);
+        this._collider = collider;
+    }
+    get collider() {
+        return this._collider;
+    }
+    get impl() {
+        return this._impl;
+    }
+    get point() {
+        return this._startPosition.addMulScalar(this._direction, this._impl.time_of_impact);
+    }
+    get distance() {
+        return this._impl.time_of_impact;
+    }
+    get localPoint1() {
+        return fromPx2ImplVec2(this._impl.witness1);
+    }
+    get localPoint2() {
+        return fromPx2ImplVec2(this._impl.witness2);
+    }
+    get localNormal1() {
+        return fromPx2ImplVec2(this._impl.normal1);
+    }
+    get localNormal2() {
+        return fromPx2ImplVec2(this._impl.normal2);
+    }
+    _impl;
+    _startPosition;
+    _direction;
+    _collider;
+}
+export class ColliderShapeIntersection {
+    _collider;
+    constructor(_collider) {
+        this._collider = _collider;
+    }
+    get collider() {
+        return this._collider;
+    }
+}
+export class RayColliderIntersection {
+    constructor(collider, timeOfImpact, normal) {
+        this._collider = collider;
+        this._timeOfImpact = timeOfImpact;
+        this._normal = normal;
+    }
+    get collider() {
+        return this._collider;
+    }
+    get timeOfImpact() {
+        return this._timeOfImpact;
+    }
+    get normal() {
+        return this._normal;
+    }
+    _collider;
+    _timeOfImpact;
+    _normal;
+}
+//# sourceMappingURL=scene-query.js.map

package/lib/shared.d.ts

@@ -0,0 +1,9 @@
+import { ManagedEventEmitter } from '@cyclonium/event';
+export declare enum ContactEventListenerFlagIndex {
+    begin = 0,
+    stay = 1,
+    end = 2,
+    body = 8
+}
+export declare function createCollisionEventEmitter<T extends unknown[]>(callback: (hasAnyListener: boolean) => void): ManagedEventEmitter<T>;
+//# sourceMappingURL=shared.d.ts.map

package/lib/shared.js

@@ -0,0 +1,42 @@
+import { ManagedEventEmitter } from '@cyclonium/event';
+export var ContactEventListenerFlagIndex;
+(function (ContactEventListenerFlagIndex) {
+    ContactEventListenerFlagIndex[ContactEventListenerFlagIndex["begin"] = 0] = "begin";
+    ContactEventListenerFlagIndex[ContactEventListenerFlagIndex["stay"] = 1] = "stay";
+    ContactEventListenerFlagIndex[ContactEventListenerFlagIndex["end"] = 2] = "end";
+    ContactEventListenerFlagIndex[ContactEventListenerFlagIndex["body"] = 8] = "body";
+})(ContactEventListenerFlagIndex || (ContactEventListenerFlagIndex = {}));
+class ManagedCollisionEventEmitter extends ManagedEventEmitter {
+    _callback;
+    constructor(_callback) {
+        super();
+        this._callback = _callback;
+    }
+    emit(...args) {
+        const r = super.emit(...args);
+        this._updateListenerFlag();
+        return r;
+    }
+    add(...args) {
+        const r = super.add(...args);
+        this._updateListenerFlag();
+        return r;
+    }
+    remove(...args) {
+        const r = super.remove(...args);
+        this._updateListenerFlag();
+        return r;
+    }
+    removeAll() {
+        const r = super.removeAll();
+        this._updateListenerFlag();
+        return r;
+    }
+    _updateListenerFlag() {
+        this._callback(this.listenerCount > 0);
+    }
+}
+export function createCollisionEventEmitter(callback) {
+    return new ManagedCollisionEventEmitter(callback);
+}
+//# sourceMappingURL=shared.js.map

package/lib/utils/3-to-2.d.ts

@@ -0,0 +1,3 @@
+import type { Quat } from 'cc';
+export declare function getZRotation(quat: Quat): number;
+//# sourceMappingURL=3-to-2.d.ts.map

package/lib/utils/3-to-2.js

@@ -0,0 +1,12 @@
+import { clamp } from '@cyclonium/core/math/number';
+export function getZRotation(quat) {
+    const { z, w } = quat;
+    const halfTheta = Math.acos(clamp(w, -1, 1));
+    if (halfTheta === 0) {
+        return 0;
+    }
+    const sinSign = Math.sign(halfTheta);
+    const axisSign = sinSign * Math.sign(z);
+    return axisSign * halfTheta * 2;
+}
+//# sourceMappingURL=3-to-2.js.map

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

@@ -0,0 +1,6 @@
+declare const _default: {
+    source: any;
+    target: string;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/wasm-binary-helper/index.js

@@ -0,0 +1,14 @@
+import { wasmBinaryId } from './wasm-binary-id.js';
+// @ts-expect-error node specific
+import { join, dirname } from 'node:path';
+// @ts-expect-error node specific
+import { fileURLToPath } from 'node:url';
+export default {
+    source: (() => {
+        const rapier2dModule = fileURLToPath(import.meta.resolve('@cyclonium/rapier2d'));
+        const rapier2dPkg = dirname(rapier2dModule);
+        return join(rapier2dPkg, 'rapier_wasm2d_bg.wasm');
+    })(),
+    target: wasmBinaryId,
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,2 @@
+export declare const wasmBinaryId = "@cyclonium/physics-2d/rapier2d/rapier_wasm2d_bg.wasm";
+//# sourceMappingURL=wasm-binary-id.d.ts.map

package/lib/wasm-binary-helper/wasm-binary-id.js

@@ -0,0 +1,2 @@
+export const wasmBinaryId = '@cyclonium/physics-2d/rapier2d/rapier_wasm2d_bg.wasm';
+//# sourceMappingURL=wasm-binary-id.js.map

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

@@ -0,0 +1,6 @@
+declare const _default: {
+    source: void;
+    target: string;
+};
+export default _default;
+//# sourceMappingURL=wasm-binary-helper.d.ts.map

package/lib/wasm-binary-helper.js

@@ -0,0 +1,6 @@
+export default {
+    source: (() => {
+    })(),
+    target: '@cyclonium/physics-2d/rapier2d/rapier_wasm2d_bg.wasm',
+};
+//# sourceMappingURL=wasm-binary-helper.js.map

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@cyclonium/physics-2d",
+  "version": "0.0.100",
+  "type": "module",
+  "files": [
+    "lib/**/*{.js,.d.ts}"
+  ],
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "imports": {
+    "#gizmo": {
+      "headless": "./lib/gizmo-headless.js",
+      "default": "./lib/gizmo.js"
+    },
+    "#physics-2d-debugger": {
+      "headless": "./lib/physics-2d-debugger-headless.js",
+      "default": "./lib/physics-2d-debugger.js"
+    }
+  },
+  "dependencies": {
+    "@cyclonium/algorithm": "0.0.100",
+    "@cyclonium/web-assembly": "0.0.100",
+    "@cyclonium/event": "0.0.100",
+    "@cyclonium/debug-draw": "0.0.100",
+    "@cyclonium/rapier2d": "0.0.100"
+  },
+  "peerDependencies": {
+    "@cyclonium/core": "0.0.100"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@vitest/browser-playwright": "^4.1.5",
+    "fs-extra": "^11.3.0",
+    "playwright": "^1.59.1",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.5",
+    "@cyclonium/cc-test": "0.0.100",
+    "@cyclonium/workflow": "0.0.100",
+    "@cyclonium/types-cc": "0.0.100"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b --watch",
+    "test:browser": "vitest --no-file-parallelism --disableConsoleIntercept",
+    "test": "npm run test:compile && npm run t",
+    "test:compile": "tsc -b test/tsconfig.json",
+    "t": "npm run test:browser -- run --browser.headless=true"
+  }
+}