@cyclonium/physics-2d 0.0.100

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

@@ -0,0 +1,81 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { type Contact2DInfo } from './contact.js';
+import { px2Impl } from './px2-impl.js';
+import { PhysicsComponent2DBase } from './physics-component-2d-base.js';
+import { ColliderShapeCastHit, ColliderShapeIntersection, RayColliderIntersection, type ShapeCastQueryOptions, type ShapeIntersectionQueryOptions } from './scene-query.js';
+import type { Ray2D } from '@cyclonium/core/math/ray';
+import { Bounds2D } from '@cyclonium/core/math/bounds-2d';
+export declare abstract class Collider2D extends PhysicsComponent2DBase {
+    get attachedRigidBody(): import("./rigid-body-2d.js").RigidBody2D | null;
+    get isSensor(): boolean;
+    set isSensor(value: boolean);
+    get center(): Vec2;
+    set center(value: Vec2);
+    get bounds(): Bounds2D;
+    /**
+     * Test only.
+     * @internal
+     */
+    get impl_internal(): px2Impl.Collider | undefined;
+    onContactBegin: import("@cyclonium/event").ManagedEventEmitter<[Collider2D, Collider2D, Contact2DInfo]>;
+    onContactStay: import("@cyclonium/event").ManagedEventEmitter<[Collider2D, Collider2D, Contact2DInfo]>;
+    onContactEnd: import("@cyclonium/event").ManagedEventEmitter<[Collider2D, Collider2D, Contact2DInfo]>;
+    intersect(opts: ShapeIntersectionQueryOptions): ColliderShapeIntersection | undefined;
+    cast(opts: ShapeCastQueryOptions): ColliderShapeCastHit | undefined;
+    castRay(ray: Ray2D, maxDistance: number, solid?: boolean): RayColliderIntersection | undefined;
+    /**
+     * @internal
+     */
+    _enableCollisionEventsSinceBody(value: boolean): void;
+    /**
+     * @internal
+     */
+    _responseToBodyActiveCollisionTypes(value: number): void;
+    /**
+     * @internal
+     */
+    _responseToBodyCollisionGroups(value: number): void;
+    /**
+     * @internal
+     */
+    _responseToBodySolverGroups(value: number): void;
+    /**
+     * @internal
+     */
+    _responseToAttachedRigidBodyChanged(): void;
+    protected get _implCollider(): px2Impl.Collider | undefined;
+    protected recreateCollider(): void;
+    protected onAttachToWorld(): void;
+    protected onDetachFromWorld(): void;
+    protected onEnabled(): void;
+    protected onDisabled(): void;
+    protected onSyncTransforms(forceTransform: boolean, forceScale: boolean): void;
+    protected abstract getShape(): px2Impl.Shape | undefined;
+    protected abstract computeShapeBounds(out: Bounds2D): void;
+    protected get sceneGraphScale(): Vec2;
+    protected updateSceneGraphScale(): void;
+    private _isSensor;
+    private _center;
+    private _handle;
+    private _listenerFlags;
+    private _bodyActiveCollisionTypes;
+    private _bodyCollisionGroups;
+    private _bodySolverGroups;
+    private _transformChangeFlagsObserver;
+    private _sceneGraphScaleCache;
+    private _shape;
+    /**
+     * `false` if we acquired the shape but the shape is invalid,
+     * otherwise either we have not acquired the shape or the shape is valid.
+     */
+    private _shapeAcquired;
+    private _boundsCache;
+    private get _transform();
+    private _destroyCollider;
+    private _updateListenerFlag;
+    private _getActiveEvents;
+    private _acquireShape;
+    private _updateTransform;
+    private _computeBounds;
+}
+//# sourceMappingURL=collider-2d.d.ts.map

package/lib/collider-2d.js

