@bloopjs/toodle 0.0.104 → 0.1.2

package/src/textures/AssetManager.ts

@@ -1,15 +1,15 @@
+import type { IRenderBackend } from "../backends/IRenderBackend";
+import { TextureComputeShader } from "../backends/webgpu/TextureComputeShader";
+import type { WebGPUBackend } from "../backends/webgpu/WebGPUBackend";
 import type { Size } from "../coreTypes/Size";
 import type { Vec2 } from "../coreTypes/Vec2";
-import type { Limits } from "../limits";
 import { JumboQuadNode } from "../scene/JumboQuadNode";
 import { QuadNode } from "../scene/QuadNode";
 import type { SceneNode } from "../scene/SceneNode";
 import { FontPipeline } from "../text/FontPipeline";
 import { MsdfFont } from "../text/MsdfFont";
 import { TextShader } from "../text/TextShader";
-import { assert } from "../utils/mod";
 import { Bundles } from "./Bundles";
-import { TextureComputeShader } from "./TextureComputeShader";
 import type {
   AtlasBundleOpts,
   AtlasCoords,
@@ -26,51 +26,63 @@ export type FontId = string;
 export type AssetManagerOptions = {
   /** Existing Bundles instance to use for CPU-side storage. If not provided, a new one is created. */
   bundles?: Bundles;
-  /** Texture format (default: "rgba8unorm") */
-  format?: "rgba8unorm" | "rg8unorm";
+  /** Which texture atlas to use (default: "default") */
+  atlasId?: string;
 };
 
 export class AssetManager {
-  readonly textureAtlas: GPUTexture;
   readonly bundles: Bundles;
-  #device: GPUDevice;
-  #presentationFormat: GPUTextureFormat;
+  #backend: IRenderBackend;
+  #atlasId: string;
   #fonts: Map<string, TextShader> = new Map();
-  #cropComputeShader: TextureComputeShader;
-  #limits: Limits;
+  #cropComputeShader: TextureComputeShader | null = null;
   #availableIndices: Set<number> = new Set();
 
-  constructor(
-    device: GPUDevice,
-    presentationFormat: GPUTextureFormat,
-    limits: Limits,
-    options: AssetManagerOptions = {},
-  ) {
-    this.#device = device;
-    this.#presentationFormat = presentationFormat;
-    this.#limits = limits;
-    this.bundles =
-      options.bundles ?? new Bundles({ atlasSize: limits.textureSize });
-    const format = options.format ?? "rgba8unorm";
-    this.textureAtlas = device.createTexture({
-      label: "Asset Manager Atlas Texture",
-      size: [
-        this.#limits.textureSize,
-        this.#limits.textureSize,
-        this.#limits.textureArrayLayers,
-      ],
-      format,
-      usage:
-        GPUTextureUsage.TEXTURE_BINDING |
-        GPUTextureUsage.COPY_DST |
-        GPUTextureUsage.RENDER_ATTACHMENT,
-    });
-    this.#cropComputeShader = TextureComputeShader.create(device);
+  constructor(backend: IRenderBackend, options: AssetManagerOptions = {}) {
+    this.#backend = backend;
+    this.#atlasId = options.atlasId ?? "default";
+
+    const atlas = backend.getTextureAtlas(this.#atlasId);
+    if (!atlas) {
+      throw new Error(`Atlas "${this.#atlasId}" not found`);
+    }
+
+    this.bundles = options.bundles ?? new Bundles({ atlasSize: atlas.size });
+
+    // Initialize compute shader only for WebGPU backend
+    if (backend.type === "webgpu") {
+      const device = (backend as WebGPUBackend).device;
+      this.#cropComputeShader = TextureComputeShader.create(device);
+    }
+
     this.#availableIndices = new Set(
-      Array.from({ length: limits.textureArrayLayers }, (_, i) => i),
+      Array.from({ length: atlas.layers }, (_, i) => i),
     );
   }
 
+  /**
+   * Get the atlas ID this asset manager uses.
+   */
+  get atlasId(): string {
+    return this.#atlasId;
+  }
+
+  /**
+   * Get the GPU texture atlas. For WebGPU, returns GPUTexture.
+   * @deprecated Access via backend.getTextureAtlas(atlasId).handle instead
+   */
+  get textureAtlas(): GPUTexture {
+    return this.#backend.getTextureAtlas(this.#atlasId)!.handle as GPUTexture;
+  }
+
+  /**
+   * Get the atlas dimensions
+   */
+  get atlasSize(): Size {
+    const atlas = this.#backend.getTextureAtlas(this.#atlasId);
+    return { width: atlas!.size, height: atlas!.size };
+  }
+
   /**
    * True dimensions of a loaded texture, prior to any transparent pixel cropping.
    *
@@ -80,9 +92,10 @@ export class AssetManager {
   getSize(id: TextureId): Size {
     const coords = this.extra.getAtlasCoords(id);
     const originalScale = coords[0].uvScale;
+    // Use atlasSize instead of textureAtlas.width/height for WebGL2 compatibility
     return {
-      width: originalScale.width * this.textureAtlas.width,
-      height: originalScale.height * this.textureAtlas.height,
+      width: originalScale.width * this.atlasSize.width,
+      height: originalScale.height * this.atlasSize.height,
     };
   }
 
@@ -95,9 +108,10 @@ export class AssetManager {
   getCroppedSize(id: TextureId): Size {
     const scaledUvs = this.extra.getAtlasCoords(id)[0].uvScaleCropped;
     if (scaledUvs) {
+      // Use atlasSize instead of textureAtlas.width/height for WebGL2 compatibility
       return {
-        width: scaledUvs.width * this.textureAtlas.width,
-        height: scaledUvs.height * this.textureAtlas.height,
+        width: scaledUvs.width * this.atlasSize.width,
+        height: scaledUvs.height * this.atlasSize.height,
       };
     }
     return this.getSize(id);
@@ -165,12 +179,20 @@ export class AssetManager {
    *
    * Note: this will consume one texture atlas per texture.
    * For more efficient loading of multiple textures, consider {@link loadBundle}
+   *
+   * @throws Error if using WebGL backend (use registerBundle instead)
    */
   async loadTexture(
     id: TextureId,
     url: URL | ImageBitmap,
     options?: Partial<TextureBundleOpts>,
   ) {
+    if (this.#backend.type !== "webgpu") {
+      throw new Error(
+        "loadTexture is only supported with WebGPU backend. Use registerBundle with prebaked atlases instead.",
+      );
+    }
+
     const bitmap =
       url instanceof ImageBitmap ? url : await getBitmapFromUrl(url);
 
@@ -180,24 +202,25 @@ export class AssetManager {
     );
     const atlasIndex = this.extra.nextAvailableAtlasIndex();
 
-    if (options?.cropTransparentPixels) {
+    if (options?.cropTransparentPixels && this.#cropComputeShader) {
       textureWrapper =
         await this.#cropComputeShader.processTexture(textureWrapper);
     }
 
     this.#copyTextureToAtlas(textureWrapper.texture, atlasIndex);
 
+    const { width: atlasWidth, height: atlasHeight } = this.atlasSize;
     const coords: AtlasCoords = {
       uvOffset: { x: 0, y: 0 },
       cropOffset: textureWrapper.cropOffset,
       uvScale: {
-        width: textureWrapper.texture.width / this.textureAtlas.width,
-        height: textureWrapper.texture.height / this.textureAtlas.height,
+        width: textureWrapper.texture.width / atlasWidth,
+        height: textureWrapper.texture.height / atlasHeight,
       },
       originalSize: textureWrapper.originalSize,
       uvScaleCropped: {
-        width: textureWrapper.texture.width / this.textureAtlas.width,
-        height: textureWrapper.texture.height / this.textureAtlas.height,
+        width: textureWrapper.texture.width / atlasWidth,
+        height: textureWrapper.texture.height / atlasHeight,
       },
       atlasIndex,
     };
@@ -292,23 +315,36 @@ export class AssetManager {
    * @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
+   *
+   * @throws Error if using WebGL backend (fonts not supported in WebGL mode)
    */
   async loadFont(id: string, url: URL, fallbackCharacter = "_") {
+    if (this.#backend.type !== "webgpu") {
+      throw new Error(
+        "loadFont is only supported with WebGPU backend. Text rendering is not available in WebGL mode.",
+      );
+    }
+
+    const webgpuBackend = this.#backend as WebGPUBackend;
+    const device = webgpuBackend.device;
+    const presentationFormat = webgpuBackend.presentationFormat;
+    const limits = this.#backend.limits;
+
     const font = await MsdfFont.create(id, url);
     font.fallbackCharacter = fallbackCharacter;
     const fontPipeline = await FontPipeline.create(
-      this.#device,
+      device,
       font,
-      this.#presentationFormat,
-      this.#limits.maxTextLength,
+      presentationFormat,
+      limits.maxTextLength,
     );
 
     const textShader = new TextShader(
-      this.#device,
+      this.#backend as WebGPUBackend,
       fontPipeline,
       font,
-      this.#presentationFormat,
-      this.#limits.instanceCount,
+      presentationFormat,
+      limits.instanceCount,
     );
     this.#fonts.set(id, textShader);
     return id;
@@ -353,7 +389,8 @@ export class AssetManager {
    * @private
    */
   #createTextureFromImageBitmap(bitmap: ImageBitmap, name: string): GPUTexture {
-    const texture = this.#device.createTexture({
+    const device = (this.#backend as WebGPUBackend).device;
+    const texture = device.createTexture({
       label: `${name} Intermediary Texture`,
       size: [bitmap.width, bitmap.height],
       format: "rgba8unorm",
@@ -364,7 +401,7 @@ export class AssetManager {
         GPUTextureUsage.RENDER_ATTACHMENT,
     });
 
-    this.#device.queue.copyExternalImageToTexture(
+    device.queue.copyExternalImageToTexture(
       {
         source: bitmap,
       },
@@ -380,20 +417,27 @@ export class AssetManager {
     bundleId: BundleId,
     opts: TextureBundleOpts,
   ) {
+    if (this.#backend.type !== "webgpu") {
+      throw new Error(
+        "Dynamic texture bundle registration is only supported with WebGPU backend. Use prebaked atlases instead.",
+      );
+    }
+
+    const device = (this.#backend as WebGPUBackend).device;
     const images = new Map<string, TextureWithMetadata>();
 
-    let networkLoadTime = 0;
+    let _networkLoadTime = 0;
     await Promise.all(
       Object.entries(opts.textures).map(async ([id, url]) => {
         const now = performance.now();
         const bitmap = await getBitmapFromUrl(url);
-        networkLoadTime += performance.now() - now;
+        _networkLoadTime += performance.now() - now;
         let textureWrapper: TextureWithMetadata = this.#wrapBitmapToTexture(
           bitmap,
           id,
         );
 
-        if (opts.cropTransparentPixels) {
+        if (opts.cropTransparentPixels && this.#cropComputeShader) {
           textureWrapper =
             await this.#cropComputeShader.processTexture(textureWrapper);
         }
@@ -403,8 +447,8 @@ export class AssetManager {
 
     const atlases = await packBitmapsToAtlas(
       images,
-      this.#limits.textureSize,
-      this.#device,
+      this.#backend.limits.textureSize,
+      device,
     );
 
     this.bundles.registerDynamicBundle(bundleId, atlases);
@@ -467,6 +511,8 @@ export class AssetManager {
      * @returns Usage stats for texture atlases
      */
     getAtlasUsage: () => {
+      const atlas = this.#backend.getTextureAtlas(this.#atlasId);
+      const totalLayers = atlas?.layers ?? 0;
       return {
         /**
          * The number of texture atlases that are currently unused
@@ -476,11 +522,11 @@ export class AssetManager {
         /**
          * The number of texture atlases that are currently in use.
          */
-        used: this.#limits.textureArrayLayers - this.#availableIndices.size,
+        used: totalLayers - this.#availableIndices.size,
         /**
          * The total number of texture atlases that can be loaded.
          */
-        total: this.#limits.textureArrayLayers,
+        total: totalLayers,
       };
     },
 
@@ -489,7 +535,9 @@ export class AssetManager {
      *
      */
     nextAvailableAtlasIndex: () => {
-      for (let i = 0; i < this.#limits.textureArrayLayers; i++) {
+      const atlas = this.#backend.getTextureAtlas(this.#atlasId);
+      const totalLayers = atlas?.layers ?? 0;
+      for (let i = 0; i < totalLayers; i++) {
         if (this.#availableIndices.has(i)) {
           this.#availableIndices.delete(i);
           return i;
@@ -507,34 +555,8 @@ export class AssetManager {
     loadAtlas: async (atlas: CpuTextureAtlas) => {
       const atlasIndex = this.extra.nextAvailableAtlasIndex();
 
-      if (atlas.rg8Bytes) {
-        const { width: w, height: h } = {
-          width: this.textureAtlas.width,
-          height: this.textureAtlas.height,
-        };
-
-        // WebGPU requires 256-byte bytesPerRow
-        const rowBytes = w * 2;
-        assert(rowBytes % 256 === 0, "rowBytes must be a multiple of 256");
-
-        this.#device.queue.writeTexture(
-          { texture: this.textureAtlas, origin: { x: 0, y: 0, z: atlasIndex } },
-          atlas.rg8Bytes,
-          { bytesPerRow: rowBytes, rowsPerImage: h },
-          { width: w, height: h, depthOrArrayLayers: 1 },
-        );
-      } else {
-        this.#device.queue.copyExternalImageToTexture(
-          {
-            source: atlas.texture,
-          },
-          {
-            texture: this.textureAtlas,
-            origin: [0, 0, atlasIndex],
-          },
-          [atlas.texture.width, atlas.texture.height, 1],
-        );
-      }
+      // Delegate to backend for actual GPU upload
+      await this.#backend.uploadAtlas(atlas, atlasIndex, this.#atlasId);
 
       for (const [id, region] of atlas.textureRegions) {
         this.bundles.addTextureEntry(id, { ...region, atlasIndex });
@@ -569,7 +591,8 @@ export class AssetManager {
   }
 
   #copyTextureToAtlas(texture: GPUTexture, atlasIndex: number) {
-    const copyEncoder: GPUCommandEncoder = this.#device.createCommandEncoder();
+    const device = (this.#backend as WebGPUBackend).device;
+    const copyEncoder: GPUCommandEncoder = device.createCommandEncoder();
     copyEncoder.copyTextureToTexture(
       {
         texture: texture,
@@ -584,12 +607,13 @@ export class AssetManager {
       [texture.width, texture.height, 1],
     );
 
-    this.#device.queue.submit([copyEncoder.finish()]);
+    device.queue.submit([copyEncoder.finish()]);
   }
+
   /**
    * Destroy the texture atlas. This should free up ~4gb of gpu memory (and make all draw calls fail)
    */
   destroy() {
-    this.textureAtlas.destroy();
+    this.#backend.destroy();
   }
 }

package/src/textures/util.ts

@@ -1,4 +1,3 @@
-import { unzipSync } from "fflate";
 import type {
   CpuTextureAtlas,
   TextureRegion,
@@ -16,97 +15,6 @@ export async function getBitmapFromUrl(url: URL): Promise<ImageBitmap> {
   }
 }
 
-/**
- * Converts an image Blob to ImageData.
- *
- * @param blob - The Blob containing the image.
- * @returns A Promise resolving to the image as ImageData.
- */
-async function blobToImageData(blob: Blob) {
-  const imageBitmap: ImageBitmap = await createImageBitmap(blob);
-
-  const canvas = document.createElement("canvas");
-  const ctx = canvas.getContext("2d");
-
-  if (!ctx) {
-    throw new Error("Failed to get 2D context from canvas");
-  }
-
-  canvas.width = imageBitmap.width;
-  canvas.height = imageBitmap.height;
-
-  ctx.drawImage(imageBitmap, 0, 0);
-
-  const imageData: ImageData = ctx.getImageData(
-    0,
-    0,
-    canvas.width,
-    canvas.height,
-  );
-
-  imageBitmap.close();
-
-  return imageData;
-}
-
-/**
- * Creates a checkerboard pattern ImageData in black and purple.
- *
- * @param width - Width of the image.
- * @param height - Height of the image.
- * @param tileSize - Size of each checker tile (default is 8).
- * @returns The generated ImageData object.
- */
-function createCheckerboardImageData(
-  width: number,
-  height: number,
-  tileSize = 8,
-): ImageData {
-  const data = new Uint8ClampedArray(width * height * 4);
-
-  const purple = [128, 0, 128, 255]; // #800080
-  const black = [0, 0, 0, 255]; // #000000
-
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      const usePurple =
-        (Math.floor(x / tileSize) + Math.floor(y / tileSize)) % 2 === 0;
-      const color = usePurple ? purple : black;
-      const idx = (y * width + x) * 4;
-
-      data.set(color, idx);
-    }
-  }
-
-  return new ImageData(data, width, height);
-}
-
-export async function loadZip(
-  zipUrl: URL,
-): Promise<{ path: string; bitmap: ImageBitmap }[]> {
-  console.time("fetch zip");
-  const zip = await fetch(zipUrl);
-  const zipBlob = await zip.blob();
-  const zipUint8Array = await zipBlob.arrayBuffer();
-  console.timeEnd("fetch zip");
-
-  console.time("unzip");
-  const files = unzipSync(new Uint8Array(zipUint8Array));
-  console.timeEnd("unzip");
-
-  console.time("create bitmaps");
-  const validFiles = Object.entries(files).filter(
-    ([path]) => !path.match("__MACOS") && path.endsWith(".png"),
-  );
-
-  return await Promise.all(
-    validFiles.map(async ([path, file]) => {
-      const bitmap = await createImageBitmap(new Blob([file]));
-      return { path, bitmap };
-    }),
-  );
-}
-
 export async function packBitmapsToAtlas(
   images: Map<string, TextureWithMetadata>,
   textureSize: number,

package/src/utils/boilerplate.ts

@@ -2,7 +2,7 @@ import {
   makeBindGroupLayoutDescriptors,
   makeShaderDataDefinitions,
 } from "webgpu-utils";
-import type { ShaderDescriptor } from "../shaders/ShaderDescriptor";
+import type { ShaderDescriptor } from "../backends/webgpu/ShaderDescriptor";
 import { assert } from "./assert";
 
 // convenience functions to wrap verbose webgpu apis - not part of public api

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

@@ -1 +0,0 @@
-{"version":3,"file":"EngineUniform.d.ts","sourceRoot":"","sources":["../../src/shaders/EngineUniform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,EAAE,IAAI,CAAC;CAG5B,CAAC"}

package/dist/shaders/IShader.d.ts

@@ -1,15 +0,0 @@
-import type { SceneNode } from "../scene/SceneNode";
-import type { EngineUniform } from "./EngineUniform";
-export interface IShader {
-    startFrame: (device: GPUDevice, uniform: EngineUniform) => void;
-    /**
-     * Process a batch of nodes.
-     *
-     * @param renderPass - The render pass to use.
-     * @param nodes - The nodes to process.
-     * @returns The number of draw calls made.
-     */
-    processBatch: (renderPass: GPURenderPassEncoder, nodes: SceneNode[]) => number;
-    endFrame: () => void;
-}
-//# sourceMappingURL=IShader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IShader.d.ts","sourceRoot":"","sources":["../../src/shaders/IShader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,WAAW,OAAO;IACtB,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,KAAK,IAAI,CAAC;IAEhE;;;;;;OAMG;IACH,YAAY,EAAE,CACZ,UAAU,EAAE,oBAAoB,EAChC,KAAK,EAAE,SAAS,EAAE,KACf,MAAM,CAAC;IAEZ,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB"}

package/dist/shaders/QuadShader.d.ts

@@ -1,18 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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

@@ -1,6 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

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

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

@@ -1 +0,0 @@
-{"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/pixel-scraping.wgsl.d.ts.map

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

package/src/shaders/IShader.ts

@@ -1,20 +0,0 @@
-import type { SceneNode } from "../scene/SceneNode";
-import type { EngineUniform } from "./EngineUniform";
-
-export interface IShader {
-  startFrame: (device: GPUDevice, uniform: EngineUniform) => void;
-
-  /**
-   * Process a batch of nodes.
-   *
-   * @param renderPass - The render pass to use.
-   * @param nodes - The nodes to process.
-   * @returns The number of draw calls made.
-   */
-  processBatch: (
-    renderPass: GPURenderPassEncoder,
-    nodes: SceneNode[],
-  ) => number;
-
-  endFrame: () => void;
-}

package/src/shaders/mod.ts

@@ -1,5 +0,0 @@
-export * from "./EngineUniform";
-export * from "./IShader";
-export * from "./postprocess/mod";
-export * from "./ShaderDescriptor";
-export * from "./samplers";