@bloopjs/toodle 0.0.100

package/dist/shaders/QuadShader.d.ts

@@ -0,0 +1,18 @@
+import type { SceneNode } from "../scene/SceneNode";
+import type { AssetManager } from "../textures/AssetManager";
+import type { EngineUniform } from "./EngineUniform";
+import type { IShader } from "./IShader";
+export type QuadShaderOpts = {
+    assetManager?: AssetManager;
+    blendMode?: GPUBlendState;
+};
+export declare class QuadShader implements IShader {
+    #private;
+    label: string;
+    code: string;
+    startFrame(device: GPUDevice, uniform: EngineUniform): void;
+    processBatch(renderPass: GPURenderPassEncoder, nodes: SceneNode[]): number;
+    endFrame(): void;
+    constructor(label: string, assetManager: AssetManager, device: GPUDevice, presentationFormat: GPUTextureFormat, userCode: string, instanceCount: number, blendMode?: GPUBlendState);
+}
+//# sourceMappingURL=QuadShader.d.ts.map

package/dist/shaders/QuadShader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuadShader.d.ts","sourceRoot":"","sources":["../../src/shaders/QuadShader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAQ7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASzC,MAAM,MAAM,cAAc,GAAG;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B,CAAC;AAEF,qBAAa,UAAW,YAAW,OAAO;;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IAYb,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa;IAiBpD,YAAY,CAAC,UAAU,EAAE,oBAAoB,EAAE,KAAK,EAAE,SAAS,EAAE;IA0DjE,QAAQ;gBAGN,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,SAAS,EACjB,kBAAkB,EAAE,gBAAgB,EACpC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,SAAS,CAAC,EAAE,aAAa;CA4G5B"}

package/dist/shaders/ShaderDescriptor.d.ts

@@ -0,0 +1,7 @@
+export type ShaderDescriptor = {
+    label: string;
+    code: string;
+    vertexEntrypoint: string;
+    fragmentEntrypoint: string;
+};
+//# sourceMappingURL=ShaderDescriptor.d.ts.map

package/dist/shaders/ShaderDescriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderDescriptor.d.ts","sourceRoot":"","sources":["../../src/shaders/ShaderDescriptor.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC"}

package/dist/shaders/mod.d.ts

@@ -0,0 +1,6 @@
+export * from "./EngineUniform";
+export * from "./IShader";
+export * from "./postprocess/mod";
+export * from "./ShaderDescriptor";
+export * from "./samplers";
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/shaders/mod.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC"}

package/dist/shaders/parser.d.ts

@@ -0,0 +1,8 @@
+import { type StructInfo } from "wgsl_reflect";
+import type { ShaderDescriptor } from "./ShaderDescriptor";
+export declare function codeWithLineNumbers(code: string): string;
+export declare function combineShaderCode(label: string, base: string, mod: string): ShaderDescriptor;
+export declare function struct2BufferLayout(struct: StructInfo, stepMode?: GPUVertexStepMode): GPUVertexBufferLayout;
+export declare function validateFragmentShader(shaderCode: string): void;
+export declare function getGpuFormat(typeName: string): GPUVertexFormat;
+//# sourceMappingURL=parser.d.ts.map

package/dist/shaders/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/shaders/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAe,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,UAK/C;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GACV,gBAAgB,CA4ClB;AAuED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,EAClB,QAAQ,GAAE,iBAA8B,GACvC,qBAAqB,CAkDvB;AAED,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,QAaxD;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAqB9D"}

package/dist/shaders/postprocess/blur.d.ts

@@ -0,0 +1,3 @@
+import type { Color } from "../../coreTypes/Color";
+export declare function blur(encoder: GPUCommandEncoder, context: GPUCanvasContext, device: GPUDevice, clearColor: Color, presentationFormat: GPUTextureFormat, pingpong: [GPUTexture, GPUTexture]): void;
+//# sourceMappingURL=blur.d.ts.map

package/dist/shaders/postprocess/blur.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../src/shaders/postprocess/blur.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAInD,wBAAgB,IAAI,CAClB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,KAAK,EACjB,kBAAkB,EAAE,gBAAgB,EACpC,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,QA2InC"}

