@bloopjs/toodle 0.0.100

package/dist/src/utils/pool.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A simple pool for creating and reusing objects to avoid allocation between frames
+ *
+ * @example
+ *
+ * const pool = new Pool(() => new SomeObject(), 10);
+ *
+ * function animate() {
+ *   const obj = pool.get();
+ *   console.log(obj);
+ *   pool.free();
+ *   requestAnimationFrame(animate);
+ * }
+ *
+ * requestAnimationFrame(animate);
+ */
+export declare class Pool<T> {
+    #private;
+    constructor(create: () => T, initialSize?: number);
+    get(): T;
+    free(): void;
+}

package/dist/src/utils/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../../src/utils/pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,IAAI,CAAC,CAAC;;gBAKL,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,SAAI;IAS5C,GAAG;IAQH,IAAI;CAGL"}

package/dist/test/math/matrix.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/scene/Batcher.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/scene/SceneNode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/shader/parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/text/FontPipeline.d.ts

@@ -0,0 +1,14 @@
+import type { MsdfFont } from "./MsdfFont";
+/**
+ * A webgpu pipeline for rendering blocks of text with a given font.
+ */
+export declare class FontPipeline {
+    pipeline: GPURenderPipeline;
+    font: MsdfFont;
+    fontBindGroup: GPUBindGroup;
+    maxCharCount: number;
+    constructor(pipeline: GPURenderPipeline, font: MsdfFont, fontBindGroup: GPUBindGroup, maxCharCount: number);
+    static create(device: GPUDevice, font: MsdfFont, colorFormat: GPUTextureFormat, maxCharCount: number): Promise<FontPipeline>;
+}
+export declare function pipelinePromise(device: GPUDevice, colorFormat: GPUTextureFormat, label: string): Promise<GPURenderPipeline>;
+//# sourceMappingURL=FontPipeline.d.ts.map

package/dist/text/FontPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontPipeline.d.ts","sourceRoot":"","sources":["../../src/text/FontPipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;GAEG;AACH,qBAAa,YAAY;IAEd,QAAQ,EAAE,iBAAiB;IAC3B,IAAI,EAAE,QAAQ;IACd,aAAa,EAAE,YAAY;IAC3B,YAAY,EAAE,MAAM;gBAHpB,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,YAAY,EAC3B,YAAY,EAAE,MAAM;WAGhB,MAAM,CACjB,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,QAAQ,EACd,WAAW,EAAE,gBAAgB,EAC7B,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,YAAY,CAAC;CAuEzB;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,gBAAgB,EAC7B,KAAK,EAAE,MAAM,8BA4Cd"}

package/dist/text/MsdfFont.d.ts

@@ -0,0 +1,82 @@
+export type KerningMap = Map<number, Map<number, number>>;
+export interface MsdfChar {
+    id: number;
+    index: number;
+    char: string;
+    width: number;
+    height: number;
+    xoffset: number;
+    yoffset: number;
+    xadvance: number;
+    chnl: number;
+    x: number;
+    y: number;
+    page: number;
+    charIndex: number;
+}
+export declare class MsdfFont {
+    #private;
+    id: string;
+    json: MsdfFontJson;
+    imageBitmap: ImageBitmap;
+    /** the name of the font */
+    name: string;
+    /** the set of available characters in the font texture */
+    charset: string[];
+    charCount: number;
+    lineHeight: number;
+    /** a binary buffer of character data for loading into the gpu */
+    charBuffer: Float32Array;
+    constructor(id: string, json: MsdfFontJson, imageBitmap: ImageBitmap);
+    getChar(charCode: number): MsdfChar;
+    getXAdvance(charCode: number, nextCharCode?: number): number;
+    static create(id: string, fontJsonUrl: URL): Promise<MsdfFont>;
+    set fallbackCharacter(character: string);
+}
+type MsdfFontJson = {
+    pages: string[];
+    chars: MsdfChar[];
+    info: {
+        face: string;
+        size: string;
+        bold: number;
+        italic: number;
+        charset: string[];
+        unicode: number;
+        stretchH: number;
+        smooth: number;
+        aa: number;
+        padding: number[];
+        spacing: number[];
+    };
+    common: {
+        lineHeight: number;
+        base: number;
+        scaleW: number;
+        scaleH: number;
+        pages: number;
+        packed: number;
+        alphaChnl: number;
+        redChnl: number;
+        greenChnl: number;
+        blueChnl: number;
+    };
+    distanceField: {
+        fieldType: string;
+        distanceRange: number;
+    };
+    kernings: Kerning[];
+};
+type Kerning = {
+    first: number;
+    second: number;
+    amount: number;
+};
+export declare enum WhitespaceKeyCodes {
+    HorizontalTab = 9,
+    Newline = 10,
+    CarriageReturn = 13,
+    Space = 32
+}
+export {};
+//# sourceMappingURL=MsdfFont.d.ts.map

