@cyclonium/physics-2d 0.0.100

package/lib/colliders/circle-collider-2d.js

@@ -0,0 +1,59 @@
+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 { Collider2D } from '../collider-2d.js';
+import { px2Impl } from '../px2-impl.js';
+import { EDITOR_NOT_IN_PREVIEW } from 'cc/env';
+import { drawCircleCollider2DGizmo } from '#gizmo';
+import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+let CircleCollider2D = class CircleCollider2D extends Collider2D {
+    get radius() {
+        return this._radius;
+    }
+    set radius(value) {
+        this._radius = value;
+        this._implCollider?.setRadius(this._getRadius());
+    }
+    getShape() {
+        return new px2Impl.Ball(this._getRadius());
+    }
+    computeShapeBounds(out) {
+        out.setCenterSize(Vec2.ZERO, Vec2.splat(this._getRadius() * 2));
+    }
+    onUpdate() {
+        if (EDITOR_NOT_IN_PREVIEW) {
+            drawCircleCollider2DGizmo(this);
+        }
+    }
+    updateSceneGraphScale() {
+        this._implCollider?.setRadius(this._getRadius());
+    }
+    _radius = 1;
+    _getRadius() {
+        const scale = this.sceneGraphScale;
+        if (scale.x !== scale.y) {
+            console.warn('CircleCollider2D should have uniform scale');
+        }
+        return this._radius * scale.x;
+    }
+};
+__decorate([
+    editable({
+        min: 0,
+    }),
+    idem
+], CircleCollider2D.prototype, "radius", null);
+__decorate([
+    serializable
+], CircleCollider2D.prototype, "_radius", void 0);
+CircleCollider2D = __decorate([
+    cycloBuiltinClass('CircleCollider2D'),
+    executeInEditMode
+], CircleCollider2D);
+export { CircleCollider2D };
+//# sourceMappingURL=circle-collider-2d.js.map

package/lib/colliders/polygon-collider-2d.d.ts

@@ -0,0 +1,17 @@
+import { Collider2D } from '../collider-2d.js';
+import { px2Impl } from '../px2-impl.js';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { Bounds2D } from '@cyclonium/core/math/bounds-2d';
+export declare class PolygonCollider2D extends Collider2D {
+    get points(): Vec2[];
+    setPolygon(points: Vec2[], indices?: ArrayLike<number>): void;
+    protected getShape(): px2Impl.Shape | undefined;
+    protected computeShapeBounds(out: Bounds2D): void;
+    protected updateSceneGraphScale(): void;
+    private _points;
+    private _indices;
+    private _isValidShape;
+    private _updateShape;
+    private _makeShape;
+}
+//# sourceMappingURL=polygon-collider-2d.d.ts.map

package/lib/colliders/polygon-collider-2d.js