package/dist/shaders/postprocess/mod.d.ts

@@ -0,0 +1,17 @@
+export type PostProcess = {
+    /**
+     * A post-processor modifies the current render before it is presented to the screen.
+     *
+     * @param encoder - a GPUCommandEncoder used to create render passes
+     * @param pingpong - a pair of GPUTextures used for ping-pong rendering
+     * @param screen - the final screen GPUTexture to render to
+     */
+    process(queue: GPUQueue, encoder: GPUCommandEncoder, pingpong: [GPUTexture, GPUTexture], screen: GPUTexture): void;
+};
+export declare const PostProcessDefaults: {
+    readonly sampler: (device: GPUDevice) => GPUSampler;
+    readonly vertexBufferLayout: (device: GPUDevice) => GPUVertexBufferLayout;
+    readonly vertexShader: (device: GPUDevice) => GPUShaderModule;
+    readonly pipelineDescriptor: (device: GPUDevice) => GPURenderPipelineDescriptor;
+};
+//# sourceMappingURL=mod.d.ts.map

package/dist/shaders/postprocess/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/shaders/postprocess/mod.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACxB;;;;;;OAMG;IACH,OAAO,CACL,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,EAClC,MAAM,EAAE,UAAU,GACjB,IAAI,CAAC;CACT,CAAC;AAEF,eAAO,MAAM,mBAAmB;+BACd,SAAS,KAAG,UAAU;0CAWX,SAAS,KAAG,qBAAqB;oCAOvC,SAAS,KAAG,eAAe;0CAuBrB,SAAS,KAAG,2BAA2B;CAY1D,CAAC"}

package/dist/shaders/samplers.d.ts

@@ -0,0 +1,3 @@
+export declare const pixelArtSampler: GPUSamplerDescriptor;
+export declare const smoothSampler: GPUSamplerDescriptor;
+//# sourceMappingURL=samplers.d.ts.map

package/dist/shaders/samplers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"samplers.d.ts","sourceRoot":"","sources":["../../src/shaders/samplers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,EAAE,oBAK7B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,oBAK3B,CAAC"}

package/dist/shaders/wgsl/example.wgsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "\nstruct MyStuff {\n  red: f32,\n}\n\n@vertex\nfn vert(\n  @builtin(vertex_index) VertexIndex: u32,\n  @builtin(instance_index) InstanceIndex: u32,\n  instance: InstanceData\n) -> VertexOutput {\n  var output = default_vertex_shader(VertexIndex, InstanceIndex, instance);\n  return output;\n}\n\n@fragment\nfn frag(vertex: VertexOutput) -> @location(0) vec4f {\n  let color = default_fragment_shader(vertex);\n  color.r = vertex.myStuff_red;\n  return color;\n}\n";
+export default _default;
+//# sourceMappingURL=example.wgsl.d.ts.map

package/dist/shaders/wgsl/example.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example.wgsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/wgsl/example.wgsl.ts"],"names":[],"mappings":";AAEA,wBAqBE"}

package/dist/shaders/wgsl/hello.wgsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "\n\n//\n// SECTION: Struct Definitions\n//\n\nstruct InstanceData {}\n\n\nstruct VertexInput {\n  @builtin(vertex_index) vertexIndex: u32,\n  @builtin(instance_index) instanceIndex: u32,\n}\n\nstruct VertexOutput {\n  @builtin(position) engine_clip_position : vec4<f32>,\n}\n\nstruct FragmentInput {\n  @builtin(position) engine_clip_position : vec4<f32>,\n}\n\nstruct FragmentOutput {\n  color: vec4<f32>,\n}\n\n//\n// SECTION: Base Entrypoints\n//\n\n@vertex\nfn base_vertex_entrypoint(input: VertexInput) -> VertexOutput {\n  return default_vertex_shader(input);\n}\n\n@fragment\nfn base_fragment_entrypoint(vertex: VertexOutput) -> @location(0) vec4<f32> {\n  let output = base_fragment_shader(vertex);\n  return output.color;\n}\n\n//\n// SECTION: Base Shaders\n//\n\nconst pos = array(vec2f(-1, -1), vec2f(1, -1), vec2f(-1, 1), vec2f(1, 1));\n\nfn base_vertex_shader(input: VertexInput) -> VertexOutput {\n  var output : VertexOutput;\n  output.engine_clip_position = vec4f(pos[input.vertexIndex], 0.0, 1.0);\n  return output;\n}\n\nfn base_fragment_shader(vertex: VertexOutput) -> FragmentOutput {\n  var output : FragmentOutput;\n  output.color = vec4f(1.0, 0.0, 1.0, 1.0);\n  return output;\n}\n\n";
+export default _default;
+//# sourceMappingURL=hello.wgsl.d.ts.map