package/dist/text/MsdfFont.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MsdfFont.d.ts","sourceRoot":"","sources":["../../src/text/MsdfFont.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAE1D,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,QAAQ;;IAgBV,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,WAAW;IAjBjC,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IAEnB,iEAAiE;IACjE,UAAU,EAAE,YAAY,CAAC;gBAOhB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,YAAY,EAClB,WAAW,EAAE,WAAW;IA0CjC,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ;IAiBnC,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,SAAK,GAAG,MAAM;WAW3C,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC;IAuBpE,IAAI,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAWtC;CACF;AAED,KAAK,YAAY,GAAG;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,IAAI,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IACF,MAAM,EAAE;QACN,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,aAAa,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5D,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB,CAAC;AAEF,KAAK,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjE,oBAAY,kBAAkB;IAC5B,aAAa,IAAI;IACjB,OAAO,KAAK;IACZ,cAAc,KAAK;IACnB,KAAK,KAAK;CACX"}

package/dist/text/TextFormatting.d.ts

@@ -0,0 +1,19 @@
+import type { Color } from "../coreTypes/Color";
+export interface TextFormatting {
+    align?: "left" | "right" | "center";
+    fontSize?: number;
+    color?: Color;
+    wordWrap?: WordWrapOptions;
+    shrinkToFit?: ShrinkToFitOptions;
+}
+export type WordWrapOptions = {
+    emWidth: number;
+    breakOn?: "word" | "character";
+};
+export type ShrinkToFitOptions = {
+    minFontSize: number;
+    maxFontSize?: number;
+    maxLines?: number;
+    padding?: number;
+};
+//# sourceMappingURL=TextFormatting.d.ts.map

package/dist/text/TextFormatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextFormatting.d.ts","sourceRoot":"","sources":["../../src/text/TextFormatting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,MAAM,WAAW,cAAc;IAE7B,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IAEpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,KAAK,CAAC,EAAE,KAAK,CAAC;IAGd,QAAQ,CAAC,EAAE,eAAe,CAAC;IAG3B,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/text/TextNode.d.ts

@@ -0,0 +1,19 @@
+import type { Color } from "../coreTypes/Color";
+import { type NodeOptions, SceneNode } from "../scene/SceneNode";
+import type { MsdfFont } from "./MsdfFont";
+import type { TextFormatting } from "./TextFormatting";
+import type { TextShader } from "./TextShader";
+export declare const DEFAULT_FONT_SIZE = 14;
+export declare class TextNode extends SceneNode {
+    #private;
+    constructor(shader: TextShader, text: string, opts?: TextOptions);
+    get text(): string;
+    get formatting(): TextFormatting;
+    get font(): MsdfFont;
+    set text(text: string);
+    get tint(): Color;
+    set tint(tint: Color);
+    set formatting(formatting: TextFormatting);
+}
+export type TextOptions = Omit<NodeOptions, "render"> & TextFormatting;
+//# sourceMappingURL=TextNode.d.ts.map

package/dist/text/TextNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextNode.d.ts","sourceRoot":"","sources":["../../src/text/TextNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,KAAK,WAAW,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,qBAAa,QAAS,SAAQ,SAAS;;gBAKzB,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB;IAgCpE,IAAI,IAAI,IAYO,MAAM,CAVpB;IAED,IAAI,UAAU,IAyBa,cAAc,CAvBxC;IAED,IAAI,IAAI,aAEP;IAED,IAAI,IAAI,CAAC,IAAI,EAAE,MAAM,EAMpB;IAED,IAAI,IAAI,IAIO,KAAK,CAFnB;IAED,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAGnB;IAED,IAAI,UAAU,CAAC,UAAU,EAAE,cAAc,EAGxC;CACF;AAED,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,cAAc,CAAC"}

package/dist/text/TextShader.d.ts