@@ -0,0 +1,77 @@
+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 { Collider2D } from '../collider-2d.js';
+import { px2Impl } from '../px2-impl.js';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { Bounds2D } from '@cyclonium/core/math/bounds-2d';
+let PolygonCollider2D = class PolygonCollider2D extends Collider2D {
+    get points() {
+        return this._points;
+    }
+    setPolygon(points, indices) {
+        this._points = points.slice().map((v) => v.clone());
+        this._indices = indices ? Uint32Array.from(indices) : undefined;
+        this._updateShape();
+    }
+    getShape() {
+        if (!this._isValidShape()) {
+            return undefined;
+        }
+        return this._makeShape();
+    }
+    computeShapeBounds(out) {
+        const scale = this.sceneGraphScale;
+        out.setMinMax(Vec2.POSITIVE_INFINITY, Vec2.NEGATIVE_INFINITY);
+        const p = new Vec2();
+        for (let i = 0; i < this._points.length; i++) {
+            const point = this._points[i];
+            out.extend(p.copyFrom(point).mulSelf(scale));
+        }
+    }
+    updateSceneGraphScale() {
+        this._updateShape();
+    }
+    _points = [];
+    _indices = undefined;
+    _isValidShape() {
+        return this._points.length > 0;
+    }
+    _updateShape() {
+        if (!this._implCollider) {
+            this.recreateCollider();
+        }
+        else if (this._isValidShape()) {
+            this._implCollider.setShape(this._makeShape());
+        }
+        else {
+            this.recreateCollider();
+        }
+    }
+    _makeShape() {
+        const scale = this.sceneGraphScale;
+        const flatVertices = new Float32Array(this._points.length * 2);
+        for (let i = 0; i < this._points.length; i++) {
+            const point = this._points[i];
+            flatVertices[i * 2] = point.x * scale.x;
+            flatVertices[i * 2 + 1] = point.y * scale.y;
+        }
+        const polyline = new px2Impl.Polyline(flatVertices, this._indices);
+        // try {
+        //   polyline.intoRaw();
+        // } catch (e) {
+        //   console.error(`Invalid polygon: , name: ${this.node.getPathInHierarchy()} points: ${this._points.length}, indices: ${this._indices?.length}`);
+        //   throw e;
+        // }
+        return polyline;
+    }
+};
+PolygonCollider2D = __decorate([
+    cycloBuiltinClass('PolygonCollider2D')
+], PolygonCollider2D);
+export { PolygonCollider2D };
+//# sourceMappingURL=polygon-collider-2d.js.map

package/lib/collision-matrix.d.ts

@@ -0,0 +1,12 @@
+export declare class CollisionMatrix {
+    static readonly EXTENT = 16;
+    private get values();
+    private set values(value);
+    clone(): CollisionMatrix;
+    get(i: number, j: number): boolean;
+    set(i: number, j: number, value: boolean): void;
+    getCollisionsBitsOf(i: number): number;
+    private _values;
+    private _locate;
+}
+//# sourceMappingURL=collision-matrix.d.ts.map

package/lib/collision-matrix.js

@@ -0,0 +1,70 @@
+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;
+};
+var CollisionMatrix_1;
+import { editable, serializable } from '@cyclonium/core/legacy-decorator';
+import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { dumpRaw } from '@cyclonium/core/utils';
+const EXTENT = 16;
+let CollisionMatrix = class CollisionMatrix {
+    static { CollisionMatrix_1 = this; }
+    static EXTENT = EXTENT;
+    get values() {
+        return this._values;
+    }
+    set values(values) {
+        this._values = [...values];
+    }
+    clone() {
+        const clone = new CollisionMatrix_1();
+        clone._values = this._values.slice();
+        return clone;
+    }
+    get(i, j) {
+        return this._values[this._locate(i, j)];
+    }
+    set(i, j, value) {
+        const index = this._locate(i, j);
+        this._values[index] = value;
+    }
+    getCollisionsBitsOf(i) {
+        let bits = 0;
+        for (let j = 0; j < EXTENT; j++) {
+            const value = this.get(i, j);
+            if (value) {
+                bits |= 1 << j;
+            }
+        }
+        const rowStart = i * (i + 1) / 2;
+        for (let j = 0; j <= i; j++) {
+            bits |= this._values[rowStart + j] ? 1 << j : 0;
+        }
+        return bits;
+    }
+    _values = new Array(EXTENT * (EXTENT + 1) / 2).fill(false);
+    _locate(i, j) {
+        if (i < 0 || i >= EXTENT || j < 0 || j >= EXTENT) {
+            throw new Error(`Index out of range.`);
+        }
+        if (i > j) {
+            [i, j] = [j, i];
+        }
+        const rowStart = i * (2 * EXTENT - i - 1) / 2;
+        return rowStart + j;
+    }
+};
+__decorate([
+    editable,
+    dumpRaw
+], CollisionMatrix.prototype, "values", null);
+__decorate([
+    serializable
+], CollisionMatrix.prototype, "_values", void 0);
+CollisionMatrix = CollisionMatrix_1 = __decorate([
+    cycloBuiltinClass('CollisionMatrix')
+], CollisionMatrix);
+export { CollisionMatrix };
+//# sourceMappingURL=collision-matrix.js.map