package/dist/shaders/wgsl/hello.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hello.wgsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/wgsl/hello.wgsl.ts"],"names":[],"mappings":";AAEA,wBA2DE"}

package/dist/shaders/wgsl/helloInstanced.wgsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "\n// const pos = array(vec2f(-0.5, -0.5), vec2f(0.5, -0.5), vec2f(-0.5, 0.5), vec2f(0.5, 0.5));\nconst pos = array(vec2f(-0.5, 0.5), vec2f(-0.5, -0.5), vec2f(0.5, 0.5), vec2f(0.5, -0.5));\n\nstruct InstanceData {\n  @location(0) model0: vec4<f32>,\n  @location(1) model1: vec4<f32>,\n  @location(2) model2: vec4<f32>,\n  @location(3) color: vec4<f32>,\n}\nstruct VertexOutput {\n  @builtin(position) engine_clip_position : vec4<f32>,\n  @location(0) @interpolate(flat) color: vec4<f32>,\n}\n\nstruct EngineUniform {\n  viewProjection: mat3x3<f32>,\n};\n\n@group(0) @binding(0) var<uniform> engineUniform: EngineUniform;\n\n\n// this is the vertex shader\n@vertex\nfn vs(\n  @builtin(vertex_index) VertexIndex : u32,\n  @builtin(instance_index) InstanceIndex: u32,  // Instance ID for each instance\n  instanceData: InstanceData,\n) -> VertexOutput {\n  var output : VertexOutput;\n  let modelMatrix = mat3x3(instanceData.model0.xyz, instanceData.model1.xyz, instanceData.model2.xyz);\n  let worldPosition = engineUniform.viewProjection * modelMatrix * vec3f(pos[VertexIndex], 1.0);\n\n  output.engine_clip_position = vec4f(worldPosition, 1.0);\n  output.color = instanceData.color;\n  return output;\n}\n\n// this is the fragment shader\n@fragment\nfn fs(vertex: VertexOutput) -> @location(0) vec4<f32> {\n  return vertex.color;\n}\n";
+export default _default;
+//# sourceMappingURL=helloInstanced.wgsl.d.ts.map

package/dist/shaders/wgsl/helloInstanced.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helloInstanced.wgsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/wgsl/helloInstanced.wgsl.ts"],"names":[],"mappings":";AAEA,wBA2CE"}