@@ -0,0 +1,15 @@
+import type { SceneNode } from "../scene/SceneNode";
+import type { EngineUniform } from "../shaders/EngineUniform";
+import type { IShader } from "../shaders/IShader";
+import type { FontPipeline } from "./FontPipeline";
+import type { MsdfFont } from "./MsdfFont";
+export declare class TextShader implements IShader {
+    #private;
+    constructor(device: GPUDevice, pipeline: FontPipeline, font: MsdfFont, colorFormat: GPUTextureFormat, instanceCount: number);
+    startFrame(device: GPUDevice, uniform: EngineUniform): void;
+    processBatch(renderPass: GPURenderPassEncoder, nodes: SceneNode[]): number;
+    endFrame(): void;
+    get font(): MsdfFont;
+    get maxCharCount(): number;
+}
+//# sourceMappingURL=TextShader.d.ts.map

package/dist/text/TextShader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextShader.d.ts","sourceRoot":"","sources":["../../src/text/TextShader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAY3C,qBAAa,UAAW,YAAW,OAAO;;gBAetC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,QAAQ,EACd,WAAW,EAAE,gBAAgB,EAC7B,aAAa,EAAE,MAAM;IAoEvB,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAU3D,YAAY,CAAC,UAAU,EAAE,oBAAoB,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM;IAiG1E,QAAQ,IAAI,IAAI;IAIhB,IAAI,IAAI,aAEP;IAED,IAAI,YAAY,WAEf;CACF"}

package/dist/text/mod.d.ts

@@ -0,0 +1,4 @@
+export type { TextOptions } from "./TextNode";
+export { TextNode } from "./TextNode";
+export { TextShader } from "./TextShader";
+//# sourceMappingURL=mod.d.ts.map

package/dist/text/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/text/mod.ts"],"names":[],"mappings":"AAKA,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/dist/text/shaping.d.ts

@@ -0,0 +1,39 @@
+import type { Size } from "../coreTypes/Size";
+import { type MsdfChar, type MsdfFont } from "./MsdfFont";
+import type { TextFormatting, WordWrapOptions } from "./TextFormatting";
+export interface MsdfTextMeasurements {
+    /** The width of the text block in em units. */
+    width: number;
+    /** The height of the text block in em units. */
+    height: number;
+    /** The width of each line in em units. */
+    lineWidths: number[];
+    /** The number of lines in the text block. */
+    lineCount: number;
+    /** The number of characters printed in the text block. */
+    printedCharCount: number;
+    /** All words in the text block */
+    words: Word[];
+}
+export type Glyph = {
+    char: MsdfChar;
+    offset: [number, number];
+    line: number;
+};
+export type Word = {
+    glyphs: Glyph[];
+    width: number;
+    startX: number;
+    startY: number;
+};
+export declare function shapeText(font: MsdfFont, text: string, blockSize: Size, fontSize: number, formatting: TextFormatting, textArray: Float32Array, initialFloatOffset?: number, debug?: boolean): void;
+/**
+ * Measure the text and return measurements for block + each glyph.
+ * @param font - The font to use.
+ * @param text - The text to measure
+ * @param wordWrap - Maximum word length before word wrapping
+ * @returns The measurements of the text in em units.
+ */
+export declare function measureText(font: MsdfFont, text: string, wordWrap?: WordWrapOptions): MsdfTextMeasurements;
+export declare function findLargestFontSize(font: MsdfFont, text: string, size: Size, formatting: TextFormatting): number | undefined;
+//# sourceMappingURL=shaping.d.ts.map

package/dist/text/shaping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaping.d.ts","sourceRoot":"","sources":["../../src/text/shaping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAsB,MAAM,YAAY,CAAC;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AASxE,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,gBAAgB,EAAE,MAAM,CAAC;IAEzB,kCAAkC;IAClC,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AAED,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,SAAS,CACvB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,IAAI,EACf,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,cAAc,EAC1B,SAAS,EAAE,YAAY,EACvB,kBAAkB,SAAI,EACtB,KAAK,UAAQ,QAgEd;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,eAAe,GACzB,oBAAoB,CA+GtB;AACD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,cAAc,GACzB,MAAM,GAAG,SAAS,CAqCpB"}

