@codexo/exojs 0.6.7 → 0.6.9

package/dist/exo.esm.js

@@ -6211,19 +6211,6 @@ const createCanvas = (options = {}) => {
     context.fillRect(0, 0, newCanvas.width, newCanvas.height);
     return newCanvas;
 };
-const heightCache = new Map();
-const determineFontHeight = (font) => {
-    if (!heightCache.has(font)) {
-        const body = document.body;
-        const dummy = document.createElement('div');
-        dummy.appendChild(document.createTextNode('M'));
-        dummy.setAttribute('style', `font: ${font};position:absolute;top:0;left:0`);
-        body.appendChild(dummy);
-        heightCache.set(font, dummy.offsetHeight);
-        body.removeChild(dummy);
-    }
-    return heightCache.get(font);
-};
 
 class Texture {
     static _black = null;
@@ -17629,14 +17616,227 @@ class AnimatedSprite extends Sprite {
     }
 }
 
+const glyphPadding = 2;
+class ShelfPacker {
+    _shelves = [];
+    _width;
+    _height;
+    constructor(width, height) {
+        this._width = width;
+        this._height = height;
+    }
+    insert(width, height) {
+        // Try existing shelves in order (ascending y)
+        for (const shelf of this._shelves) {
+            if (shelf.height >= height && shelf.cursorX + width <= this._width) {
+                const x = shelf.cursorX;
+                shelf.cursorX += width;
+                return { x, y: shelf.y };
+            }
+        }
+        // Create a new shelf at the bottom
+        const last = this._shelves[this._shelves.length - 1];
+        const bottomY = last === undefined ? 0 : last.y + last.height;
+        if (bottomY + height > this._height) {
+            throw new Error(`GlyphAtlas full — clear() and re-render, or instantiate with larger dims`);
+        }
+        this._shelves.push({ y: bottomY, height, cursorX: width });
+        return { x: 0, y: bottomY };
+    }
+    reset() {
+        this._shelves.length = 0;
+    }
+}
+/**
+ * A shared atlas that rasterizes glyphs on demand into an offscreen canvas
+ * and wraps it as a Texture for use by the Mesh-based Text renderer.
+ *
+ * Glyphs are always rasterized in white so that runtime tinting via
+ * `Mesh.tint` applies the fill color without requiring re-rasterization.
+ *
+ * Use `getDefaultGlyphAtlas()` from `atlas-singleton.ts` rather than
+ * constructing directly.
+ */
+class DynamicGlyphAtlas {
+    texture;
+    _canvas;
+    _ctx;
+    _packer;
+    _cache = new Map();
+    _width;
+    _height;
+    constructor(width = 1024, height = 1024) {
+        this._width = width;
+        this._height = height;
+        // Use OffscreenCanvas when available, fall back to HTMLCanvasElement.
+        // In jsdom / Node the global may be absent; createCanvas falls through
+        // to document.createElement which jsdom provides.
+        const canvas = typeof OffscreenCanvas !== 'undefined'
+            ? new OffscreenCanvas(width, height)
+            : document.createElement('canvas');
+        if ('width' in canvas) {
+            canvas.width = width;
+            canvas.height = height;
+        }
+        this._canvas = canvas;
+        const ctx = canvas.getContext('2d');
+        if (ctx === null) {
+            throw new Error('DynamicGlyphAtlas: could not obtain a 2D context.');
+        }
+        this._ctx = ctx;
+        this._packer = new ShelfPacker(width, height);
+        this.texture = new Texture(canvas);
+        this.texture.setSize(width, height);
+    }
+    /**
+     * Returns the cached GlyphInfo for the given character + font parameters,
+     * rasterizing it into the atlas if not already present.
+     */
+    getGlyph(char, family, size, weight, style) {
+        const key = `${char}:${family}:${size}:${weight}:${style}`;
+        const cached = this._cache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const info = this._rasterize(char, family, size, weight, style, key);
+        this._cache.set(key, info);
+        // Bump texture version so GPU backends re-upload the canvas data.
+        this.texture.updateSource();
+        return info;
+    }
+    /**
+     * Clears all cached glyphs and resets the atlas packer.
+     * The underlying canvas pixels are also cleared.
+     */
+    clear() {
+        this._cache.clear();
+        this._packer.reset();
+        this._ctx.clearRect(0, 0, this._width, this._height);
+        this.texture.updateSource();
+    }
+    // -----------------------------------------------------------------------
+    _rasterize(char, family, size, weight, fontStyle, _key) {
+        const ctx = this._ctx;
+        const padding = glyphPadding;
+        ctx.font = `${fontStyle} ${weight} ${size}px ${family}`;
+        ctx.textBaseline = 'alphabetic';
+        ctx.fillStyle = '#ffffff';
+        const metrics = ctx.measureText(char);
+        const ascent = Math.ceil(metrics.fontBoundingBoxAscent
+            ?? metrics.actualBoundingBoxAscent
+            ?? size * 0.8);
+        const descent = Math.ceil(metrics.fontBoundingBoxDescent
+            ?? metrics.actualBoundingBoxDescent
+            ?? size * 0.2);
+        const advance = metrics.width;
+        const glyphWidth = Math.max(1, Math.ceil((metrics.actualBoundingBoxLeft ?? 0) + (metrics.actualBoundingBoxRight ?? 0)) || Math.ceil(advance));
+        const glyphHeight = Math.max(1, ascent + descent);
+        const slotW = glyphWidth + padding * 2;
+        const slotH = glyphHeight + padding * 2;
+        const slot = this._packer.insert(slotW, slotH);
+        // Draw the glyph white into the atlas slot
+        ctx.fillText(char, slot.x + padding + (metrics.actualBoundingBoxLeft ?? 0), slot.y + padding + ascent);
+        const info = {
+            x: slot.x,
+            y: slot.y,
+            width: glyphWidth,
+            height: glyphHeight,
+            advance,
+            ascent,
+            uvLeft: slot.x / this._width,
+            uvTop: slot.y / this._height,
+            uvRight: (slot.x + slotW) / this._width,
+            uvBottom: (slot.y + slotH) / this._height,
+        };
+        return info;
+    }
+}
+
+let _defaultAtlas = null;
+/**
+ * Returns the shared process-wide glyph atlas, creating it lazily on first
+ * call.  All `Text` instances share this atlas so that identical glyph shapes
+ * (same char + family + size + weight + style) are rasterized only once.
+ */
+function getDefaultGlyphAtlas() {
+    if (_defaultAtlas === null) {
+        _defaultAtlas = new DynamicGlyphAtlas();
+    }
+    return _defaultAtlas;
+}
+
+/**
+ * Computes per-glyph quad placements for the given text and style.
+ *
+ * Handles `\n` line breaks and left/center/right alignment. No word-wrap,
+ * no RTL, no ligature shaping — Unicode/diacritics are delegated to the
+ * browser's font engine via canvas `fillText`.
+ *
+ * Returns an empty array for empty text.
+ */
+function layoutText(text, style, atlas) {
+    if (text.length === 0) {
+        return [];
+    }
+    const { fontSize, fontFamily, fontWeight, fontStyle, lineHeight, align } = style;
+    const computedLineHeight = fontSize * lineHeight;
+    const lines = text.split('\n');
+    // Pass 1: gather glyph info per line, track line widths
+    const linePlacements = [];
+    let maxLineWidth = 0;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        const y = lineIndex * computedLineHeight;
+        let cursorX = 0;
+        const placements = [];
+        for (const char of line) {
+            const info = atlas.getGlyph(char, fontFamily, fontSize, fontWeight, fontStyle);
+            placements.push({ info, x: cursorX, y });
+            cursorX += info.advance;
+        }
+        const lineWidth = cursorX;
+        if (lineWidth > maxLineWidth) {
+            maxLineWidth = lineWidth;
+        }
+        linePlacements.push({ placements, width: lineWidth });
+    }
+    // Pass 2: apply alignment and build final GlyphPlacement array
+    const result = [];
+    for (const line of linePlacements) {
+        let offsetX = 0;
+        if (align === 'right') {
+            offsetX = maxLineWidth - line.width;
+        }
+        else if (align === 'center') {
+            offsetX = (maxLineWidth - line.width) / 2;
+        }
+        for (const { info, x, y } of line.placements) {
+            result.push({
+                x: x + offsetX,
+                y,
+                width: info.width,
+                height: info.height,
+                uvLeft: info.uvLeft,
+                uvTop: info.uvTop,
+                uvRight: info.uvRight,
+                uvBottom: info.uvBottom,
+            });
+        }
+    }
+    return result;
+}
+
 class TextStyle {
     _align;
     _fill;
+    _fillColor;
+    _lineHeight;
     _stroke;
     _strokeThickness;
     _fontSize;
     _fontWeight;
     _fontFamily;
+    _fontStyle;
     _wordWrap;
     _wordWrapWidth;
     _baseline;
@@ -17647,11 +17847,14 @@ class TextStyle {
     constructor(options = {}) {
         this._align = options.align ?? 'left';
         this._fill = options.fill ?? 'black';
+        this._fillColor = options.fillColor ?? Color.white.clone();
+        this._lineHeight = options.lineHeight ?? 1.2;
         this._stroke = options.stroke ?? 'black';
         this._strokeThickness = options.strokeThickness ?? 1;
         this._fontSize = options.fontSize ?? 20;
         this._fontWeight = options.fontWeight ?? 'bold';
         this._fontFamily = options.fontFamily ?? 'Arial';
+        this._fontStyle = options.fontStyle ?? 'normal';
         this._wordWrap = options.wordWrap ?? false;
         this._wordWrapWidth = options.wordWrapWidth ?? 100;
         this._baseline = options.baseline ?? 'alphabetic';
@@ -17677,6 +17880,31 @@ class TextStyle {
             this._dirty = true;
         }
     }
+    /**
+     * Runtime fill color applied via `Mesh.tint`. Glyphs are always
+     * rasterized white; this color multiplies them at draw time so that
+     * changing the color never requires re-rasterizing cached glyphs.
+     */
+    get fillColor() {
+        return this._fillColor;
+    }
+    set fillColor(color) {
+        this._fillColor = color;
+        this._dirty = true;
+    }
+    /**
+     * Line-height multiplier applied to `fontSize` when computing vertical
+     * spacing between lines. Defaults to 1.2.
+     */
+    get lineHeight() {
+        return this._lineHeight;
+    }
+    set lineHeight(lineHeight) {
+        if (this._lineHeight !== lineHeight) {
+            this._lineHeight = lineHeight;
+            this._dirty = true;
+        }
+    }
     get stroke() {
         return this._stroke;
     }
@@ -17722,6 +17950,15 @@ class TextStyle {
             this._dirty = true;
         }
     }
+    get fontStyle() {
+        return this._fontStyle;
+    }
+    set fontStyle(fontStyle) {
+        if (this._fontStyle !== fontStyle) {
+            this._fontStyle = fontStyle;
+            this._dirty = true;
+        }
+    }
     get wordWrap() {
         return this._wordWrap;
     }
@@ -17799,11 +18036,14 @@ class TextStyle {
         if (style !== this) {
             this.align = style.align;
             this.fill = style.fill;
+            this._fillColor = style.fillColor.clone();
+            this.lineHeight = style.lineHeight;
             this.stroke = style.stroke;
             this.strokeThickness = style.strokeThickness;
             this.fontSize = style.fontSize;
             this.fontWeight = style.fontWeight;
             this.fontFamily = style.fontFamily;
+            this.fontStyle = style.fontStyle;
             this.wordWrap = style.wordWrap;
             this.wordWrapWidth = style.wordWrapWidth;
             this.baseline = style.baseline;
@@ -17819,26 +18059,81 @@ class TextStyle {
     }
 }
 
-const newLinePattern = /(?:\r\n|\r|\n)/;
-class Text extends Sprite {
+function buildMesh(placements, style) {
+    const n = placements.length;
+    const vertices = new Float32Array(n * 4 * 2);
+    const uvs = new Float32Array(n * 4 * 2);
+    const indices = new Uint16Array(n * 6);
+    for (let i = 0; i < n; i++) {
+        const p = placements[i];
+        const v = i * 8;
+        const u = i * 8;
+        const idx = i * 6;
+        const baseV = i * 4;
+        // Vertices: TL, TR, BR, BL
+        vertices[v + 0] = p.x;
+        vertices[v + 1] = p.y;
+        vertices[v + 2] = p.x + p.width;
+        vertices[v + 3] = p.y;
+        vertices[v + 4] = p.x + p.width;
+        vertices[v + 5] = p.y + p.height;
+        vertices[v + 6] = p.x;
+        vertices[v + 7] = p.y + p.height;
+        // UVs: TL, TR, BR, BL
+        uvs[u + 0] = p.uvLeft;
+        uvs[u + 1] = p.uvTop;
+        uvs[u + 2] = p.uvRight;
+        uvs[u + 3] = p.uvTop;
+        uvs[u + 4] = p.uvRight;
+        uvs[u + 5] = p.uvBottom;
+        uvs[u + 6] = p.uvLeft;
+        uvs[u + 7] = p.uvBottom;
+        // Indices: [TL, TR, BR, TL, BR, BL]
+        indices[idx + 0] = baseV + 0;
+        indices[idx + 1] = baseV + 1;
+        indices[idx + 2] = baseV + 2;
+        indices[idx + 3] = baseV + 0;
+        indices[idx + 4] = baseV + 2;
+        indices[idx + 5] = baseV + 3;
+    }
+    const atlas = getDefaultGlyphAtlas();
+    const mesh = new Mesh({
+        vertices,
+        uvs,
+        indices,
+        texture: atlas.texture,
+    });
+    mesh.tint = style.fillColor;
+    return mesh;
+}
+/**
+ * GPU-accelerated text node that rasterizes individual glyphs into a shared
+ * atlas ({@link DynamicGlyphAtlas}) and renders them as a single quad-per-
+ * glyph {@link Mesh} (one draw call per Text instance).
+ *
+ * Glyphs are always rasterized in white and tinted at runtime via
+ * `Mesh.tint`; changing `style.fillColor` only updates the mesh tint —
+ * no atlas re-rasterization is needed.
+ *
+ * The internal {@link Mesh} is the sole child of this {@link Container}.
+ * All transform properties (position, rotation, scale, origin) are
+ * inherited from {@link Container} → {@link RenderNode}.
+ */
+class Text extends Container {
     _text;
     _style;
-    _canvas;
-    _context;
-    _dirty = true;
-    constructor(text, style, samplerOptions, canvas = document.createElement('canvas')) {
-        super(new Texture(canvas, samplerOptions));
+    _mesh = null;
+    constructor(text, style) {
+        super();
         this._text = text;
         this._style = (style && style instanceof TextStyle) ? style : new TextStyle(style);
-        this._canvas = canvas;
-        this._context = canvas.getContext('2d');
-        this.updateTexture();
+        this._rebuild();
     }
     get text() {
         return this._text;
     }
-    set text(text) {
-        this.setText(text);
+    set text(value) {
+        this.setText(value);
     }
     get style() {
         return this._style;
@@ -17846,98 +18141,43 @@ class Text extends Sprite {
     set style(style) {
         this.setStyle(style);
     }
-    get canvas() {
-        return this._canvas;
-    }
-    set canvas(canvas) {
-        this.setCanvas(canvas);
-    }
     setText(text) {
         if (this._text !== text) {
             this._text = text;
-            this._dirty = true;
+            this._rebuild();
         }
         return this;
     }
     setStyle(style) {
         this._style = (style instanceof TextStyle) ? style : new TextStyle(style);
-        this._dirty = true;
-        return this;
-    }
-    setCanvas(canvas) {
-        if (this._canvas !== canvas) {
-            this._canvas = canvas;
-            this._context = this._getContext(canvas);
-            this._dirty = true;
-            this.texture.setSource.call(this.texture, canvas);
-            this.setTextureFrame(Rectangle.temp.set(0, 0, canvas.width, canvas.height));
-        }
+        this._rebuild();
         return this;
     }
-    updateTexture() {
-        if (this._style && (this._dirty || this._style.dirty)) {
-            const canvas = this._canvas, context = this._context, style = this._style.apply(context), text = style.wordWrap ? this.getWordWrappedText() : this._text, lineHeight = determineFontHeight(context.font) + style.strokeThickness, lines = text.split(newLinePattern), lineMetrics = lines.map((line) => context.measureText(line)), maxLineWidth = lineMetrics.reduce((max, measure) => Math.max(max, measure.width), 0), canvasWidth = Math.ceil((maxLineWidth + style.strokeThickness) + (style.padding * 2)), canvasHeight = Math.ceil((lineHeight * lines.length) + (style.padding * 2));
-            if (canvasWidth !== canvas.width || canvasHeight !== canvas.height) {
-                canvas.width = canvasWidth;
-                canvas.height = canvasHeight;
-                this.setTextureFrame(Rectangle.temp.set(0, 0, canvasWidth, canvasHeight));
-            }
-            else {
-                context.clearRect(0, 0, canvasWidth, canvasHeight);
-            }
-            style.apply(context);
-            for (let i = 0; i < lines.length; i++) {
-                const metrics = lineMetrics[i], lineWidth = (maxLineWidth - metrics.width), offset = (style.align === 'right') ? lineWidth : lineWidth / 2, padding = style.padding + (style.strokeThickness / 2), lineX = metrics.actualBoundingBoxLeft + (style.align === 'left' ? 0 : offset) + padding, lineY = metrics.actualBoundingBoxAscent + (lineHeight * i) + padding;
-                if (style.stroke && style.strokeThickness) {
-                    context.strokeText(lines[i], lineX, lineY);
-                }
-                if (style.fill) {
-                    context.fillText(lines[i], lineX, lineY);
-                }
-            }
-            this.texture.updateSource();
-            this._dirty = false;
-            this._style.dirty = false;
-        }
-        return this;
-    }
-    getWordWrappedText() {
-        const context = this._context, wrapWidth = this._style.wordWrapWidth, lines = this._text.split('\n'), spaceWidth = context.measureText(' ').width;
-        let spaceLeft = wrapWidth, result = '';
-        for (let y = 0; y < lines.length; y++) {
-            const words = lines[y].split(' ');
-            if (y > 0) {
-                result += '\n';
-            }
-            for (let x = 0; x < words.length; x++) {
-                const word = words[x], wordWidth = context.measureText(word).width, pairWidth = wordWidth + spaceWidth;
-                if (pairWidth > spaceLeft) {
-                    if (x > 0) {
-                        result += '\n';
-                    }
-                    spaceLeft = wrapWidth;
-                }
-                else {
-                    spaceLeft -= pairWidth;
-                }
-                result += `${word} `;
-            }
+    destroy() {
+        if (this._mesh !== null) {
+            this._mesh.destroy();
+            this._mesh = null;
         }
-        return result;
+        super.destroy();
     }
-    render(backend) {
-        if (this.visible) {
-            this.updateTexture();
-            super.render(backend);
+    // -----------------------------------------------------------------------
+    _rebuild() {
+        // Remove and discard the old mesh (if any).
+        if (this._mesh !== null) {
+            this.removeChild(this._mesh);
+            this._mesh.destroy();
+            this._mesh = null;
+        }
+        if (this._text.length === 0) {
+            return;
         }
-        return this;
-    }
-    _getContext(canvas) {
-        const context = canvas.getContext('2d');
-        if (context === null) {
-            throw new Error('Could not create a 2D canvas context.');
+        const atlas = getDefaultGlyphAtlas();
+        const placements = layoutText(this._text, this._style, atlas);
+        if (placements.length === 0) {
+            return;
         }
-        return context;
+        this._mesh = buildMesh(placements, this._style);
+        this.addChild(this._mesh);
     }
 }
 
@@ -18519,474 +18759,5 @@ class IndexedDbStore {
     }
 }
 
-const rapierModuleName = '@dimforge/rapier2d-compat';
-const maxCollisionGroup = 15;
-const fullGroupMask = 0xFFFF;
-const defaultDeltaSeconds = 1 / 60;
-const defaultDebugDrawOptions = {
-    lineWidth: 1,
-    solidLineColor: new Color(64, 196, 255, 1),
-    solidFillColor: new Color(64, 196, 255, 0.12),
-    triggerLineColor: new Color(255, 180, 48, 1),
-    triggerFillColor: new Color(255, 180, 48, 0.08),
-};
-const resolveRapierModule = (module) => {
-    const rapier = module;
-    const vector2 = rapier.Vector2;
-    const worldConstructor = rapier.World;
-    const eventQueueConstructor = rapier.EventQueue;
-    const rigidBodyDescFactory = rapier.RigidBodyDesc;
-    const colliderDescFactory = rapier.ColliderDesc;
-    if (typeof vector2 !== 'function' || typeof worldConstructor !== 'function' || typeof eventQueueConstructor !== 'function') {
-        throw new Error('Invalid Rapier module loader result. Expected Vector2, World, and EventQueue exports.');
-    }
-    if (typeof rigidBodyDescFactory !== 'object'
-        || rigidBodyDescFactory === null
-        || typeof colliderDescFactory !== 'object'
-        || colliderDescFactory === null) {
-        throw new Error('Invalid Rapier module loader result. Expected RigidBodyDesc and ColliderDesc exports.');
-    }
-    const activeEvents = rapier.ActiveEvents;
-    const activeCollisionEvents = typeof activeEvents?.COLLISION_EVENTS === 'number'
-        ? activeEvents.COLLISION_EVENTS
-        : undefined;
-    return {
-        init: typeof rapier.init === 'function'
-            ? rapier.init
-            : undefined,
-        vector2: vector2,
-        worldConstructor: worldConstructor,
-        eventQueueConstructor: eventQueueConstructor,
-        rigidBodyDescFactory: rigidBodyDescFactory,
-        colliderDescFactory: colliderDescFactory,
-        activeCollisionEvents,
-    };
-};
-const defaultRapierModuleLoader = async () => {
-    return await import(rapierModuleName);
-};
-const assertFiniteNumber = (value, label) => {
-    if (!Number.isFinite(value)) {
-        throw new Error(`${label} must be a finite number.`);
-    }
-};
-const assertPositiveNumber = (value, label) => {
-    assertFiniteNumber(value, label);
-    if (value <= 0) {
-        throw new Error(`${label} must be greater than zero.`);
-    }
-};
-const assertGroup = (group, label) => {
-    if (!Number.isInteger(group) || group < 0 || group > maxCollisionGroup) {
-        throw new Error(`${label} must be an integer between 0 and ${maxCollisionGroup}.`);
-    }
-};
-const toGroupMask = (groups, fallback) => {
-    if (groups === undefined) {
-        return fallback;
-    }
-    if (typeof groups === 'number') {
-        assertGroup(groups, 'collision group');
-        return 1 << groups;
-    }
-    if (groups.length === 0) {
-        return 0;
-    }
-    return groups.reduce((mask, group, index) => {
-        assertGroup(group, `collision groups[${index}]`);
-        return mask | (1 << group);
-    }, 0);
-};
-const toPackedCollisionGroups = (filter) => {
-    const membershipMask = toGroupMask(filter?.membership, 1 << 0);
-    const collisionMask = toGroupMask(filter?.collidesWith, fullGroupMask);
-    return ((membershipMask & fullGroupMask) << 16) | (collisionMask & fullGroupMask);
-};
-const getOffset = (shape) => ({
-    x: shape.offsetX ?? 0,
-    y: shape.offsetY ?? 0,
-});
-const rotatePoint = (x, y, rotation) => {
-    const cos = Math.cos(rotation);
-    const sin = Math.sin(rotation);
-    return {
-        x: (x * cos) - (y * sin),
-        y: (x * sin) + (y * cos),
-    };
-};
-const assertShape = (shape) => {
-    if (shape.type === 'box') {
-        assertPositiveNumber(shape.width, 'Box width');
-        assertPositiveNumber(shape.height, 'Box height');
-        assertFiniteNumber(shape.offsetX ?? 0, 'Box offsetX');
-        assertFiniteNumber(shape.offsetY ?? 0, 'Box offsetY');
-        assertFiniteNumber(shape.offsetRotation ?? 0, 'Box offsetRotation');
-        return;
-    }
-    assertPositiveNumber(shape.radius, 'Circle radius');
-    assertFiniteNumber(shape.offsetX ?? 0, 'Circle offsetX');
-    assertFiniteNumber(shape.offsetY ?? 0, 'Circle offsetY');
-};
-const assertBodyOptions = (options) => {
-    assertShape(options.shape);
-    assertFiniteNumber(options.friction ?? 0, 'friction');
-    assertFiniteNumber(options.restitution ?? 0, 'restitution');
-    assertFiniteNumber(options.density ?? 0, 'density');
-    assertFiniteNumber(options.gravityScale ?? 1, 'gravityScale');
-    assertFiniteNumber(options.linearDamping ?? 0, 'linearDamping');
-    assertFiniteNumber(options.angularDamping ?? 0, 'angularDamping');
-    toPackedCollisionGroups(options.collisionFilter);
-};
-class RapierPhysicsBinding {
-    _world;
-    _body;
-    _collider;
-    _syncMode;
-    node;
-    bodyType;
-    shape;
-    trigger;
-    constructor(world, node, body, collider, options) {
-        this._world = world;
-        this.node = node;
-        this._body = body;
-        this._collider = collider;
-        this.bodyType = options.type ?? 'dynamic';
-        this.shape = options.shape;
-        this.trigger = options.trigger ?? false;
-        this._syncMode = options.syncMode ?? 'physicsToNode';
-    }
-    get bodyHandle() {
-        return this._body.handle;
-    }
-    get colliderHandle() {
-        return this._collider.handle;
-    }
-    getBody() {
-        return this._body;
-    }
-    get syncMode() {
-        return this._syncMode;
-    }
-    set syncMode(syncMode) {
-        this._syncMode = syncMode;
-    }
-    get x() {
-        return this._body.translation().x;
-    }
-    get y() {
-        return this._body.translation().y;
-    }
-    get rotation() {
-        return this._body.rotation();
-    }
-    setSyncMode(syncMode) {
-        this._syncMode = syncMode;
-        return this;
-    }
-    teleport(x, y, rotation = this.node.rotation) {
-        this._world.writeBodyTransform(this._body, x, y, rotation, true);
-        this.node.setPosition(x, y);
-        this.node.setRotation(rotation);
-        return this;
-    }
-    syncBodyFromNode(wakeUp = true) {
-        this._world.writeBodyTransform(this._body, this.node.x, this.node.y, this.node.rotation, wakeUp);
-        return this;
-    }
-    syncNodeFromBody() {
-        const translation = this._body.translation();
-        this.node.setPosition(translation.x, translation.y);
-        this.node.setRotation(this._body.rotation());
-        return this;
-    }
-    setCollisionFilter(filter) {
-        const groups = toPackedCollisionGroups(filter);
-        this._collider.setCollisionGroups(groups);
-        this._collider.setSolverGroups(groups);
-        return this;
-    }
-    destroy() {
-        this._world.removeBinding(this);
-    }
-}
-class RapierPhysicsWorld {
-    onCollisionEnter = new Signal();
-    onCollisionExit = new Signal();
-    onTriggerEnter = new Signal();
-    onTriggerExit = new Signal();
-    _rapier;
-    _world;
-    _eventQueue;
-    _bindings = new Set();
-    _nodeBindings = new Map();
-    _colliderBindings = new Map();
-    constructor(rapier, world, eventQueue) {
-        this._rapier = rapier;
-        this._world = world;
-        this._eventQueue = eventQueue;
-    }
-    static async create(options = {}) {
-        const moduleLoader = options.moduleLoader ?? defaultRapierModuleLoader;
-        let loadedModule = null;
-        try {
-            loadedModule = await moduleLoader();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Rapier physics module is unavailable. Install "${rapierModuleName}" or provide a custom module loader. Original error: ${message}`, { cause: error });
-        }
-        const rapier = resolveRapierModule(loadedModule);
-        if (typeof rapier.init === 'function') {
-            await rapier.init();
-        }
-        const gravityX = options.gravityX ?? 0;
-        const gravityY = options.gravityY ?? 9.81;
-        assertFiniteNumber(gravityX, 'gravityX');
-        assertFiniteNumber(gravityY, 'gravityY');
-        const world = new rapier.worldConstructor(new rapier.vector2(gravityX, gravityY));
-        const eventQueue = new rapier.eventQueueConstructor(true);
-        return new RapierPhysicsWorld(rapier, world, eventQueue);
-    }
-    get gravity() {
-        return {
-            x: this._world.gravity.x,
-            y: this._world.gravity.y,
-        };
-    }
-    setGravity(x, y) {
-        assertFiniteNumber(x, 'gravityX');
-        assertFiniteNumber(y, 'gravityY');
-        this._world.gravity.x = x;
-        this._world.gravity.y = y;
-        return this;
-    }
-    hasNode(node) {
-        return this._nodeBindings.has(node);
-    }
-    getBinding(node) {
-        return this._nodeBindings.get(node) ?? null;
-    }
-    attachNode(node, options) {
-        if (this._nodeBindings.has(node)) {
-            throw new Error('This SceneNode is already attached to a physics body.');
-        }
-        assertBodyOptions(options);
-        const bodyDescriptor = this.createBodyDescriptor(node, options);
-        const body = this._world.createRigidBody(bodyDescriptor);
-        const colliderDescriptor = this.createColliderDescriptor(options);
-        const collider = this._world.createCollider(colliderDescriptor, body);
-        const binding = new RapierPhysicsBinding(this, node, body, collider, options);
-        this._bindings.add(binding);
-        this._nodeBindings.set(node, binding);
-        this._colliderBindings.set(collider.handle, binding);
-        return binding;
-    }
-    detachNode(node) {
-        const binding = this._nodeBindings.get(node);
-        if (binding) {
-            this.removeBinding(binding);
-        }
-        return this;
-    }
-    step(deltaSeconds = defaultDeltaSeconds) {
-        assertFiniteNumber(deltaSeconds, 'deltaSeconds');
-        if (deltaSeconds < 0) {
-            throw new Error('deltaSeconds must be zero or greater.');
-        }
-        this.applyStepDelta(deltaSeconds);
-        this._world.step(this._eventQueue);
-        this.drainCollisionEvents();
-        this.syncNodeTransforms();
-        return this;
-    }
-    syncNodeTransforms() {
-        for (const binding of this._bindings) {
-            if (binding.syncMode === 'physicsToNode') {
-                binding.syncNodeFromBody();
-            }
-        }
-        return this;
-    }
-    createDebugGraphics(options = {}) {
-        const graphics = new Graphics();
-        graphics.setCullable(false);
-        this.updateDebugGraphics(graphics, options);
-        return graphics;
-    }
-    updateDebugGraphics(graphics, options = {}) {
-        const lineWidth = options.lineWidth ?? defaultDebugDrawOptions.lineWidth;
-        const solidLineColor = options.solidLineColor ?? defaultDebugDrawOptions.solidLineColor;
-        const solidFillColor = options.solidFillColor ?? defaultDebugDrawOptions.solidFillColor;
-        const triggerLineColor = options.triggerLineColor ?? defaultDebugDrawOptions.triggerLineColor;
-        const triggerFillColor = options.triggerFillColor ?? defaultDebugDrawOptions.triggerFillColor;
-        graphics.clear();
-        graphics.lineWidth = lineWidth;
-        for (const binding of this._bindings) {
-            const bodyTranslation = {
-                x: binding.x,
-                y: binding.y,
-            };
-            const rotation = binding.rotation;
-            const lineColor = binding.trigger ? triggerLineColor : solidLineColor;
-            const fillColor = binding.trigger ? triggerFillColor : solidFillColor;
-            graphics.lineColor = lineColor;
-            graphics.fillColor = fillColor;
-            if (binding.shape.type === 'box') {
-                const path = this.buildBoxPath(binding.shape, bodyTranslation.x, bodyTranslation.y, rotation);
-                graphics.drawPolygon(path);
-            }
-            else {
-                const offset = getOffset(binding.shape);
-                const rotatedOffset = rotatePoint(offset.x, offset.y, rotation);
-                graphics.drawCircle(bodyTranslation.x + rotatedOffset.x, bodyTranslation.y + rotatedOffset.y, binding.shape.radius);
-            }
-        }
-        return graphics;
-    }
-    destroy() {
-        for (const binding of Array.from(this._bindings)) {
-            this.removeBinding(binding);
-        }
-        this.onCollisionEnter.destroy();
-        this.onCollisionExit.destroy();
-        this.onTriggerEnter.destroy();
-        this.onTriggerExit.destroy();
-    }
-    writeBodyTransform(body, x, y, rotation, wakeUp) {
-        body.setTranslation(new this._rapier.vector2(x, y), wakeUp);
-        body.setRotation(rotation, wakeUp);
-    }
-    removeBinding(binding) {
-        if (!this._bindings.has(binding)) {
-            return;
-        }
-        this._bindings.delete(binding);
-        this._nodeBindings.delete(binding.node);
-        this._colliderBindings.delete(binding.colliderHandle);
-        this._world.removeRigidBody(binding.getBody());
-    }
-    createBodyDescriptor(node, options) {
-        const type = options.type ?? 'dynamic';
-        let descriptor = this._rapier.rigidBodyDescFactory.dynamic();
-        switch (type) {
-            case 'static':
-                descriptor = this._rapier.rigidBodyDescFactory.fixed();
-                break;
-            case 'kinematic':
-                if (typeof this._rapier.rigidBodyDescFactory.kinematicPositionBased === 'function') {
-                    descriptor = this._rapier.rigidBodyDescFactory.kinematicPositionBased();
-                }
-                else if (typeof this._rapier.rigidBodyDescFactory.kinematicVelocityBased === 'function') {
-                    descriptor = this._rapier.rigidBodyDescFactory.kinematicVelocityBased();
-                }
-                else {
-                    throw new Error('Rapier module does not expose a kinematic rigid-body descriptor.');
-                }
-                break;
-            default:
-                descriptor = this._rapier.rigidBodyDescFactory.dynamic();
-                break;
-        }
-        descriptor
-            .setTranslation(node.x, node.y)
-            .setRotation(node.rotation)
-            .setLinearDamping(options.linearDamping ?? 0)
-            .setAngularDamping(options.angularDamping ?? 0)
-            .setGravityScale(options.gravityScale ?? 1)
-            .lockRotations(options.lockRotation ?? false);
-        return descriptor;
-    }
-    createColliderDescriptor(options) {
-        const shape = options.shape;
-        const descriptor = shape.type === 'box'
-            ? this._rapier.colliderDescFactory.cuboid(shape.width / 2, shape.height / 2)
-            : this._rapier.colliderDescFactory.ball(shape.radius);
-        const offset = getOffset(shape);
-        const groups = toPackedCollisionGroups(options.collisionFilter);
-        descriptor
-            .setTranslation(offset.x, offset.y)
-            .setRotation(shape.type === 'box' ? (shape.offsetRotation ?? 0) : 0)
-            .setSensor(options.trigger ?? false)
-            .setFriction(options.friction ?? 0.5)
-            .setRestitution(options.restitution ?? 0)
-            .setDensity(options.density ?? 1)
-            .setCollisionGroups(groups)
-            .setSolverGroups(groups);
-        const collisionEvents = this._rapier.activeCollisionEvents;
-        if (typeof collisionEvents === 'number') {
-            descriptor.setActiveEvents(collisionEvents);
-        }
-        return descriptor;
-    }
-    applyStepDelta(deltaSeconds) {
-        const worldWithTimestep = this._world;
-        if (typeof worldWithTimestep.timestep === 'number') {
-            worldWithTimestep.timestep = deltaSeconds;
-        }
-        if (worldWithTimestep.integrationParameters
-            && typeof worldWithTimestep.integrationParameters.dt === 'number') {
-            worldWithTimestep.integrationParameters.dt = deltaSeconds;
-        }
-    }
-    drainCollisionEvents() {
-        this._eventQueue.drainCollisionEvents((handleA, handleB, started) => {
-            const first = this._colliderBindings.get(handleA);
-            const second = this._colliderBindings.get(handleB);
-            if (!first || !second) {
-                return;
-            }
-            const trigger = first.trigger || second.trigger;
-            const event = {
-                started,
-                trigger,
-                first,
-                second,
-            };
-            if (trigger) {
-                if (started) {
-                    this.onTriggerEnter.dispatch(event);
-                }
-                else {
-                    this.onTriggerExit.dispatch(event);
-                }
-                return;
-            }
-            if (started) {
-                this.onCollisionEnter.dispatch(event);
-            }
-            else {
-                this.onCollisionExit.dispatch(event);
-            }
-        });
-    }
-    buildBoxPath(shape, bodyX, bodyY, bodyRotation) {
-        const halfWidth = shape.width / 2;
-        const halfHeight = shape.height / 2;
-        const corners = [
-            { x: -halfWidth, y: -halfHeight },
-            { x: halfWidth, y: -halfHeight },
-            { x: halfWidth, y: halfHeight },
-            { x: -halfWidth, y: halfHeight },
-        ];
-        const offset = getOffset(shape);
-        const offsetRotation = shape.offsetRotation ?? 0;
-        const path = [];
-        for (const corner of corners) {
-            const local = rotatePoint(corner.x, corner.y, offsetRotation);
-            const withOffset = {
-                x: local.x + offset.x,
-                y: local.y + offset.y,
-            };
-            const worldPoint = rotatePoint(withOffset.x, withOffset.y, bodyRotation);
-            path.push(bodyX + worldPoint.x, bodyY + worldPoint.y);
-        }
-        return path;
-    }
-}
-const createRapierPhysicsWorld = async (options = {}) => {
-    return await RapierPhysicsWorld.create(options);
-};
-
-export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, RapierPhysicsBinding, RapierPhysicsWorld, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRapierPhysicsWorld, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign$1 as sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
+export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, DynamicGlyphAtlas, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, layoutText, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign$1 as sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map