package/dist/shaders/wgsl/quad.wgsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "\nstruct InstanceData {\n  // location 0-2 are the model matrix for this instanced quad\n  @location(0) model0: vec4<f32>,\n  @location(1) model1: vec4<f32>,\n  @location(2) model2: vec4<f32>,\n  // location 3 is the tint - the color will be multiplied by the texture color to determine the pixel color\n  @location(3) engine_tint: vec4<f32>,\n  // location 4 are the uv offset and scale used to sample the texture atlas. these are in normalized texel coordinates.\n  @location(4) uvOffsetAndScale: vec4<f32>,\n  // location 5 is the crop offset from center and scale. These are ratios applied to the unit quad.\n  @location(5) cropOffsetAndScale: vec4<f32>,\n  // location 6 is the atlas index\n  @location(6) atlasIndex: u32,\n  // @INSTANCE_DATA SNIPPET\n}\n\nstruct VertexInput {\n  @builtin(vertex_index) VertexIndex: u32,\n  @builtin(instance_index) InstanceIndex: u32,\n  instance: InstanceData\n}\n\nstruct VertexOutput {\n  @builtin(position) engine_clip_position : vec4<f32>,\n  // uv coordinates are stored as two vec2s:\n  // [0,1] = atlas uv coords\n  // [2,3] = uv scale\n  @location(0) engine_uv: vec4<f32>,\n  @location(1) @interpolate(flat) engine_tint: vec4<f32>,\n  @location(2) @interpolate(flat) engine_atlasIndex: u32,\n  // @VERTEX_OUTPUT SNIPPET\n}\n\nstruct EngineUniform {\n  viewProjection: mat3x3<f32>,\n  resolution: vec2f,\n};\n\n// we can't divide by 2 in the projection matrix because\n// it will affect the positioning as well as the geometry scale\n// so we need to divide by 2 for the initial position scale.\n// for eg a 10x10 quad in the top left of a 100x100 logical canvas with a 200x200 natural size\n// will be passed in as\n// position=[-45, 45]\n// scale=[10,10]\n// so the top left corner will be: (-0.5 * 10 - 45) * 2 / 100 = -1\n// if the top left vertex was -1, it would be: (-1 * 10 - 45) * 2 / 100 = -1.1\nconst enginePosLookup = array(vec2f(-0.5, 0.5), vec2f(-0.5, -0.5), vec2f(0.5, 0.5), vec2f(0.5, -0.5));\nconst engineUvLookup = array(vec2f(0, 0), vec2f(0, 1), vec2f(1, 0), vec2f(1, 1));\n\n@group(0) @binding(0) var<uniform> engineUniform: EngineUniform;\n@group(0) @binding(1) var linearSampler: sampler;\n@group(0) @binding(2) var nearestSampler: sampler;\n\n@group(1) @binding(0) var textureArray: texture_2d_array<f32>;\n\n@vertex\nfn engine_vs(\n  @builtin(vertex_index) VertexIndex: u32,\n  @builtin(instance_index) InstanceIndex: u32,\n  instance: InstanceData\n) -> VertexOutput {\n  var output = default_vertex_shader(VertexIndex, InstanceIndex,instance);\n  return output;\n}\n\n@fragment\nfn engine_fs(vertex: VertexOutput) -> @location(0) vec4<f32> {\n  return default_fragment_shader(vertex, nearestSampler);\n}\n\nfn default_vertex_shader(\n  VertexIndex: u32,\n  InstanceIndex: u32,\n  instance: InstanceData\n) -> VertexOutput {\n  var output : VertexOutput;\n  output.engine_tint = instance.engine_tint;\n\n  // reconstruct the model matrix from the instance data\n  // bc we can't pass a mat3x3 as instance data\n  let modelMatrix = mat3x3(instance.model0.xyz, instance.model1.xyz, instance.model2.xyz);\n\n  // transform the vertex position\n  let localPosition = enginePosLookup[VertexIndex];\n  let cropOffset = instance.cropOffsetAndScale.xy;\n  let cropScale = instance.cropOffsetAndScale.zw;\n  let croppedPosition = localPosition * cropScale + cropOffset;\n  let worldPosition = modelMatrix * vec3f(croppedPosition, 1.0);\n  let clipPosition = engineUniform.viewProjection * worldPosition;\n  output.engine_clip_position = vec4f(clipPosition, 1.0);\n\n  // set the uv coordinates in the texture atlas.\n  let original_uv = engineUvLookup[VertexIndex];\n  // uvOffsetAndScale is a vec4 with the following values:\n  // [0,1] = uv offset\n  // [2,3] = uv scale\n  let atlas_uv = original_uv * instance.uvOffsetAndScale.zw * cropScale + instance.uvOffsetAndScale.xy;\n  // we also pack the original uv coordinates in the w and z components\n  // since these can be useful in the fragment shader\n  output.engine_uv = vec4f(atlas_uv, original_uv);\n  output.engine_atlasIndex = u32(instance.atlasIndex);\n  // @PASSTHROUGH_SNIPPET\n\n  return output;\n}\n\nfn default_fragment_shader(vertex: VertexOutput, samp: sampler) -> vec4<f32> {\n  let atlas_uv = vertex.engine_uv.xy;\n  let original_uv = vertex.engine_uv.zw;\n\n  // Force both samplers to be referenced without assignment\n  // This prevents WGSLReflect from optimizing them away\n  var nope: bool = false;\n  if (nope) {\n    _ = linearSampler;\n    _ = nearestSampler;\n  }\n\n  let color = textureSample(textureArray, samp, atlas_uv, vertex.engine_atlasIndex);\n\n  if (vertex.engine_atlasIndex == 1000u) {\n    // rectangle - return a solid color\n    return vec4f(1,1,1,1) * vertex.engine_tint;\n  } else if (vertex.engine_atlasIndex == 1001u) {\n    // circle:\n    // edge width is 4 logical pixels\n    let edgeWidth = 4. / max(engineUniform.resolution.x, engineUniform.resolution.y);\n    // distance from center of the quad ranging from [0,1]\n    let centerDistance = 2 * distance(vec2f(0.5, 0.5), original_uv);\n    // alpha is 1 before edgeWidth and 0 after edgeWidth\n    let alpha = 1. - smoothstep(1. - edgeWidth, 1. + edgeWidth, centerDistance);\n    return vec4f(vertex.engine_tint.rgb, alpha * vertex.engine_tint.a);\n  } else {\n    // texture:\n    return color * vertex.engine_tint;\n  }\n}\n";
+export default _default;
+//# sourceMappingURL=quad.wgsl.d.ts.map