package/dist/text/text.wgsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "\n// Adapted from: https://webgpu.github.io/webgpu-samples/?sample=textRenderingMsdf\n\n// Quad vertex positions for a character\nconst pos = array(\n  vec2f(0, -1),\n  vec2f(1, -1),\n  vec2f(0,  0),\n  vec2f(1,  0),\n);\n\n// Debug colors for visualization\nconst debugColors = array(\n  vec4f(1, 0, 0, 1),\n  vec4f(0, 1, 0, 1),\n  vec4f(0, 0, 1, 1),\n  vec4f(1, 1, 1, 1),\n);\n\n// Vertex input from GPU\nstruct VertexInput {\n  @builtin(vertex_index) vertex: u32,\n  @builtin(instance_index) instance: u32,\n};\n\n// Output from vertex shader to fragment shader\nstruct VertexOutput {\n  @builtin(position) position: vec4f,\n  @location(0) texcoord: vec2f,\n  @location(1) debugColor: vec4f,\n  @location(2) @interpolate(flat) instanceIndex: u32,\n};\n\n// Metadata for a single character glyph\nstruct Char {\n  texOffset: vec2f, // Offset to top-left in MSDF texture (pixels)\n  texExtent: vec2f, // Size in texture (pixels)\n  size: vec2f,      // Glyph size in ems\n  offset: vec2f,    // Position offset in ems\n};\n\n// Metadata for a text block\nstruct TextBlockDescriptor {\n  transform: mat3x3f,   // Text transform matrix (model matrix)\n  color: vec4f,         // Text color\n  fontSize: f32,        // Font size\n  blockWidth: f32,      // Total width of text block\n  blockHeight: f32,     // Total height of text block\n  bufferPosition: f32   // Index and length in textBuffer\n};\n\n// Font bindings\n@group(0) @binding(0) var fontTexture: texture_2d<f32>;\n@group(0) @binding(1) var fontSampler: sampler;\n@group(0) @binding(2) var<storage> chars: array<Char>;\n@group(0) @binding(3) var<uniform> fontData: vec4f; // Contains line height (x)\n\n// Text bindings\n@group(1) @binding(0) var<storage> texts: array<TextBlockDescriptor>;\n@group(1) @binding(1) var<storage> textBuffer: array<vec4f>; // Each vec4: xy = glyph pos, z = char index\n\n// Global uniforms\n@group(2) @binding(0) var<uniform> viewProjectionMatrix: mat3x3f;\n\n// Vertex shader\n@vertex\nfn vertexMain(input: VertexInput) -> VertexOutput {\n  // Because the instance index is used for character indexing, we are\n  // overloading the vertex index to store the instance of the text metadata.\n  //\n  // I.e...\n  // Vertex 0-4 = Instance 0, Vertex 0-4\n  // Vertex 4-8 = Instance 1, Vertex 0-4\n  // Vertex 8-12 = Instance 2, Vertex 0-4\n  let vertexIndex = input.vertex % 4;\n  let textIndex = input.vertex / 4;\n\n  let text = texts[textIndex];\n  let textElement = textBuffer[u32(text.bufferPosition) + input.instance];\n  let char = chars[u32(textElement.z)];\n\n  let lineHeight = fontData.x;\n  let textWidth = text.blockWidth;\n  let textHeight = text.blockHeight;\n\n  // Center text vertically; origin is mid-height\n  let offset = vec2f(0, -textHeight / 2);\n\n  // Glyph position in ems (quad pos * size + per-char offset)\n  let emPos = pos[vertexIndex] * char.size + char.offset + textElement.xy - offset;\n  let charPos = emPos * (text.fontSize / lineHeight);\n\n  var output: VertexOutput;\n  let transformedPosition = viewProjectionMatrix * text.transform * vec3f(charPos, 1);\n\n  output.position = vec4f(transformedPosition, 1);\n  output.texcoord = pos[vertexIndex] * vec2f(1, -1);\n  output.texcoord *= char.texExtent;\n  output.texcoord += char.texOffset;\n  output.debugColor = debugColors[vertexIndex];\n  output.instanceIndex = textIndex;\n  return output;\n\n  // To debug - hardcode quad in bottom right quarter of the screen:\n  // output.position = vec4f(pos[input.vertex], 0, 1);\n}\n\n// Signed distance function sampling for MSDF font rendering\nfn sampleMsdf(texcoord: vec2f) -> f32 {\n  let c = textureSample(fontTexture, fontSampler, texcoord);\n  return max(min(c.r, c.g), min(max(c.r, c.g), c.b));\n}\n\n// Fragment shader\n// Anti-aliasing technique by Paul Houx\n// more details here:\n// https://github.com/Chlumsky/msdfgen/issues/22#issuecomment-234958005\n@fragment\nfn fragmentMain(input: VertexOutput) -> @location(0) vec4f {\n  let text = texts[input.instanceIndex];\n\n  // pxRange (AKA distanceRange) comes from the msdfgen tool.\n  let pxRange = 4.0;\n  let texSize = vec2f(textureDimensions(fontTexture, 0));\n\n  let dx = texSize.x * length(vec2f(dpdxFine(input.texcoord.x), dpdyFine(input.texcoord.x)));\n  let dy = texSize.y * length(vec2f(dpdxFine(input.texcoord.y), dpdyFine(input.texcoord.y)));\n\n  let toPixels = pxRange * inverseSqrt(dx * dx + dy * dy);\n  let sigDist = sampleMsdf(input.texcoord) - 0.5;\n  let pxDist = sigDist * toPixels;\n\n  let edgeWidth = 0.5;\n  let alpha = smoothstep(-edgeWidth, edgeWidth, pxDist);\n\n  if (alpha < 0.001) {\n    discard;\n  }\n\n  let msdfColor = vec4f(text.color.rgb, text.color.a * alpha);\n  return msdfColor;\n\n  // Debug options:\n  // return text.color;\n  // return input.debugColor;\n  // return vec4f(1, 0, 1, 1); // hardcoded magenta\n  // return textureSample(fontTexture, fontSampler, input.texcoord);\n}\n";
+export default _default;
+//# sourceMappingURL=text.wgsl.d.ts.map