package/lib/contact.d.ts

@@ -0,0 +1,7 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+export interface Contact2DInfo {
+    manifold: {
+        points: Vec2[];
+    };
+}
+//# sourceMappingURL=contact.d.ts.map

package/lib/contact.js

@@ -0,0 +1,2 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+//# sourceMappingURL=contact.js.map

package/lib/exchange.d.ts

@@ -0,0 +1,5 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { px2Impl } from './px2-impl.js';
+export declare function toPx2ImplVec2(input: Vec2, out?: px2Impl.Vector2): px2Impl.Vector2;
+export declare function fromPx2ImplVec2(input: px2Impl.Vector2, out?: Vec2): Vec2;
+//# sourceMappingURL=exchange.d.ts.map

package/lib/exchange.js

@@ -0,0 +1,23 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { px2Impl } from './px2-impl.js';
+export function toPx2ImplVec2(input, out) {
+    if (out) {
+        out.x = input.x;
+        out.y = input.y;
+        return out;
+    }
+    else {
+        return new px2Impl.Vector2(input.x, input.y);
+    }
+}
+export function fromPx2ImplVec2(input, out) {
+    if (out) {
+        out.x = input.x;
+        out.y = input.y;
+        return out;
+    }
+    else {
+        return new Vec2(input.x, input.y);
+    }
+}
+//# sourceMappingURL=exchange.js.map

package/lib/gizmo-headless.d.ts

@@ -0,0 +1,7 @@
+export declare function drawBoxCollider2DGizmo(): void;
+export declare function drawCircleCollider2DGizmo(): void;
+export declare function drawCapsuleCollider2DGizmo(): void;
+export declare function drawBoxSceneQueryProbe2DGizmo(): void;
+export declare function drawCircleSceneQueryProbe2DGizmo(): void;
+export declare function drawCapsuleSceneQueryProbe2DGizmo(): void;
+//# sourceMappingURL=gizmo-headless.d.ts.map

package/lib/gizmo-headless.js

@@ -0,0 +1,7 @@
+export function drawBoxCollider2DGizmo() { }
+export function drawCircleCollider2DGizmo() { }
+export function drawCapsuleCollider2DGizmo() { }
+export function drawBoxSceneQueryProbe2DGizmo() { }
+export function drawCircleSceneQueryProbe2DGizmo() { }
+export function drawCapsuleSceneQueryProbe2DGizmo() { }
+//# sourceMappingURL=gizmo-headless.js.map

package/lib/gizmo.d.ts

@@ -0,0 +1,13 @@
+import type { BoxCollider2D } from './colliders/box-collider-2d.js';
+import type { CircleCollider2D } from './colliders/circle-collider-2d.js';
+import type { CapsuleCollider2D } from './colliders/capsule-collider-2d.js';
+import type { BoxSceneQueryProbe2D } from './scene-query-probes/box-scene-query-probe-2d.js';
+import type { CapsuleSceneQueryProbe2D } from './scene-query-probes/capsule-scene-query-probe-2d.js';
+import type { CircleSceneQueryProbe2D } from './scene-query-probes/circle-scene-query-probe-2d.js';
+export declare function drawBoxCollider2DGizmo(collider: BoxCollider2D): void;
+export declare function drawCircleCollider2DGizmo(collider: CircleCollider2D): void;
+export declare function drawCapsuleCollider2DGizmo(_collider: CapsuleCollider2D): void;
+export declare function drawBoxSceneQueryProbe2DGizmo(probe: BoxSceneQueryProbe2D): void;
+export declare function drawCircleSceneQueryProbe2DGizmo(probe: CircleSceneQueryProbe2D): void;
+export declare function drawCapsuleSceneQueryProbe2DGizmo(probe: CapsuleSceneQueryProbe2D): void;
+//# sourceMappingURL=gizmo.d.ts.map

