@codexo/exojs 0.6.7 → 0.6.9

package/CHANGELOG.md

@@ -4,6 +4,125 @@ All notable changes to ExoJS are documented in this file.
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.9] - 2026-05-02
+
+> **Heads-up — breaking change despite the patch number.** `Text`'s
+> internal architecture changed completely: glyph-quad meshing
+> against a runtime atlas instead of canvas2d-rasterize-as-Sprite.
+> The user-facing API for `text.text`, `text.style`, and standard
+> Drawable transforms (`position`, `rotation`, `scale`, etc.) is
+> unchanged, but `text.canvas`, `text.setCanvas`, `text.textureFrame`,
+> `text.getWordWrappedText`, and the `Text instanceof Sprite` check
+> are gone. Text is now `Text extends Container`, not Sprite.
+
+GPU font glyphs (Pixi-style runtime cache). Replaces the prior
+canvas-rasterize-the-whole-string-as-Sprite path with: rasterize
+each glyph once into a shared atlas Texture, build a single Mesh
+per Text whose quads sample the atlas. All Texts in the page share
+one atlas — memory-efficient at scale, single drawcall per Text.
+
+### Added
+
+- **`DynamicGlyphAtlas`** — public class. Constructor takes
+  `width = 1024, height = 1024`. Has `getGlyph(char, family, size,
+  weight, style) → GlyphInfo` (cached or rasterizes), `clear()` to
+  reset, and `texture` for binding to a Mesh. Internal shelf
+  bin-packing; throws on atlas-full (LRU eviction is V2).
+- **`layoutText(text, style, atlas)`** — pure function. Returns
+  `readonly GlyphPlacement[]` with one quad per visible glyph.
+  Handles `\n` line breaks and `align: 'left' | 'center' | 'right'`
+  alignment per `style.align`. Empty text returns `[]`.
+- **Types: `GlyphInfo`, `GlyphPlacement`, `GlyphKey`,
+  `TextAlignment`** — all exported for users who want to compose
+  their own atlas / layout pipelines.
+- **TextStyle gets `fillColor: Color`** (defaults to white, used
+  via mesh.tint after glyph rasterization), **`fontStyle: 'normal'
+  | 'italic'`**, and **`lineHeight: number`** (multiplied by
+  fontSize for line spacing, defaults to 1.2). `align` field is
+  now strongly typed as `TextAlignment`.
+
+### Changed
+
+- **`Text` extends `Container`** (was `Sprite`). It internally
+  manages a single `Mesh` child whose vertices/uvs/indices are
+  rebuilt on every `text` / `style` setter call. Empty string =
+  no internal mesh (no children).
+- **Glyphs always rasterize white**; `style.fillColor` becomes
+  `mesh.tint`. Changing fillColor is cheap (mesh-tint update only,
+  no atlas re-rasterization).
+
+### Removed
+
+- `Text.canvas` getter / setter, `Text.setCanvas(...)`,
+  `Text.textureFrame`, `Text.updateTexture(...)`,
+  `Text.getWordWrappedText(...)` — the old canvas2d path is gone.
+  Word-wrapping is V2; for now use `\n` for explicit line breaks.
+
+### Notes
+
+- Atlas is a process-wide singleton via `getDefaultGlyphAtlas()`
+  (internal helper, not a public function). All `Text` instances
+  share one atlas. Tests can reset it via `atlas.clear()`.
+- The atlas uses `OffscreenCanvas` when available, falls back to
+  `document.createElement('canvas')` (works in jsdom / older
+  browsers).
+- First-render of a never-seen glyph costs one canvas2d round-trip
+  + texture re-upload. Cached glyphs are zero-cost on subsequent
+  renders.
+- Per-character animation, MSDF rendering, word-wrap, BiDi, and
+  text outlines / drop-shadows are all V2.
+
+## [0.6.8] - 2026-05-02
+
+> **Heads-up — breaking change despite the patch number.** Removes
+> the optional Rapier physics integration in its entirety. Pre-1.0
+> SemVer permits breaking changes within the 0.x.y line; we kept
+> the minor digit unchanged because the integration was opt-in and
+> usage outside the engine is presumed minimal.
+
+### Removed
+
+- **`createRapierPhysicsWorld` factory and the `RapierPhysicsWorld`
+  / `RapierPhysicsBinding` classes.** Plus the entire associated
+  type surface (`PhysicsBodyOptions`, `PhysicsBodyType`,
+  `PhysicsBoxShape`, `PhysicsCircleShape`, `PhysicsColliderShape`,
+  `PhysicsCollisionFilter`, `PhysicsSyncMode`, `RapierModuleLoader`,
+  `RapierPhysicsDebugDrawOptions`, `RapierPhysicsEvent`,
+  `RapierPhysicsWorldOptions`).
+- **`@dimforge/rapier2d-compat` peerDependency.** Removed from
+  `package.json` along with the `peerDependenciesMeta` entry that
+  marked it optional.
+- **README's "Optional Rapier Physics" section** and the
+  feature-list bullets that mentioned it.
+- **`src/physics/`** and **`test/physics/`** directories deleted.
+
+### Migration
+
+Apps that depended on `createRapierPhysicsWorld` need to integrate
+Rapier (or any other physics library) directly in their own code
+without library involvement. The adapter was always intentionally
+narrow — it bound Rapier bodies to scene nodes from the outside,
+no rendering / application / core scene code referenced physics.
+Removing it is therefore mechanical for downstream consumers:
+
+```ts
+// Before (≤ 0.6.7)
+import { createRapierPhysicsWorld } from '@codexo/exojs';
+const physics = await createRapierPhysicsWorld({ gravityY: 9.81 });
+
+// After (0.6.8+) — pull Rapier directly:
+import RAPIER from '@dimforge/rapier2d-compat';
+await RAPIER.init();
+const physics = new RAPIER.World({ x: 0, y: 9.81 });
+// Sync bodies to your scene-node positions in your app's update loop.
+```
+
+The motivation: ExoJS doesn't want to be a thin wrapper around
+Rapier's API, and keeping the integration around tied the library
+to a specific physics library forever. Removing it cleans the
+boundary — ExoJS is rendering + scene + input; physics is the
+user's choice.
+
 ## [0.6.7] - 2026-05-02
 
 Touch / multi-touch / pointer support, fully unified — no separate