package/dist/shaders/wgsl/quad.wgsl.d.ts.map

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

package/dist/src/Toodle.d.ts

@@ -0,0 +1,303 @@
+import type { Color } from "./coreTypes/Color";
+import type { Point } from "./coreTypes/Point";
+import type { Limits, LimitsOptions } from "./limits";
+import { Batcher } from "./scene/Batcher";
+import { Camera } from "./scene/Camera";
+import { JumboQuadNode, type JumboQuadOptions } from "./scene/JumboQuadNode";
+import { QuadNode, type QuadOptions } from "./scene/QuadNode";
+import { type NodeOptions, SceneNode } from "./scene/SceneNode";
+import type { Resolution } from "./screen/resolution";
+import type { IShader } from "./shaders/IShader";
+import type { PostProcess } from "./shaders/postprocess/mod";
+import { QuadShader, QuadShaderOpts } from "./shaders/QuadShader";
+import { TextNode, type TextOptions } from "./text/TextNode";
+import { AssetManager, type TextureId } from "./textures/AssetManager";
+export declare class Toodle {
+    #private;
+    /**
+     * Asset manager. Use toodle.assets.loadTexture to load texture assets.
+     */
+    assets: AssetManager;
+    /**
+     * diagnostics can be used as a rough gauge for performance.
+     * besides frames, these stats are reset at the beginning of each frame.
+     */
+    diagnostics: {
+        /** number of instanced draw calls issued last frame. lower is better */
+        drawCalls: number;
+        /** number of pipeline switches last frame. lower is better. to reduce pipeline switches, use fewer z-indexes or fewer custom shaders */
+        pipelineSwitches: number;
+        /** number of frames rendered */
+        frames: number;
+        /** number of instances enqueued last frame */
+        instancesEnqueued: number;
+    };
+    /** sometimes for debugging you might want to access the GPU device, this should not be necessary in normal operation */
+    debug: {
+        device: GPUDevice;
+        presentationFormat: GPUTextureFormat;
+    };
+    /**
+     * Camera. This applies a 2d perspective projection matrix to any nodes drawn with toodle.draw
+     */
+    camera: Camera;
+    /**
+     * clearColor is the color that will be used to clear the screen at the beginning of each frame
+     * you can also think of this as the background color of the canvas
+     */
+    clearColor: Color;
+    /**
+     * it's unlikely that you want to use the constructor directly.
+     * see {@link Toodle.attach} for creating a Toodle instance that draws to a canvas.
+     */
+    constructor(device: GPUDevice, context: GPUCanvasContext, presentationFormat: GPUTextureFormat, canvas: HTMLCanvasElement, resolution: Resolution, options: ToodleOptions);
+    /**
+     * Screen shader is an optional slot for post-processing effects.
+     * Note that this will do the main render pass to an offscreen texture, which may impact performance.
+     */
+    get postprocess(): PostProcess | null;
+    set postprocess(value: PostProcess | null);
+    /**
+     * call resize when the canvas is resized.
+     * this will update the projection matrix and the resolution.
+     *
+     * @param resolution - the resolution of the canvas in logical pixels.
+     * this should be `canvas.clientWidth x canvas.clientHeight` and NOT `canvas.width * canvas.height`
+     *
+     * @example
+     *
+     *  const canvas = document.querySelector("canvas")!
+     *
+     *  const observer = new ResizeObserver((entries) => {
+     *   if (entries.length === 0) return
+     *   toodle.resize({ width: canvas.clientWidth, height: canvas.clientHeight })
+     *  })
+     *
+     *  observer.observe(canvas)
+     */
+    resize(resolution: Resolution): void;
+    /**
+     * The resolution of the canvas in css or logical pixels.
+     *
+     * @example
+     *
+     * // devicePixelRatio is 1, resolution is 200x200
+     * <canvas width="200" height="200" style="width: 200px; height: 200px;"></canvas>
+     * // devicePixelRatio is 2, resolution is 100x100
+     * <canvas width="200" height="200" style="width: 100px; height: 100px;"></canvas>
+     */
+    get resolution(): Resolution;
+    /**
+     * Returns the currently configured Toodle engine limits
+     *
+     * See: https://toodle.gg/f849595b3ed13fc956fc1459a5cb5f0228f9d259/limits.html
+     *
+     * @example
+     *
+     * const instanceLimit: number = toodle.limits.instanceCount;
+     */
+    get limits(): Limits;
+    get batcher(): Batcher;
+    /**
+     * The maximum number of pixels that can be loaded into texture atlases for this toodle instance.
+     */
+    get maxPixels(): number;
+    /**
+     * The maximum amount of GPU memory that will be used by the Toodle instance.
+     * This is a rough estimate and may not be exact. This will be allocated up front when calling Toodle.attach, and freed when calling toodle.destroy.
+     */
+    get maxGpuMemory(): number;
+    /**
+     * call startFrame before drawing anything.
+     * this will create a new encoder and render pass.
+     *
+     * @example
+     *
+     * toodle.startFrame();
+     * // draw stuff
+     * toodle.endFrame();
+     */
+    startFrame(options?: StartFrameOptions): void;
+    /**
+     * call draw in between start frame and end frame to enqueue an instanced draw call.
+     *
+     * @example
+     *
+     * toodle.assets.loadTexture("myImage", "assets/image.png");
+     * const quad = toodle.Quad("myImage");
+     *
+     * toodle.startFrame();
+     * toodle.draw(quad);
+     * toodle.endFrame();
+     */
+    draw(node: SceneNode): void;
+    /**
+     * call end frame to run through enqueued draw calls and submit them to the GPU.
+     *
+     * @example
+     *
+     * toodle.startFrame();
+     * // draw stuff
+     * toodle.endFrame();
+     */
+    endFrame(): void;
+    /**
+     * Convert a point from one coordinate space to another.
+     *
+     * @param point - The point to convert.
+     * @param options - The options for the conversion.
+     * @returns The converted point.
+     */
+    convertSpace(point: Point, options: {
+        from: "screen" | "world";
+        to: "world" | "screen";
+    }): Point;
+    /**
+     * The number of frames rendered since this Toodle instance was created.
+     */
+    get frameCount(): number;
+    /**
+     * Create a custom shader for quad instances. In some engines, this might be called a material.
+     *
+     * @param label Debug name of the shader
+     * @param instanceCount - The maximum number of instances that will be processed by the shader. Note that a worst-case buffer of this many instances will be immediately allocated.
+     * @param userCode - The WGSL code to be used for the shader.
+     * @param blendMode - The blend mode to be used for the shader.
+     *
+     * @example
+     *
+     *
+     */
+    QuadShader(label: string, instanceCount: number, userCode: string, shaderOpts?: QuadShaderOpts): QuadShader;
+    /**
+     * Create a new quad node.
+     *
+     * @param assetId - The ID of the asset to use for the quad. This must have been loaded with toodle.assets.loadBundle.
+     *
+     * @param options - QuadOptions for Quad creation
+     * @param options
+     * @example
+     *
+     * await toodle.assets.loadTextures({
+     *   "myImage": new URL("assets/image.png"),
+     * });
+     * const quad = toodle.Quad("myImage");
+     *
+     * toodle.startFrame();
+     * toodle.draw(quad);
+     * toodle.endFrame();
+     */
+    Quad(assetId: TextureId, options?: QuadOptions): QuadNode;
+    /**
+     * Create a jumbo quad node. This contains multiple tiles for a single texture.
+     *
+     * @param assetId - The ID of the asset to use for the jumbo quad. This must have been loaded with toodle.assets.loadTextures.
+     *
+     * @param options - QuadOptions for Quad creation
+     *
+     */
+    JumboQuad(assetId: TextureId, options: JumboQuadOptions): JumboQuadNode;
+    /**
+     * Create a new container node.
+     *
+     * @example
+     *
+     * const node = toodle.Node();
+     * const child = node.add(toodle.Node());
+     * node.position = [100, 100];
+     * console.log(child.matrix);
+     */
+    Node(nodeOpts?: NodeOptions): SceneNode;
+    Text(fontId: string, text: string, textOpts?: TextOptions): TextNode;
+    shapes: {
+        Rect: (options?: QuadOptions) => QuadNode;
+        Circle: (options?: QuadOptions) => QuadNode;
+        Line: (options: LineOptions) => QuadNode;
+    };
+    /**
+     * Attach toodle to a canvas.
+     *
+     * @param canvas - The canvas to attach toodle to.
+     * @param options - ToodleOptions for the creation of the toodle instance
+     * @returns A promise that resolves to a Toodle instance.
+     *
+     * @example
+     *
+     *   const canvas = document.createElement("canvas");
+     *
+     *   const toodle = await Toodle.attach(canvas);
+     */
+    static attach(canvas: HTMLCanvasElement, options?: ToodleOptions): Promise<Toodle>;
+    /**
+     * Destroy the toodle instance and release its gpu and cpu resources.
+     *
+     * Note that calling any methods on the instance after this result in undefined behavior.
+     */
+    destroy(): void;
+    /**
+     * Advanced and niche features
+     */
+    extra: {
+        /**
+         * Get the GPU device used by this Toodle instance.
+         */
+        device: () => GPUDevice;
+    };
+}
+export type StartFrameOptions = {
+    /**
+     * The load operation to use for the render pass.
+     *
+     * **clear**: clear the current texture to the clear color. necessary if you're using toodle without another renderer.
+     *
+     * **load**: blend the render pass with the current canvas contents. useful if you're using toodle alongside another renderer like painter or pixi.js
+     *
+     * @default "clear"
+     *
+     */
+    loadOp?: "load" | "clear";
+};
+export type ToodleOptions = {
+    /**
+     * The filter mode to use for the default quad shader.
+     * see: https://webgpufundamentals.org/webgpu/lessons/webgpu-textures.html#a-mag-filter
+     *
+     * **nearest**: nearest neighbor sampling. makes pixel art look sharp and vector art look jaggy.
+     *
+     * **linear**: linear sampling. makes vector art look smooth and pixel art look blurry.
+     *
+     * @default "linear"
+     */
+    filter?: "nearest" | "linear";
+    limits?: LimitsOptions;
+};
+export type LineOptions = {
+    /**
+     * The start position of the line.
+     */
+    start: Point;
+    /**
+     * The end position of the line.
+     */
+    end: Point;
+    /**
+     * The color of the line.
+     */
+    color: Color;
+    /**
+     * The thickness of the line.
+     */
+    thickness?: number;
+    /**
+     * The shader to use for the line.
+     */
+    shader?: IShader;
+    /**
+     * The layer to draw the line on.
+     */
+    layer?: number;
+    /**
+     * A unique identifier for the line.
+     */
+    key?: string;
+};

package/dist/src/Toodle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Toodle.d.ts","sourceRoot":"","sources":["../../src/Toodle.ts"],"names":[],"mappings":"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"}