package/lib/gizmo.js

@@ -0,0 +1,122 @@
+import { Color } from 'cc';
+import { EDITOR_NOT_IN_PREVIEW } from 'cc/env';
+import { tryGetDebugGeometryRenderer, drawBox2D, drawCircle2D, drawLineFromTo2D } from '@cyclonium/debug-draw';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { Transform2DComponent } from '@cyclonium/core/2d';
+const depthTest = false;
+const color = Color.YELLOW;
+const probeColor = new Color(0, 204, 255, 255);
+const wireframe = true;
+export function drawBoxCollider2DGizmo(collider) {
+    if (EDITOR_NOT_IN_PREVIEW) {
+        const g = tryGetDebugGeometryRenderer();
+        if (g) {
+            const transform = getCollider2DTransform(collider);
+            drawBox2D(g, collider.center, new Vec2(collider.width / 2, collider.height / 2), color, {
+                wireframe,
+                depthTest,
+                transform,
+            });
+            drawLineFromTo2D(g, collider.center, collider.center.addMulScalar(Vec2.UNIT_X, collider.width / 2), Color.RED, {
+                depthTest,
+                transform,
+            });
+            drawLineFromTo2D(g, collider.center, collider.center.addMulScalar(Vec2.UNIT_Y, collider.height / 2), Color.GREEN, {
+                depthTest,
+                transform,
+            });
+        }
+    }
+}
+export function drawCircleCollider2DGizmo(collider) {
+    if (EDITOR_NOT_IN_PREVIEW) {
+        const g = tryGetDebugGeometryRenderer();
+        if (g) {
+            const transform = Transform2DComponent.of(collider);
+            drawCircle2D(g, {
+                center: collider.center,
+                radius: collider.radius * transform.scale.x,
+                color: color,
+                wireframe,
+                depthTest,
+                transform: getCollider2DTransform(collider),
+            });
+        }
+    }
+}
+export function drawCapsuleCollider2DGizmo(_collider) {
+    if (EDITOR_NOT_IN_PREVIEW) {
+        const g = tryGetDebugGeometryRenderer();
+        if (g) {
+            // todo
+        }
+    }
+}
+export function drawBoxSceneQueryProbe2DGizmo(probe) {
+    if (EDITOR_NOT_IN_PREVIEW) {
+        const g = tryGetDebugGeometryRenderer();
+        if (g) {
+            drawBox2D(g, Vec2.ZERO, probe.halfExtents, probeColor, {
+                wireframe,
+                depthTest,
+                transform: getSceneQueryProbe2DTransform(probe),
+            });
+        }
+    }
+}
+export function drawCircleSceneQueryProbe2DGizmo(probe) {
+    if (EDITOR_NOT_IN_PREVIEW) {
+        const g = tryGetDebugGeometryRenderer();
+        if (g) {
+            drawCircle2D(g, {
+                center: Vec2.ZERO.clone(),
+                radius: probe.radius,
+                color: probeColor,
+                wireframe,
+                depthTest,
+                transform: getSceneQueryProbe2DTransform(probe),
+            });
+        }
+    }
+}
+export function drawCapsuleSceneQueryProbe2DGizmo(probe) {
+    if (EDITOR_NOT_IN_PREVIEW) {
+        const g = tryGetDebugGeometryRenderer();
+        if (g) {
+            const transform = getSceneQueryProbe2DTransform(probe);
+            const top = new Vec2(0, probe.halfHeight);
+            const bottom = new Vec2(0, -probe.halfHeight);
+            drawCircle2D(g, {
+                center: top,
+                radius: probe.radius,
+                color: probeColor,
+                wireframe,
+                depthTest,
+                transform,
+            });
+            drawCircle2D(g, {
+                center: bottom,
+                radius: probe.radius,
+                color: probeColor,
+                wireframe,
+                depthTest,
+                transform,
+            });
+            drawLineFromTo2D(g, new Vec2(-probe.radius, -probe.halfHeight), new Vec2(-probe.radius, probe.halfHeight), probeColor, {
+                depthTest,
+                transform,
+            });
+            drawLineFromTo2D(g, new Vec2(probe.radius, -probe.halfHeight), new Vec2(probe.radius, probe.halfHeight), probeColor, {
+                depthTest,
+                transform,
+            });
+        }
+    }
+}
+function getCollider2DTransform(collider) {
+    return Transform2DComponent.of(collider).matrix;
+}
+function getSceneQueryProbe2DTransform(probe) {
+    return Transform2DComponent.of(probe).matrix;
+}
+//# sourceMappingURL=gizmo.js.map

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+export { PhysicsWorld2D, RaycastResult, type CircleShapeDesc, type CapsuleShapeDesc, type RectShapeDesc, type ShapeTransformDesc, } from './physics-world-2d.js';
+export { RigidBody2D, RigidBody2DType } from './rigid-body-2d.js';
+export { Collider2D } from './collider-2d.js';
+export { Physics2DSettings } from './physics-2d-settings.js';
+export { BoxCollider2D } from './colliders/box-collider-2d.js';
+export { CircleCollider2D } from './colliders/circle-collider-2d.js';
+export { PolygonCollider2D } from './colliders/polygon-collider-2d.js';
+export { CapsuleCollider2D } from './colliders/capsule-collider-2d.js';
+export { SceneQueryProbe2D, type SceneQueryProbeSweepOptions } from './scene-query-probe-2d.js';
+export { BoxSceneQueryProbe2D } from './scene-query-probes/box-scene-query-probe-2d.js';
+export { CircleSceneQueryProbe2D } from './scene-query-probes/circle-scene-query-probe-2d.js';
+export { CapsuleSceneQueryProbe2D } from './scene-query-probes/capsule-scene-query-probe-2d.js';
+export { KinematicCharacterController2D } from './character-controller-2d.js';
+export { initializePx2Impl as __init } from './px2-impl.js';
+export { Physics2DDebugger } from '#physics-2d-debugger';
+export { CollisionMatrix } from './collision-matrix.js';
+export { PhysicsWorld2DSceneComponent } from './physics-world-2d-scene-component.js';
+export { type Contact2DInfo } from './contact.js';
+export { SceneQueryFilter, type ShapeCastQueryOptions, ColliderShapeCastHit, type ShapeIntersectionQueryOptions, ColliderShapeIntersection, RayColliderIntersection, } from './scene-query.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,20 @@
+export { PhysicsWorld2D, RaycastResult, } from './physics-world-2d.js';
+export { RigidBody2D, RigidBody2DType } from './rigid-body-2d.js';
+export { Collider2D } from './collider-2d.js';
+export { Physics2DSettings } from './physics-2d-settings.js';
+export { BoxCollider2D } from './colliders/box-collider-2d.js';
+export { CircleCollider2D } from './colliders/circle-collider-2d.js';
+export { PolygonCollider2D } from './colliders/polygon-collider-2d.js';
+export { CapsuleCollider2D } from './colliders/capsule-collider-2d.js';
+export { SceneQueryProbe2D } from './scene-query-probe-2d.js';
+export { BoxSceneQueryProbe2D } from './scene-query-probes/box-scene-query-probe-2d.js';
+export { CircleSceneQueryProbe2D } from './scene-query-probes/circle-scene-query-probe-2d.js';
+export { CapsuleSceneQueryProbe2D } from './scene-query-probes/capsule-scene-query-probe-2d.js';
+export { KinematicCharacterController2D } from './character-controller-2d.js';
+export { initializePx2Impl as __init } from './px2-impl.js';
+export { Physics2DDebugger } from '#physics-2d-debugger';
+export { CollisionMatrix } from './collision-matrix.js';
+export { PhysicsWorld2DSceneComponent } from './physics-world-2d-scene-component.js';
+export {} from './contact.js';
+export { SceneQueryFilter, ColliderShapeCastHit, ColliderShapeIntersection, RayColliderIntersection, } from './scene-query.js';
+//# sourceMappingURL=index.js.map