@@ -0,0 +1,364 @@
+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 { editable, requiresComponent, serializable } from '@cyclonium/core/legacy-decorator';
+import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import {} from './contact.js';
+import { fromPx2ImplVec2, toPx2ImplVec2 } from './exchange.js';
+import { px2Impl } from './px2-impl.js';
+import { PhysicsComponent2DBase } from './physics-component-2d-base.js';
+import { ContactEventListenerFlagIndex, createCollisionEventEmitter } from './shared.js';
+import {} from './physics-world-2d.js';
+import { assert } from '@cyclonium/core/utils';
+import { getZRotation } from './utils/3-to-2.js';
+import { ColliderShapeCastHit, ColliderShapeIntersection, RayColliderIntersection } from './scene-query.js';
+import { Bounds2D } from '@cyclonium/core/math/bounds-2d';
+let Collider2D = class Collider2D extends PhysicsComponent2DBase {
+    get attachedRigidBody() {
+        return this._handle?.attachedRigidBody ?? null;
+    }
+    get isSensor() {
+        return this._isSensor;
+    }
+    set isSensor(value) {
+        this._isSensor = value;
+        if (this._implCollider) {
+            this._implCollider.setSensor(value);
+        }
+    }
+    get center() {
+        return this._center;
+    }
+    set center(value) {
+        Vec2.assign(this._center, value);
+        this._updateTransform();
+    }
+    get bounds() {
+        return this._computeBounds();
+    }
+    /**
+     * Test only.
+     * @internal
+     */
+    get impl_internal() {
+        return this._implCollider;
+    }
+    onContactBegin = createCollisionEventEmitter((hasAnyListener) => {
+        this._updateListenerFlag(ContactEventListenerFlagIndex.begin, hasAnyListener);
+    });
+    onContactStay = createCollisionEventEmitter((hasAnyListener) => {
+        this._updateListenerFlag(ContactEventListenerFlagIndex.stay, hasAnyListener);
+    });
+    onContactEnd = createCollisionEventEmitter((hasAnyListener) => {
+        this._updateListenerFlag(ContactEventListenerFlagIndex.end, hasAnyListener);
+    });
+    intersect(opts) {
+        const world = this.world;
+        if (!world) {
+            return;
+        }
+        const implCollider = this._implCollider;
+        if (!implCollider) {
+            return;
+        }
+        const collierImpl = world.impl.intersectionWithShape(implCollider.translation(), implCollider.rotation(), implCollider.shape, opts.filter?._filterFlags_internal, opts.filter?._filterGroups_internal, undefined, undefined);
+        if (!collierImpl) {
+            return;
+        }
+        const collider = world.getColliderWithWarn_internal(collierImpl);
+        if (!collider) {
+            return;
+        }
+        return new ColliderShapeIntersection(collider);
+    }
+    cast(opts) {
+        const world = this.world;
+        if (!world) {
+            return;
+        }
+        const implCollider = this._implCollider;
+        if (!implCollider) {
+            return;
+        }
+        const directionNormalized = opts.direction.normalize();
+        const shapePosition = implCollider.translation();
+        let filterPredicate;
+        if (opts.excludeColliders) {
+            const excludedColliderHandles = new Set();
+            for (const collider of opts.excludeColliders) {
+                const excludedImplCollider = collider.impl_internal;
+                if (excludedImplCollider) {
+                    excludedColliderHandles.add(excludedImplCollider.handle);
+                }
+            }
+            if (excludedColliderHandles.size > 0) {
+                filterPredicate = (collider) => !excludedColliderHandles.has(collider.handle);
+            }
+        }
+        const hit = world.impl.castShape(shapePosition, implCollider.rotation(), toPx2ImplVec2(directionNormalized), implCollider.shape, opts.targetDistance ?? 1e-6, opts.maxDistance, false, opts.filter?._filterFlags_internal, opts.filter?._filterGroups_internal, undefined, undefined, filterPredicate);
+        if (!hit) {
+            return;
+        }
+        const hitCollider = world.getColliderWithWarn_internal(hit.collider);
+        if (!hitCollider) {
+            return;
+        }
+        return new ColliderShapeCastHit(hit, fromPx2ImplVec2(shapePosition), directionNormalized, hitCollider);
+    }
+    castRay(ray, maxDistance, solid) {
+        const world = this.world;
+        if (!world) {
+            return;
+        }
+        const implCollider = this._implCollider;
+        if (!implCollider) {
+            return;
+        }
+        const hit = implCollider.castRayAndGetNormal(new px2Impl.Ray(toPx2ImplVec2(ray.origin), toPx2ImplVec2(ray.direction)), maxDistance, solid ?? true);
+        if (!hit) {
+            return;
+        }
+        return new RayColliderIntersection(this, hit.timeOfImpact, fromPx2ImplVec2(hit.normal));
+    }
+    /**
+     * @internal
+     */
+    _enableCollisionEventsSinceBody(value) {
+        this._updateListenerFlag(ContactEventListenerFlagIndex.body, value);
+    }
+    /**
+     * @internal
+     */
+    _responseToBodyActiveCollisionTypes(value) {
+        this._bodyActiveCollisionTypes = value;
+        if (this._implCollider) {
+            this._implCollider.setActiveCollisionTypes(this._bodyActiveCollisionTypes);
+        }
+    }
+    /**
+     * @internal
+     */
+    _responseToBodyCollisionGroups(value) {
+        this._bodyCollisionGroups = value;
+        if (this._implCollider) {
+            this._implCollider.setCollisionGroups(value);
+        }
+    }
+    /**
+     * @internal
+     */
+    _responseToBodySolverGroups(value) {
+        this._bodySolverGroups = value;
+        if (this._implCollider) {
+            this._implCollider.setSolverGroups(value);
+        }
+    }
+    /**
+     * @internal
+     */
+    _responseToAttachedRigidBodyChanged() {
+        this.recreateCollider();
+    }
+    get _implCollider() {
+        return this._handle?.impl ?? undefined;
+    }
+    recreateCollider() {
+        this._destroyCollider();
+        const handle = this._handle;
+        if (!handle) {
+            return;
+        }
+        const shape = this._acquireShape();
+        if (!shape) {
+            return;
+        }
+        const desc = new px2Impl.ColliderDesc(shape);
+        desc.setSensor(this._isSensor);
+        desc.setActiveEvents(this._getActiveEvents());
+        const collider = handle.createCollider(desc);
+        collider.setActiveCollisionTypes(this._bodyActiveCollisionTypes);
+        collider.setCollisionGroups(this._bodyCollisionGroups);
+        collider.setSolverGroups(this._bodySolverGroups);
+        this._updateTransform();
+        collider.setEnabled(this.enabledInHierarchy);
+    }
+    onAttachToWorld() {
+        if (!this.world) {
+            return;
+        }
+        this._transformChangeFlagsObserver.observe(this._transform);
+        this._sceneGraphScaleCache.copyFrom(this.sceneGraphScale);
+        this._handle = this.world._addColliderHandle(this);
+        this.recreateCollider();
+    }
+    onDetachFromWorld() {
+        this._handle?.destroy(true);
+        this._handle = null;
+    }
+    onEnabled() {
+        super.onEnabled();
+        this._implCollider?.setEnabled(true);
+    }
+    onDisabled() {
+        this._implCollider?.setEnabled(false);
+    }
+    onSyncTransforms(forceTransform, forceScale) {
+        const changeFlags = this._transformChangeFlagsObserver.sync();
+        const currentScale = this.sceneGraphScale;
+        const scaleChanged = forceScale || !!(changeFlags & TransformFlag.scale) || !Vec2.equals(currentScale, this._sceneGraphScaleCache);
+        if (scaleChanged) {
+            this._sceneGraphScaleCache.copyFrom(currentScale);
+            this.updateSceneGraphScale();
+        }
+        if (forceTransform || scaleChanged || !!(changeFlags & (TransformFlag.position | TransformFlag.rotation))) {
+            this._updateTransform();
+        }
+    }
+    get sceneGraphScale() {
+        return this._transform.scale;
+    }
+    updateSceneGraphScale() {
+        const implCollider = this._implCollider;
+        if (!implCollider) {
+            this.recreateCollider();
+            return;
+        }
+        const shape = this.getShape();
+        if (!shape) {
+            this.recreateCollider();
+            return;
+        }
+        implCollider.setShape(shape);
+    }
+    _isSensor = false;
+    _center = new Vec2();
+    _handle = null;
+    _listenerFlags = 0;
+    _bodyActiveCollisionTypes = 0;
+    _bodyCollisionGroups = 0;
+    _bodySolverGroups = 0;
+    _transformChangeFlagsObserver = new TransformChangeFlagsObserver();
+    _sceneGraphScaleCache = new Vec2(1, 1);
+    _shape = undefined;
+    /**
+     * `false` if we acquired the shape but the shape is invalid,
+     * otherwise either we have not acquired the shape or the shape is valid.
+     */
+    _shapeAcquired = false;
+    _boundsCache = new Bounds2D();
+    get _transform() { return undefined; }
+    _destroyCollider() {
+        this._shape = undefined;
+        this._shapeAcquired = false;
+        this._handle?.removeCollider(true);
+    }
+    _updateListenerFlag(index, hasAnyListener) {
+        if (hasAnyListener) {
+            this._listenerFlags |= 1 << index;
+        }
+        else {
+            this._listenerFlags &= ~(1 << index);
+        }
+        if (this._implCollider) {
+            this._implCollider.setActiveEvents(this._getActiveEvents());
+        }
+    }
+    _getActiveEvents() {
+        return this._listenerFlags === 0
+            ? px2Impl.ActiveEvents.NONE
+            : px2Impl.ActiveEvents.COLLISION_EVENTS;
+    }
+    _acquireShape() {
+        if (this._shapeAcquired) {
+            return undefined;
+        }
+        if (!this._shape) {
+            this._shape = this.getShape();
+            if (!this._shape) {
+                this._shapeAcquired = true;
+            }
+        }
+        return this._shape;
+    }
+    _updateTransform() {
+        const handle = this._handle;
+        if (!handle) {
+            return;
+        }
+        const implCollider = handle.impl;
+        if (!implCollider) {
+            return;
+        }
+        const parentRigidBody = handle.attachedRigidBody;
+        const pivot = this._center.clone();
+        const colliderTransform = this._transform;
+        pivot.x *= colliderTransform.scale.x;
+        pivot.y *= colliderTransform.scale.y;
+        if (parentRigidBody) {
+            assert(implCollider.parent());
+            if (parentRigidBody.node === this.node) {
+                // our parent rigid body already handled the scene graph transform
+                // only need the collider self's transform.
+                implCollider.setTranslationWrtParent(toPx2ImplVec2(pivot));
+            }
+            else {
+                const { position, rotation } = computeRelativeTransform(colliderTransform.node, parentRigidBody.node);
+                pivot.addSelf(position);
+                implCollider.setTranslationWrtParent(toPx2ImplVec2(pivot));
+                implCollider.setRotationWrtParent(rotation);
+            }
+        }
+        else {
+            pivot.addSelf(colliderTransform.position);
+            implCollider.setTranslation(toPx2ImplVec2(pivot));
+            implCollider.setRotation(colliderTransform.rotation);
+        }
+    }
+    _computeBounds() {
+        const bounds = this._boundsCache;
+        this.computeShapeBounds(bounds);
+        const pivot = this._center.clone();
+        const colliderTransform = this._transform;
+        pivot.x *= colliderTransform.scale.x;
+        pivot.y *= colliderTransform.scale.y;
+        const center = pivot;
+        center.rotateSelf(colliderTransform.rotation);
+        center.addSelf(colliderTransform.position);
+        bounds.center = center;
+        return bounds;
+    }
+};
+__decorate([
+    editable
+], Collider2D.prototype, "isSensor", null);
+__decorate([
+    editable
+], Collider2D.prototype, "center", null);
+__decorate([
+    serializable
+], Collider2D.prototype, "_isSensor", void 0);
+__decorate([
+    serializable
+], Collider2D.prototype, "_center", void 0);
+__decorate([
+    requiresComponent(Transform2DComponent)
+], Collider2D.prototype, "_transform", null);
+Collider2D = __decorate([
+    cycloBuiltinClass({ abstract: true })
+], Collider2D);
+export { Collider2D };
+function computeRelativeTransform(child, parent) {
+    const parentRotation = getZRotation(parent.worldRotation);
+    const childPosition = child.worldPosition;
+    const parentPosition = parent.worldPosition;
+    return {
+        position: new Vec2(childPosition.x - parentPosition.x, childPosition.y - parentPosition.y).rotateSelf(-parentRotation),
+        rotation: getZRotation(child.worldRotation) - parentRotation,
+    };
+}
+//# sourceMappingURL=collider-2d.js.map

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