package/dist/text/text.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.wgsl.d.ts","sourceRoot":"","sources":["../../src/text/text.wgsl.ts"],"names":[],"mappings":";AAAA,wBAoJE"}

package/dist/textures/AssetManager.d.ts

@@ -0,0 +1,182 @@
+import type { Size } from "../coreTypes/Size";
+import type { Vec2 } from "../coreTypes/Vec2";
+import type { Limits } from "../limits";
+import { QuadNode } from "../scene/QuadNode";
+import type { SceneNode } from "../scene/SceneNode";
+import { TextShader } from "../text/TextShader";
+import type { AtlasBundleOpts, AtlasCoords, CpuTextureAtlas, TextureBundleOpts } from "./types";
+export type TextureId = string;
+export type BundleId = string;
+export type FontId = string;
+export declare class AssetManager {
+    #private;
+    readonly textureAtlas: GPUTexture;
+    constructor(device: GPUDevice, presentationFormat: GPUTextureFormat, limits: Limits, format?: "rgba8unorm" | "rg8unorm");
+    /**
+     * True dimensions of a loaded texture, prior to any transparent pixel cropping.
+     *
+     * @param id - The id of the texture to get the size of
+     * @returns The size of the texture
+     */
+    getSize(id: TextureId): Size;
+    /**
+     * Dimensions of a loaded texture, cropped to a minimal bounding box.
+     *
+     * @param id - The id of the texture to get the size of
+     * @returns The size of the texture
+     */
+    getCroppedSize(id: TextureId): Size;
+    /**
+     * Whether the texture has been cropped for extra transparency.
+     *
+     * @param id - The id of the texture to be checked
+     * @returns Whether the image has been cropped (i.e. if it has uvScaledCropped)
+     */
+    isCropped(id: TextureId): boolean;
+    /**
+     * A read-only map of all currently loaded textures.
+     */
+    get textures(): Map<string, AtlasCoords[]>;
+    /**
+     * A read-only array of all currently loaded texture ids.
+     */
+    get textureIds(): string[];
+    /**
+     * Debug method to load a set of textures from a record of URLS.
+     *
+     * @param textures Collection of strings and URLs representing the texture name and target file
+     * @param options LoadingOptions used to modify the loading process
+     *
+     * Note: this will consume one texture atlas per texture.
+     * For more efficient loading of multiple textures, consider {@link loadBundle}
+     *
+     * @example
+     *
+     * await toodle.assets.loadTextures({
+     *   "myImage": new URL("assets/image.png", "https://mywebsite.com"),
+     * });
+     *
+     * @deprecated use {@link registerBundle} instead. or {@link loadTexture} for debugging
+     */
+    loadTextures(opts: TextureBundleOpts["textures"]): Promise<void>;
+    /**
+     * Debug method to load a single texture.
+     *
+     * @param id ID used to name the texture
+     * @param url URL or ImageBitmap target for the image
+     * @param options LoadingOptions used to modify the loading process
+     *
+     * Note: this will consume one texture atlas per texture.
+     * For more efficient loading of multiple textures, consider {@link loadBundle}
+     */
+    loadTexture(id: TextureId, url: URL | ImageBitmap, options?: Partial<TextureBundleOpts>): Promise<{
+        id: string;
+        coords: AtlasCoords;
+    }>;
+    /**
+     * Register a bundle of textures.
+     *
+     * @param bundleId ID used to name the bundle
+     * @param bundle Collection of strings and URLs representing the texture name and target file
+     * @param options LoadingOptions used to modify the loading process
+     *
+     * See: https://toodle.gg/f849595b3ed13fc956fc1459a5cb5f0228f9d259/examples/texture-bundles.html
+     */
+    registerBundle(bundleId: BundleId, opts: TextureBundleOpts | AtlasBundleOpts): Promise<BundleId>;
+    /**
+     * Load a bundle of textures to the gpu
+     *
+     * See: https://toodle.gg/f849595b3ed13fc956fc1459a5cb5f0228f9d259/examples/texture-bundles.html
+     */
+    loadBundle(bundleId: BundleId): Promise<void>;
+    /**
+     * Unload a bundle of textures from the gpu - this marks the gpu-side texture atlas
+     * as available for future texture loading.
+     *
+     * @param bundleId - The id of the bundle to unload
+     */
+    unloadBundle(bundleId: BundleId): Promise<void>;
+    /**
+     * Load a font to the gpu
+     *
+     * @param id - The id of the font to load
+     * @param url - The url of the font to load
+     * @param fallbackCharacter - The character to use as a fallback if the font does not contain a character to be rendererd
+     */
+    loadFont(id: string, url: URL, fallbackCharacter?: string): Promise<string>;
+    getFont(id: string): TextShader;
+    validateTextureReference(node: SceneNode | QuadNode): void;
+    /**
+     * Advanced and niche features
+     */
+    extra: {
+        getRegisteredBundleIds: () => string[];
+        getLoadedBundleIds: () => string[];
+        /**
+         * Set the atlas coordinates for a texture.
+         *
+         * This should not be necessary for most use cases. This allows for UV precision
+         *
+         * @param id - The id of the texture to set the atlas coordinates for
+         * @param coords - The atlas coordinates to set
+         */
+        setAtlasCoords: (id: TextureId, coords: AtlasCoords) => void;
+        /**
+         * Get the atlas coordinates for a texture.
+         *
+         * @param id - The id of the texture to get the atlas coordinates for
+         * @returns An array of the atlas coordinates for the texture
+         */
+        getAtlasCoords: (id: TextureId) => AtlasCoords[];
+        /**
+         * Get the texture default offset
+         *
+         * @param id - The id of the texture to get the atlas coordinates for
+         * @returns Point of the texture's associated X,Y offset
+         */
+        getTextureOffset: (id: TextureId) => Vec2;
+        /**
+         * Get diagnostics on texture atlas usage
+         *
+         * @returns Usage stats for texture atlases
+         */
+        getAtlasUsage: () => {
+            /**
+             * The number of texture atlases that are currently unused
+             * and available to load textures into.
+             */
+            available: number;
+            /**
+             * The number of texture atlases that are currently in use.
+             */
+            used: number;
+            /**
+             * The total number of texture atlases that can be loaded.
+             */
+            total: number;
+        };
+        /**
+         * Consume the next available atlas index.
+         *
+         */
+        nextAvailableAtlasIndex: () => number;
+        /**
+         * Load a texture atlas from a CpuTextureAtlas.
+         *
+         * @param atlas - The texture atlas to load
+         * @returns The index of the atlas
+         */
+        loadAtlas: (atlas: CpuTextureAtlas) => Promise<number>;
+        /**
+         * Unload an atlas from the texture atlas.
+         *
+         * @param atlasIndex - The index of the atlas to unload
+         */
+        unloadAtlas: (atlasIndex: number) => Promise<void>;
+    };
+    /**
+     * Destroy the texture atlas. This should free up ~4gb of gpu memory (and make all draw calls fail)
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=AssetManager.d.ts.map

package/dist/textures/AssetManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../../src/textures/AssetManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGhD,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,eAAe,EAEf,iBAAiB,EAGlB,MAAM,SAAS,CAAC;AAGjB,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAC/B,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAC9B,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAQ5B,qBAAa,YAAY;;IACvB,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC;gBAWhC,MAAM,EAAE,SAAS,EACjB,kBAAkB,EAAE,gBAAgB,EACpC,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,YAAY,GAAG,UAAyB;IAwBlD;;;;;OAKG;IACH,OAAO,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAS5B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAWnC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO;IAUjC;;OAEG;IACH,IAAI,QAAQ,+BAEX;IAED;;OAEG;IACH,IAAI,UAAU,aAEb;IAED;;;;;;;;;;;;;;;;OAgBG;IACG,YAAY,CAAC,IAAI,EAAE,iBAAiB,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtE;;;;;;;;;OASG;IACG,WAAW,CACf,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,GAAG,GAAG,WAAW,EACtB,OAAO,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;;;;IAwCtC;;;;;;;;OAQG;IACG,cAAc,CAClB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,iBAAiB,GAAG,eAAe,GACxC,OAAO,CAAC,QAAQ,CAAC;IAapB;;;;OAIG;IACG,UAAU,CAAC,QAAQ,EAAE,QAAQ;IAmBnC;;;;;OAKG;IACG,YAAY,CAAC,QAAQ,EAAE,QAAQ;IAqBrC;;;;;;OAMG;IACG,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,iBAAiB,SAAM;IAqB5D,OAAO,CAAC,EAAE,EAAE,MAAM;IASlB,wBAAwB,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ;IAqNnD;;OAEG;IACH,KAAK;sCAEyB,MAAM,EAAE;kCAKZ,MAAM,EAAE;QAMhC;;;;;;;WAOG;6BACkB,SAAS,UAAU,WAAW;QAWnD;;;;;WAKG;6BACkB,SAAS,KAAG,WAAW,EAAE;QAS9C;;;;;WAKG;+BACoB,SAAS,KAAG,IAAI;QAUvC;;;;WAIG;;YAGC;;;eAGG;;YAEH;;eAEG;;YAEH;;eAEG;;;QAKP;;;WAGG;;QAWH;;;;;WAKG;2BACsB,eAAe;QAyCxC;;;;WAIG;kCAC6B,MAAM;MActC;IAmCF;;OAEG;IACH,OAAO;CAGR"}

package/dist/textures/TextureComputeShader.d.ts

@@ -0,0 +1,21 @@
+import type { TextureWithMetadata } from "./types";
+/**
+ * A GPU-based texture processor that uses compute shaders to:
+ * 1. Find the non-transparent bounding box in a texture.
+ * 2. Crop the texture to that bounding box.
+ * 3. Create a fallback texture if no non-transparent pixels are found.
+ */
+export declare class TextureComputeShader {
+    #private;
+    constructor(device: GPUDevice, cropPipeline: GPUComputePipeline, boundPipeline: GPUComputePipeline, missingTexturePipeline: GPUComputePipeline);
+    /**
+     * Factory method to initialize pipelines and return an instance of TextureComputeShader.
+     */
+    static create(device: GPUDevice): TextureComputeShader;
+    /**
+     * Main entry point to process a texture.
+     * Returns a cropped ImageBitmap and metadata.
+     */
+    processTexture(textureWrapper: TextureWithMetadata): Promise<TextureWithMetadata>;
+}
+//# sourceMappingURL=TextureComputeShader.d.ts.map

package/dist/textures/TextureComputeShader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureComputeShader.d.ts","sourceRoot":"","sources":["../../src/textures/TextureComputeShader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAwBnD;;;;;GAKG;AACH,qBAAa,oBAAoB;;gBAQ7B,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE,kBAAkB,EAChC,aAAa,EAAE,kBAAkB,EACjC,sBAAsB,EAAE,kBAAkB;IAiB5C;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS;IAU/B;;;OAGG;IACG,cAAc,CAClB,cAAc,EAAE,mBAAmB,GAClC,OAAO,CAAC,mBAAmB,CAAC;CAwQhC"}

package/dist/textures/mod.d.ts

@@ -0,0 +1,2 @@
+export type * from "./types";
+//# sourceMappingURL=mod.d.ts.map

package/dist/textures/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/textures/mod.ts"],"names":[],"mappings":"AAAA,mBAAmB,SAAS,CAAC"}

package/dist/textures/pixel-scraping.wgsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "\n// ==============================\n// === BOUNDING BOX PASS =======\n// ==============================\n\n// Input texture from which to compute the non-transparent bounding box\n@group(0) @binding(0)\nvar input_texture: texture_2d<f32>;\n\n// Atomic bounding box storage structure\nstruct bounding_box_atomic {\n    min_x: atomic<u32>,\n    min_y: atomic<u32>,\n    max_x: atomic<u32>,\n    max_y: atomic<u32>,\n};\n\n// Storage buffer to hold atomic bounding box updates\n@group(0) @binding(1)\nvar<storage, read_write> bounds: bounding_box_atomic;\n\n// Compute shader to find the bounding box of non-transparent pixels\n@compute @workgroup_size(8, 8)\nfn find_bounds(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let size = textureDimensions(input_texture).xy;\n    if (gid.x >= size.x || gid.y >= size.y) {\n        return;\n    }\n\n    let pixel = textureLoad(input_texture, vec2<i32>(gid.xy), 0);\n    if (pixel.a > 0.0) {\n        atomicMin(&bounds.min_x, gid.x);\n        atomicMin(&bounds.min_y, gid.y);\n        atomicMax(&bounds.max_x, gid.x);\n        atomicMax(&bounds.max_y, gid.y);\n    }\n}\n\n// ==============================\n// === CROP + OUTPUT PASS ======\n// ==============================\n\n// Input texture from which cropped data is read\n@group(0) @binding(0)\nvar input_texture_crop: texture_2d<f32>;\n\n// Output texture where cropped image is written\n@group(0) @binding(1)\nvar output_texture: texture_storage_2d<rgba8unorm, write>;\n\n// Bounding box passed in as a uniform (not atomic anymore)\nstruct bounding_box_uniform {\n    min_x: u32,\n    min_y: u32,\n    max_x: u32,\n    max_y: u32,\n};\n\n@group(0) @binding(2)\nvar<uniform> bounds_uniform: bounding_box_uniform;\n\n// Struct to store both original and cropped texture dimensions\nstruct image_dimensions {\n    original_width: u32,\n    original_height: u32,\n    cropped_width: u32,\n    cropped_height: u32,\n};\n\n// Storage buffer to output the result dimensions\n@group(0) @binding(3)\nvar<storage, read_write> dimensions_out: image_dimensions;\n\n// Compute shader to crop the input texture to the bounding box and output it\n@compute @workgroup_size(8, 8)\nfn crop_and_output(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let size = textureDimensions(input_texture_crop).xy;\n\n    let crop_width = bounds_uniform.max_x - bounds_uniform.min_x + 1u;\n    let crop_height = bounds_uniform.max_y - bounds_uniform.min_y + 1u;\n\n    if (gid.x >= crop_width || gid.y >= crop_height) {\n        return;\n    }\n\n    let src_coord = vec2<i32>(\n        i32(bounds_uniform.min_x + gid.x),\n        i32(bounds_uniform.min_y + gid.y)\n    );\n\n    let dst_coord = vec2<i32>(i32(gid.x), i32(gid.y));\n    let pixel = textureLoad(input_texture_crop, src_coord, 0);\n    textureStore(output_texture, dst_coord, pixel);\n\n    // Output dimensions from workgroup (0,0) only\n    if (gid.x == 0u && gid.y == 0u) {\n        dimensions_out.original_width = size.x;\n        dimensions_out.original_height = size.y;\n        dimensions_out.cropped_width = crop_width;\n        dimensions_out.cropped_height = crop_height;\n    }\n}\n\n// ==============================\n// === MISSING TEXTURE FILL ====\n// ==============================\n\n// Output texture to draw a fallback checkerboard\n@group(0) @binding(0)\nvar checker_texture: texture_storage_2d<rgba8unorm, write>;\n\n// Compute shader to fill a texture with a purple & green checkerboard\n@compute @workgroup_size(8, 8)\nfn missing_texture(@builtin(global_invocation_id) id: vec3<u32>) {\n    let size = textureDimensions(checker_texture);\n    if (id.x >= size.x || id.y >= size.y) {\n        return;\n    }\n\n    let checker_size = 25u;\n    let on_color = ((id.x / checker_size + id.y / checker_size) % 2u) == 0u;\n\n    let color = select(\n        vec4<f32>(0.5, 0.0, 0.5, 1.0), // Purple\n        vec4<f32>(0.0, 1.0, 0.0, 1.0), // Green\n        on_color\n    );\n\n    textureStore(checker_texture, vec2<i32>(id.xy), color);\n}\n";
+export default _default;
+//# sourceMappingURL=pixel-scraping.wgsl.d.ts.map

package/dist/textures/pixel-scraping.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixel-scraping.wgsl.d.ts","sourceRoot":"","sources":["../../src/textures/pixel-scraping.wgsl.ts"],"names":[],"mappings":";AAAA,wBAkIE"}