package/lib/physics-2d-debugger-headless.d.ts

@@ -0,0 +1,6 @@
+export declare class Physics2DDebugger {
+    constructor();
+    destroy(): void;
+    render(): void;
+}
+//# sourceMappingURL=physics-2d-debugger-headless.d.ts.map

package/lib/physics-2d-debugger-headless.js

@@ -0,0 +1,9 @@
+export class Physics2DDebugger {
+    constructor() {
+    }
+    destroy() {
+    }
+    render() {
+    }
+}
+//# sourceMappingURL=physics-2d-debugger-headless.js.map

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

@@ -0,0 +1,11 @@
+import { Scene } from 'cc';
+import { px2Impl } from './px2-impl.js';
+export declare class Physics2DDebugger {
+    private _implWorld;
+    constructor(_implWorld: px2Impl.World, scene: Scene);
+    destroy(): void;
+    render(): void;
+    private _node;
+    private _renderer;
+}
+//# sourceMappingURL=physics-2d-debugger.d.ts.map

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

@@ -0,0 +1,146 @@
+import { assetManager, EffectAsset, gfx, Material, Node, renderer, Renderer, RenderingSubMesh, Scene } from 'cc';
+import { px2Impl } from './px2-impl.js';
+class Physics2DDebugRenderer extends Renderer {
+    constructor() {
+        super();
+        const material = new Material('physics-2d-debugger');
+        material.reset({
+            effectName: 'builtin-unlit',
+            states: {
+                primitive: gfx.PrimitiveMode.LINE_LIST,
+                rasterizerState: {
+                    lineWidth: 100,
+                },
+            },
+        });
+        this._material = material;
+        this._loadMaterial();
+    }
+    onEnable() {
+        if (this._renderRecord) {
+            this._renderRecord.model.enabled = true;
+        }
+    }
+    onDisable() {
+        if (this._renderRecord) {
+            this._renderRecord.model.enabled = false;
+        }
+    }
+    render(world) {
+        const { vertices, colors } = world.debugRender();
+        const vertexCount = vertices.length / 2;
+        this._ensureModelCapacity(vertexCount);
+        const renderRecord = this._renderRecord;
+        if (renderRecord) {
+            this._setDrawVertexCount(renderRecord, vertexCount);
+            if (vertexCount === 0) {
+                return;
+            }
+            // @ts-expect-error Cocos buffer typings omit the runtime Float32Array update overload.
+            renderRecord.vertexBuffer.update(vertices, vertices.byteLength);
+            // @ts-expect-error Cocos buffer typings omit the runtime Float32Array update overload.
+            renderRecord.colorVertexBuffer.update(colors, colors.byteLength);
+        }
+    }
+    _material;
+    _materialLoaded = false;
+    _renderRecord;
+    _ensureModelCapacity(requiredVertexCount) {
+        if (requiredVertexCount === 0) {
+            return;
+        }
+        const renderRecord = this._renderRecord;
+        if (renderRecord) {
+            if (renderRecord.vertexCapacity >= requiredVertexCount) {
+                return;
+            }
+            renderRecord.model.scene?.removeModel(renderRecord.model);
+            renderRecord.model.destroy();
+            renderRecord.vertexBuffer.destroy();
+            renderRecord.colorVertexBuffer.destroy();
+            this._renderRecord = undefined;
+        }
+        const renderScene = this._getRenderScene();
+        const device = renderScene.root.device;
+        const vertexBuffer = device.createBuffer(new gfx.BufferInfo(gfx.BufferUsageBit.VERTEX, gfx.MemoryUsageBit.DEVICE, requiredVertexCount * 2 * Float32Array.BYTES_PER_ELEMENT, 2 * Float32Array.BYTES_PER_ELEMENT, gfx.BufferFlagBit.NONE));
+        const colorVertexBuffer = device.createBuffer(new gfx.BufferInfo(gfx.BufferUsageBit.VERTEX, gfx.MemoryUsageBit.DEVICE, requiredVertexCount * 4 * Float32Array.BYTES_PER_ELEMENT, 4 * Float32Array.BYTES_PER_ELEMENT, gfx.BufferFlagBit.NONE));
+        const renderingSubMesh = new RenderingSubMesh([vertexBuffer, colorVertexBuffer], [
+            new gfx.Attribute(gfx.AttributeName.ATTR_POSITION, gfx.Format.RG32F, false, 0, false, undefined),
+            new gfx.Attribute(gfx.AttributeName.ATTR_COLOR, gfx.Format.RGBA32F, false, 1, false, undefined),
+        ], gfx.PrimitiveMode.LINE_LIST, undefined, undefined);
+        const drawInfo = new gfx.DrawInfo();
+        renderingSubMesh.drawInfo = drawInfo;
+        const model = new renderer.scene.Model();
+        model.node = this.node;
+        model.transform = this.node;
+        model.initSubModel(0, renderingSubMesh, this._material);
+        renderScene.addModel(model);
+        this._renderRecord = {
+            vertexCapacity: requiredVertexCount,
+            drawInfo,
+            model,
+            renderingSubMesh,
+            vertexBuffer,
+            colorVertexBuffer,
+        };
+    }
+    _setDrawVertexCount(renderRecord, vertexCount) {
+        renderRecord.drawInfo.vertexCount = vertexCount;
+        renderRecord.renderingSubMesh.drawInfo = renderRecord.drawInfo;
+        renderRecord.model.subModels[0]?.onGeometryChanged();
+    }
+    _loadMaterial() {
+        if (this._materialLoaded) {
+            return;
+        }
+        this._materialLoaded = true;
+        new Promise((resolve, reject) => {
+            assetManager.loadAny('0352391c-bc3d-4674-bed1-3472beacecc1', (err, effect) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(effect);
+            });
+        })
+            .then((effect) => {
+            const material = new Material('physics-2d-debugger');
+            material.reset({
+                effectAsset: effect,
+                states: {
+                    primitive: gfx.PrimitiveMode.LINE_LIST,
+                    rasterizerState: {
+                        lineWidth: 100,
+                    },
+                },
+            });
+            material.setProperty('z', 1);
+            this._material = material;
+            if (this._renderRecord) {
+                this._renderRecord.model.setSubModelMaterial(0, material);
+            }
+        })
+            .catch((err) => {
+            console.error('Failed to load physics-2d-debugger material', err);
+        });
+    }
+}
+export class Physics2DDebugger {
+    _implWorld;
+    constructor(_implWorld, scene) {
+        this._implWorld = _implWorld;
+        const node = this._node = new Node(`physics-2d-debugger`);
+        this._node.parent = scene;
+        const renderer = node.addComponent(Physics2DDebugRenderer);
+        this._renderer = renderer;
+    }
+    destroy() {
+        this._node.destroy();
+    }
+    render() {
+        this._renderer.render(this._implWorld);
+    }
+    _node;
+    _renderer;
+}
+//# sourceMappingURL=physics-2d-debugger.js.map

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

@@ -0,0 +1,13 @@
+import { Asset } from 'cc';
+import { CollisionMatrix } from './collision-matrix.js';
+export declare class Physics2DSettings extends Asset {
+    fps: number;
+    get tags(): Record<string, number>;
+    private get tags_editor();
+    private set tags_editor(value);
+    get collisionMatrix(): CollisionMatrix;
+    findTagIndex(tag: string): number;
+    private _tags;
+    private _collisionMatrix;
+}
+//# sourceMappingURL=physics-2d-settings.d.ts.map