@@ -0,0 +1,20 @@
+import { Collider2D } from '../collider-2d.js';
+import { px2Impl } from '../px2-impl.js';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import type { Bounds2D } from '@cyclonium/core/math/bounds-2d';
+export declare class BoxCollider2D extends Collider2D {
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get halfExtents(): Vec2;
+    set halfExtents(value: Vec2);
+    protected getShape(): px2Impl.Shape | undefined;
+    protected computeShapeBounds(out: Bounds2D): void;
+    protected onUpdate(): void;
+    protected updateSceneGraphScale(): void;
+    private _halfWidth;
+    private _halfHeight;
+    private _updateExtents;
+}
+//# sourceMappingURL=box-collider-2d.d.ts.map

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

@@ -0,0 +1,84 @@
+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 { drawBoxCollider2DGizmo } from '#gizmo';
+import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+let BoxCollider2D = class BoxCollider2D extends Collider2D {
+    get width() {
+        return this._halfWidth * 2;
+    }
+    set width(value) {
+        this._halfWidth = value / 2;
+        this._updateExtents();
+    }
+    get height() {
+        return this._halfHeight * 2;
+    }
+    set height(value) {
+        this._halfHeight = value / 2;
+        this._updateExtents();
+    }
+    get halfExtents() {
+        return new Vec2(this._halfWidth, this._halfHeight);
+    }
+    set halfExtents(value) {
+        this._halfWidth = value.x;
+        this._halfHeight = value.y;
+        this._updateExtents();
+    }
+    getShape() {
+        const scale = this.sceneGraphScale;
+        return new px2Impl.Cuboid(this._halfWidth * scale.x, this._halfHeight * scale.y);
+    }
+    computeShapeBounds(out) {
+        const hw = this._halfWidth;
+        const hh = this._halfHeight;
+        const scale = this.sceneGraphScale;
+        out.setCenterSize(Vec2.ZERO, new Vec2(hw * scale.x * 2, hh * scale.y * 2));
+    }
+    onUpdate() {
+        if (EDITOR_NOT_IN_PREVIEW) {
+            drawBoxCollider2DGizmo(this);
+        }
+    }
+    updateSceneGraphScale() {
+        this._updateExtents();
+    }
+    _halfWidth = 1;
+    _halfHeight = 1;
+    _updateExtents() {
+        if (!this._implCollider) {
+            return;
+        }
+        const scale = this.sceneGraphScale;
+        this._implCollider.setHalfExtents(new px2Impl.Vector2(this._halfWidth * scale.x, this._halfHeight * scale.y));
+    }
+};
+__decorate([
+    editable({ min: 0 }),
+    idem
+], BoxCollider2D.prototype, "width", null);
+__decorate([
+    editable({ min: 0 }),
+    idem
+], BoxCollider2D.prototype, "height", null);
+__decorate([
+    serializable
+], BoxCollider2D.prototype, "_halfWidth", void 0);
+__decorate([
+    serializable
+], BoxCollider2D.prototype, "_halfHeight", void 0);
+BoxCollider2D = __decorate([
+    cycloBuiltinClass('BoxCollider2D'),
+    executeInEditMode
+], BoxCollider2D);
+export { BoxCollider2D };
+//# sourceMappingURL=box-collider-2d.js.map

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