package/README.md

@@ -14,7 +14,6 @@ ExoJS is **pre-1.0**. The public API is still under active design — scene grap
 - Practical visuals: filters, masks, render passes, cache-as-bitmap
 - Gameplay tools: animated sprites, scene stacking, camera helpers, audio sprites
 - Performance visibility with built-in render stats and benchmark harness
-- Optional Rapier physics integration without forcing physics on every app
 
 ## What Is Shipped Today
 
@@ -25,7 +24,6 @@ ExoJS is **pre-1.0**. The public API is still under active design — scene grap
 - View/camera helpers (`follow`, bounds clamp, shake, zoom)
 - Rendering composition primitives (`RenderTexture`, `RenderTargetPass`, filter chains, visual masks, cache-as-bitmap)
 - Render stats (`submittedNodes`, `culledNodes`, `drawCalls`, `batches`, `renderPasses`, ...)
-- Optional Rapier adapter (`createRapierPhysicsWorld`)
 
 ## Installation
 
@@ -98,40 +96,6 @@ new Application({ backend: { type: 'webgl2' } });
 new Application({ backend: { type: 'auto' } });
 ```
 
-## Optional Rapier Physics
-
-Rapier integration is opt-in and loaded only when you use it.
-
-```ts
-import { createRapierPhysicsWorld } from '@codexo/exojs';
-
-const physics = await createRapierPhysicsWorld({ gravityY: 9.81 });
-```
-
-If Rapier is unavailable, creation fails with a clear setup error.
-
-### Physics scope policy
-
-ExoJS ships **one** physics adapter: Rapier. The integration is intentionally
-narrow:
-
-- Physics is **optional**. `@dimforge/rapier2d-compat` is a peer dependency
-  marked `optional`. Apps that do not call `createRapierPhysicsWorld` never
-  load it and never pay for it at runtime.
-- Rendering, application, and core scene code **do not** depend on physics.
-  The adapter binds Rapier bodies to scene nodes from the outside; the core
-  has no knowledge of physics.
-- ExoJS is **not** a physics-engine abstraction layer. There is no
-  `PhysicsWorld` interface that spans multiple backends, and no plan to
-  add one. If you need a different physics library, integrate it directly
-  in your app code without library involvement.
-- A second physics adapter (Box2D, Matter.js, Planck, etc.) is **not** on
-  the 1.0 roadmap and will not be accepted as a contribution. The honesty
-  rule that applies to rendering backends applies here too: one chosen
-  physics, not a fake-universal physics layer.
-
-For full integration details see [docs/physics/rapier-integration.md](docs/physics/rapier-integration.md).
-
 ## Examples
 
 The runnable live site (Astro + Lit + Monaco preview) lives in [`examples/`](examples/README.md) and is deployed as the repository's GitHub Pages site at <https://exoridus.github.io/ExoJS/>.

package/dist/esm/index.d.ts

@@ -5,4 +5,3 @@ export * from './math/index';
 export * from './particles/index';
 export * from './rendering/index';
 export * from './resources/index';
-export * from './physics/index';

package/dist/esm/index.js

@@ -70,7 +70,9 @@ export { ShaderUniform } from './rendering/shader/ShaderUniform.js';
 export { Sprite, SpriteFlags } from './rendering/sprite/Sprite.js';
 export { Spritesheet } from './rendering/sprite/Spritesheet.js';
 export { AnimatedSprite } from './rendering/sprite/AnimatedSprite.js';
+export { DynamicGlyphAtlas } from './rendering/text/DynamicGlyphAtlas.js';
 export { Text } from './rendering/text/Text.js';
+export { layoutText } from './rendering/text/TextLayout.js';
 export { TextStyle } from './rendering/text/TextStyle.js';
 export { RenderTexture } from './rendering/texture/RenderTexture.js';
 export { Sampler } from './rendering/texture/Sampler.js';
@@ -129,5 +131,4 @@ export { VideoFactory } from './resources/factories/VideoFactory.js';
 export { BinaryFactory } from './resources/factories/BinaryFactory.js';
 export { VttFactory } from './resources/factories/VttFactory.js';
 export { WasmFactory } from './resources/factories/WasmFactory.js';
-export { RapierPhysicsBinding, RapierPhysicsWorld, createRapierPhysicsWorld } from './physics/RapierPhysicsWorld.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/rendering/index.d.ts

@@ -6,8 +6,11 @@ export * from './shader/ShaderUniform';
 export * from './sprite/Sprite';
 export * from './sprite/Spritesheet';
 export * from './sprite/AnimatedSprite';
+export * from './text/DynamicGlyphAtlas';
 export * from './text/Text';
+export * from './text/TextLayout';
 export * from './text/TextStyle';
+export * from './text/types';
 export * from './texture/RenderTexture';
 export * from './texture/Sampler';
 export * from './texture/Texture';

package/dist/esm/rendering/text/DynamicGlyphAtlas.d.ts

@@ -0,0 +1,33 @@
+import { Texture } from '@/rendering/texture/Texture';
+import type { GlyphInfo } from './types';
+/**
+ * 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.
+ */
+export declare class DynamicGlyphAtlas {
+    readonly texture: Texture;
+    private readonly _canvas;
+    private readonly _ctx;
+    private readonly _packer;
+    private readonly _cache;
+    private readonly _width;
+    private readonly _height;
+    constructor(width?: number, height?: number);
+    /**
+     * Returns the cached GlyphInfo for the given character + font parameters,
+     * rasterizing it into the atlas if not already present.
+     */
+    getGlyph(char: string, family: string, size: number, weight: string | number, style: 'normal' | 'italic'): GlyphInfo;
+    /**
+     * Clears all cached glyphs and resets the atlas packer.
+     * The underlying canvas pixels are also cleared.
+     */
+    clear(): void;
+    private _rasterize;
+}

package/dist/esm/rendering/text/DynamicGlyphAtlas.js

@@ -0,0 +1,140 @@
+import { Texture } from '../texture/Texture.js';
+
+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;
+    }
+}
+
+export { DynamicGlyphAtlas };
+//# sourceMappingURL=DynamicGlyphAtlas.js.map

package/dist/esm/rendering/text/DynamicGlyphAtlas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamicGlyphAtlas.js","sources":["../../../../../src/rendering/text/DynamicGlyphAtlas.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/esm/rendering/text/Text.d.ts

@@ -1,26 +1,30 @@
-import { Sprite } from '@/rendering/sprite/Sprite';
+import { Container } from '@/rendering/Container';
 import type { TextStyleOptions } from './TextStyle';
 import { TextStyle } from './TextStyle';
-import type { SamplerOptions } from '@/rendering/texture/Sampler';
-import type { RenderBackend } from '../RenderBackend';
-export declare class Text extends Sprite {
+/**
+ * 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}.
+ */
+export declare class Text extends Container {
     private _text;
     private _style;
-    private _canvas;
-    private _context;
-    private _dirty;
-    constructor(text: string, style?: TextStyle | TextStyleOptions, samplerOptions?: Partial<SamplerOptions>, canvas?: HTMLCanvasElement);
+    private _mesh;
+    constructor(text: string, style?: TextStyle | TextStyleOptions);
     get text(): string;
-    set text(text: string);
+    set text(value: string);
     get style(): TextStyle;
-    set style(style: TextStyle);
-    get canvas(): HTMLCanvasElement;
-    set canvas(canvas: HTMLCanvasElement);
+    set style(style: TextStyle | TextStyleOptions);
     setText(text: string): this;
     setStyle(style: TextStyle | TextStyleOptions): this;
-    setCanvas(canvas: HTMLCanvasElement): this;
-    updateTexture(): this;
-    getWordWrappedText(): string;
-    render(backend: RenderBackend): this;
-    private _getContext;
+    destroy(): void;
+    private _rebuild;
 }