@@ -0,0 +1,17 @@
+import { Collider2D } from '../collider-2d.js';
+import { px2Impl } from '../px2-impl.js';
+import type { Bounds2D } from '@cyclonium/core/math/bounds-2d';
+export declare class CapsuleCollider2D extends Collider2D {
+    get radius(): number;
+    set radius(value: number);
+    get halfHeight(): number;
+    set halfHeight(value: number);
+    protected getShape(): px2Impl.Capsule;
+    protected computeShapeBounds(out: Bounds2D): void;
+    protected onUpdate(): void;
+    protected updateSceneGraphScale(): void;
+    private _radius;
+    private _halfHeight;
+    private _getRadius;
+}
+//# sourceMappingURL=capsule-collider-2d.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+import { Collider2D } from '../collider-2d.js';
+import { px2Impl } from '../px2-impl.js';
+import type { Bounds2D } from '@cyclonium/core/math/bounds-2d';
+export declare class CircleCollider2D extends Collider2D {
+    get radius(): number;
+    set radius(value: number);
+    protected getShape(): px2Impl.Ball;
+    protected computeShapeBounds(out: Bounds2D): void;
+    protected onUpdate(): void;
+    protected updateSceneGraphScale(): void;
+    private _radius;
+    private _getRadius;
+}
+//# sourceMappingURL=circle-collider-2d.d.ts.map