@nodetool-ai/game-renderer 0.8.4 → 0.8.6

package/dist/webgpu/sprites.d.ts

@@ -1,6 +1,6 @@
-import type { Batch, TextureEntry, Blend } from "./types.js";
+import type { Batch, TextureEntry, Blend, Sampling } from "./types.js";
 export declare const INSTANCE_FLOATS = 14;
 export declare const SHADER = "\nstruct Camera { center: vec2f, viewport: vec2f, zoom: f32, padding0: f32, padding1: f32, padding2: f32 };\noverride linearizeInput: bool = false;\nfn srgbToLinear(rgb: vec3f) -> vec3f {\n  return select(rgb / 12.92, pow((rgb + 0.055) / 1.055, vec3f(2.4)), rgb > vec3f(0.04045));\n}\nfn linearToSrgb(rgb: vec3f) -> vec3f {\n  return select(rgb * 12.92, 1.055 * pow(rgb, vec3f(1.0 / 2.4)) - 0.055, rgb > vec3f(0.0031308));\n}\n@group(0) @binding(0) var<uniform> camera: Camera;\n@group(0) @binding(1) var atlasSampler: sampler;\n@group(0) @binding(2) var atlas: texture_2d<f32>;\n@group(1) @binding(0) var lightSampler: sampler;\n@group(1) @binding(1) var lightTexture: texture_2d<f32>;\n\nstruct VertexInput {\n  @builtin(vertex_index) corner: u32,\n  @location(0) center: vec2f,\n  @location(1) size: vec2f,\n  @location(2) uv: vec4f,\n  @location(3) color: vec4f,\n  @location(4) rotation: f32,\n  @location(5) unlit: f32,\n};\nstruct VertexOutput {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n  @location(1) color: vec4f,\n  @location(3) @interpolate(flat) unlit: f32,\n  @location(4) lightUv: vec2f,\n};\n@vertex fn vertexMain(input: VertexInput) -> VertexOutput {\n  let corners = array<vec2f, 6>(\n    vec2f(-0.5, 0.5), vec2f(-0.5, -0.5), vec2f(0.5, 0.5),\n    vec2f(0.5, 0.5), vec2f(-0.5, -0.5), vec2f(0.5, -0.5));\n  let local = corners[input.corner] * input.size;\n  let sine = sin(input.rotation);\n  let cosine = cos(input.rotation);\n  let rotated = vec2f(local.x * cosine - local.y * sine, local.x * sine + local.y * cosine);\n  let world = input.center + rotated;\n  let clip = (world - camera.center) * camera.zoom * 2.0 / camera.viewport;\n  var output: VertexOutput;\n  output.position = vec4f(clip, 0.0, 1.0);\n  let uvCorner = corners[input.corner] + vec2f(0.5, 0.5);\n  output.uv = input.uv.xy + vec2f(uvCorner.x, 1.0 - uvCorner.y) * input.uv.zw;\n  output.color = input.color;\n  output.unlit = input.unlit;\n  output.lightUv = clip * vec2f(0.5, -0.5) + vec2f(0.5, 0.5);\n  return output;\n}\n@fragment fn fragmentMain(input: VertexOutput) -> @location(0) vec4f {\n  let sampled = textureSample(atlas, atlasSampler, input.uv) * input.color;\n  var straight = select(sampled.rgb, srgbToLinear(sampled.rgb), linearizeInput);\n  if (input.unlit < 0.5) {\n    let irradiance = textureSampleLevel(lightTexture, lightSampler, input.lightUv, 0.0).rgb;\n    let lit = clamp(srgbToLinear(sampled.rgb) * irradiance, vec3f(0.0), vec3f(1.0));\n    straight = select(linearToSrgb(lit), lit, linearizeInput);\n  }\n  return vec4f(straight * sampled.a, sampled.a);\n}";
-export declare function appendBatch(batches: Batch[], texture: TextureEntry, blend: Blend, index: number): void;
+export declare function appendBatch(batches: Batch[], texture: TextureEntry, blend: Blend, index: number, sampling: Sampling): void;
 export declare function writeInstance(target: Float32Array, index: number, ...values: number[]): void;
 //# sourceMappingURL=sprites.d.ts.map

package/dist/webgpu/sprites.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sprites.d.ts","sourceRoot":"","sources":["../../src/webgpu/sprites.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC7D,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,MAAM,0iFA2DjB,CAAC;AAEH,wBAAgB,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAOpG;AAEH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAE1F"}
+{"version":3,"file":"sprites.d.ts","sourceRoot":"","sources":["../../src/webgpu/sprites.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACvE,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,MAAM,0iFA2DjB,CAAC;AAEH,wBAAgB,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAQxH;AAEH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAE1F"}

package/dist/webgpu/sprites.js

@@ -59,13 +59,14 @@ struct VertexOutput {
   }
   return vec4f(straight * sampled.a, sampled.a);
 }`;
-export function appendBatch(batches, texture, blend, index) {
+export function appendBatch(batches, texture, blend, index, sampling) {
+    const bindGroup = texture.bindGroups[sampling];
     const last = batches[batches.length - 1];
-    if (last?.texture === texture && last.blend === blend) {
+    if (last?.texture === texture && last.bindGroup === bindGroup && last.blend === blend) {
         last.count++;
     }
     else {
-        batches.push({ texture, blend, first: index, count: 1 });
+        batches.push({ texture, bindGroup, blend, first: index, count: 1 });
     }
 }
 export function writeInstance(target, index, ...values) {

package/dist/webgpu/sprites.js.map

@@ -1 +1 @@
-{"version":3,"file":"sprites.js","sourceRoot":"","sources":["../../src/webgpu/sprites.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAC;AAClC,MAAM,CAAC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DpB,CAAC;AAEH,MAAM,UAAU,WAAW,CAAC,OAAgB,EAAE,OAAqB,EAAE,KAAY,EAAE,KAAa;IAC5F,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACzC,IAAI,IAAI,EAAE,OAAO,KAAK,OAAO,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;QACtD,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAC3D,CAAC;AACH,CAAC;AAEH,MAAM,UAAU,aAAa,CAAC,MAAoB,EAAE,KAAa,EAAE,GAAG,MAAgB;IAClF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,GAAG,eAAe,CAAC,CAAC;AAC9C,CAAC"}
+{"version":3,"file":"sprites.js","sourceRoot":"","sources":["../../src/webgpu/sprites.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAC;AAClC,MAAM,CAAC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DpB,CAAC;AAEH,MAAM,UAAU,WAAW,CAAC,OAAgB,EAAE,OAAqB,EAAE,KAAY,EAAE,KAAa,EAAE,QAAkB;IAChH,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC/C,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACzC,IAAI,IAAI,EAAE,OAAO,KAAK,OAAO,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;QACtF,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IACtE,CAAC;AACH,CAAC;AAEH,MAAM,UAAU,aAAa,CAAC,MAAoB,EAAE,KAAa,EAAE,GAAG,MAAgB;IAClF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,GAAG,eAAe,CAAC,CAAC;AAC9C,CAAC"}

package/dist/webgpu/types.d.ts

@@ -1,12 +1,14 @@
+export type Sampling = "nearest" | "linear";
 export interface TextureEntry {
     readonly texture: GPUTexture;
-    readonly bindGroup: GPUBindGroup;
+    readonly bindGroups: Readonly<Record<Sampling, GPUBindGroup>>;
     readonly width: number;
     readonly height: number;
 }
 export type Blend = "normal" | "additive";
 export interface Batch {
     readonly texture: TextureEntry;
+    readonly bindGroup: GPUBindGroup;
     readonly blend: Blend;
     readonly first: number;
     count: number;

package/dist/webgpu/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/webgpu/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,KAAK,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE1C,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/webgpu/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE5C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC;IAC9D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,KAAK,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE1C,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/webgpu.d.ts

@@ -43,7 +43,8 @@ export declare class WebGPUGameRenderer implements GameRenderer {
     private readonly lightFallback;
     private lightTarget;
     private readonly textures;
-    private readonly validatedLuts;
+    private readonly assetGenerations;
+    private readonly liveAssetTextures;
     private readonly fallback;
     private readonly particleDot;
     private readonly placeholders;
@@ -52,6 +53,7 @@ export declare class WebGPUGameRenderer implements GameRenderer {
     private hudCanvas;
     private hudTexture;
     private hudKey;
+    private hudRevision;
     private disposed;
     private lost;
     constructor(canvas: HTMLCanvasElement, device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat, assets: AssetCache, adapterType?: "hardware" | "software" | "unknown");
@@ -62,11 +64,18 @@ export declare class WebGPUGameRenderer implements GameRenderer {
     private convertColor;
     private textureEntry;
     private upload;
+    private assertUsable;
+    private assetGeneration;
+    private retireGeneration;
+    private releaseFrameAssets;
+    private uploadGeneration;
+    private generationTexture;
     private getTexture;
     private getLutTexture;
     private placeholder;
     render(frame: GameRenderFrame, interpolation: number, particles?: GameParticleField): Promise<GameRendererStats>;
     private renderFrame;
+    private renderAssetFrame;
     private updateHud;
     private ensureInstanceCapacity;
     resize(width: number, height: number): void;

package/dist/webgpu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgpu.d.ts","sourceRoot":"","sources":["../src/webgpu.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAAE,UAAU,EAA2C,MAAM,eAAe,CAAC;AAEpF,OAAO,EAA4D,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC3H,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpI,uFAAuF;AACvF,qBAAa,kBAAmB,YAAW,YAAY;IA+CnD,QAAQ,CAAC,MAAM,EAAE,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAnD9B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA8B;IAC7D,QAAQ,CAAC,OAAO,YAAY;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAoB;IACzD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoB;IACrD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAoB;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAa;IAC3C,OAAO,CAAC,eAAe,CAAoB;IAC3C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkB;IAChD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoB;IACnD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoB;IACrD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoB;IACnD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAwB;IAC3D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA2B;IAC1D,OAAO,CAAC,OAAO,CAAqC;IACpD,OAAO,CAAC,QAAQ,CAAuC;IACvD,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,sBAAsB,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAY;IACzC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAY;IAC3C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoB;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqB;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAa;IAC3C,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmC;IAC5D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAe;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAChE,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,SAAS,CAAgC;IACjD,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAS;IAErB,YACW,MAAM,EAAE,iBAAiB,EACjB,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,UAAU,EAClB,WAAW,GAAE,UAAU,GAAG,UAAU,GAAG,SAAqB,EA8G9E;IAED,IAAI,YAAY,IAAI,wBAAwB,CAS3C;IAED,UAAU,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,EAAE,QAAQ,CAAC,EAAE,kBAAkB,GAAG,IAAI,CA4CtF;IAED,OAAO,CAAC,mBAAmB;IAqC3B,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,MAAM;YAaA,UAAU;YAiBV,aAAa;IA4B3B,OAAO,CAAC,WAAW;IAmBb,MAAM,CAAC,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAqBrH;YAEa,WAAW;IAyKzB,OAAO,CAAC,SAAS;IAgBjB,OAAO,CAAC,sBAAsB;IAS9B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAe1C;IAED,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAMrC;IAED,OAAO,IAAI,IAAI,CA+Bd;CACF"}
+{"version":3,"file":"webgpu.d.ts","sourceRoot":"","sources":["../src/webgpu.ts"],"names":[],"mappings":"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"}

package/dist/webgpu.js

@@ -49,7 +49,8 @@ export class WebGPUGameRenderer {
     lightFallback;
     lightTarget;
     textures = new Map();
-    validatedLuts = new Set();
+    assetGenerations = new Set();
+    liveAssetTextures = new Set();
     fallback;
     particleDot;
     placeholders = new Map();
@@ -58,6 +59,7 @@ export class WebGPUGameRenderer {
     hudCanvas;
     hudTexture;
     hudKey = "";
+    hudRevision = 0;
     disposed = false;
     lost = false;
     constructor(canvas, device, context, format, assets, adapterType = "unknown") {
@@ -173,7 +175,7 @@ export class WebGPUGameRenderer {
         const dotTexture = device.createTexture({ size: [PARTICLE_DOT_SIZE, PARTICLE_DOT_SIZE], format: "rgba8unorm",
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST });
         device.queue.writeTexture({ texture: dotTexture }, particleDotPixels(), { bytesPerRow: PARTICLE_DOT_SIZE * 4 }, [PARTICLE_DOT_SIZE, PARTICLE_DOT_SIZE]);
-        this.particleDot = this.textureEntry(dotTexture, PARTICLE_DOT_SIZE, PARTICLE_DOT_SIZE, "linear");
+        this.particleDot = this.textureEntry(dotTexture, PARTICLE_DOT_SIZE, PARTICLE_DOT_SIZE);
         void device.lost.then(() => { this.lost = true; });
     }
     get capabilities() {
@@ -290,22 +292,24 @@ export class WebGPUGameRenderer {
         pass.end();
         output.markWritten();
     }
-    textureEntry(texture, width, height, sampling = "nearest") {
+    textureEntry(texture, width, height) {
+        const view = texture.createView();
+        const bindGroup = (sampler) => this.device.createBindGroup({
+            layout: this.pipeline.getBindGroupLayout(0),
+            entries: [
+                { binding: 0, resource: { buffer: this.cameraBuffer } },
+                { binding: 1, resource: sampler },
+                { binding: 2, resource: view },
+            ],
+        });
         return {
             texture,
             width,
             height,
-            bindGroup: this.device.createBindGroup({
-                layout: this.pipeline.getBindGroupLayout(0),
-                entries: [
-                    { binding: 0, resource: { buffer: this.cameraBuffer } },
-                    { binding: 1, resource: sampling === "linear" ? this.linearSampler : this.sampler },
-                    { binding: 2, resource: texture.createView() },
-                ],
-            }),
+            bindGroups: { nearest: bindGroup(this.sampler), linear: bindGroup(this.linearSampler) },
         };
     }
-    upload(image, sampling = "nearest") {
+    upload(image) {
         const width = image instanceof HTMLCanvasElement ? image.width : imageWidth(image);
         const height = image instanceof HTMLCanvasElement ? image.height : imageHeight(image);
         if (width <= 0 || height <= 0) {
@@ -314,31 +318,97 @@ export class WebGPUGameRenderer {
         // copyExternalImageToTexture requires RENDER_ATTACHMENT on the destination as well as COPY_DST.
         const texture = this.device.createTexture({ size: [width, height], format: "rgba8unorm",
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT });
-        this.device.queue.copyExternalImageToTexture({ source: image }, { texture, premultipliedAlpha: false }, [width, height]);
-        return this.textureEntry(texture, width, height, sampling);
+        try {
+            this.device.queue.copyExternalImageToTexture({ source: image }, { texture, premultipliedAlpha: false }, [width, height]);
+            return this.textureEntry(texture, width, height);
+        }
+        catch (error) {
+            texture.destroy();
+            throw error;
+        }
     }
-    async getTexture(assetId, sampling) {
-        if (assetId === PARTICLE_DOT_ASSET) {
-            return { texture: this.particleDot, uploadedBytes: 0 };
+    assertUsable() {
+        if (this.disposed || this.lost) {
+            throw new Error(this.lost ? "WebGPU device was lost" : "Game renderer is disposed");
         }
-        const cached = this.textures.get(assetId);
-        if (cached) {
-            return { texture: cached, uploadedBytes: 0 };
+    }
+    assetGeneration(assetId, frame) {
+        this.assertUsable();
+        let generation = this.textures.get(assetId);
+        if (!generation) {
+            generation = { image: this.assets.get(assetId), readers: 0, retired: false, opaque: false };
+            this.textures.set(assetId, generation);
+            this.assetGenerations.add(generation);
+        }
+        if (!frame.generations.has(generation)) {
+            frame.generations.add(generation);
+            generation.readers++;
+        }
+        return generation;
+    }
+    retireGeneration(generation) {
+        if (!generation.retired || generation.readers !== 0) {
+            return;
+        }
+        if (generation.entry && this.liveAssetTextures.delete(generation.entry)) {
+            generation.entry.texture.destroy();
+        }
+        generation.entry = undefined;
+        this.assetGenerations.delete(generation);
+    }
+    releaseFrameAssets(frame) {
+        for (const generation of frame.generations) {
+            generation.readers--;
+            this.retireGeneration(generation);
+        }
+        frame.generations.clear();
+    }
+    async uploadGeneration(assetId, generation, frame) {
+        const image = await generation.image;
+        this.assertUsable();
+        if (generation.retired && generation.readers === 0) {
+            throw new Error(`Asset ${assetId} was invalidated before upload`);
         }
-        const image = await this.assets.get(assetId);
         if (!image) {
-            return { texture: this.placeholder(assetId), uploadedBytes: 0 };
+            return this.placeholder(assetId);
+        }
+        const texture = this.upload(image);
+        if (texture !== this.fallback) {
+            generation.entry = texture;
+            this.liveAssetTextures.add(texture);
+            frame.uploadedBytes += texture.width * texture.height * 4;
+        }
+        return texture;
+    }
+    generationTexture(assetId, generation, frame) {
+        if (!generation.upload) {
+            const upload = this.uploadGeneration(assetId, generation, frame);
+            generation.upload = upload;
+            void upload.catch(() => {
+                if (generation.upload === upload && !generation.entry) {
+                    generation.upload = undefined;
+                }
+            });
+        }
+        return generation.upload;
+    }
+    async getTexture(assetId, frame) {
+        if (assetId === PARTICLE_DOT_ASSET) {
+            return this.particleDot;
         }
-        const texture = this.upload(image, sampling);
-        this.textures.set(assetId, texture);
-        return { texture, uploadedBytes: texture.width * texture.height * 4 };
+        const generation = this.assetGeneration(assetId, frame);
+        const texture = await this.generationTexture(assetId, generation, frame);
+        this.assertUsable();
+        return texture;
     }
-    async getLutTexture(assetId, size) {
-        const image = await this.assets.get(assetId);
+    async getLutTexture(assetId, size, frame) {
+        const generation = this.assetGeneration(assetId, frame);
+        const image = await generation.image;
+        this.assertUsable();
         if (!image || imageWidth(image) !== size * size || imageHeight(image) !== size) {
             throw new Error(`LUT ${assetId} is missing or has invalid dimensions`);
         }
-        if (!this.validatedLuts.has(assetId)) {
+        if (!generation.opaque) {
             const canvas = document.createElement("canvas");
             canvas.width = imageWidth(image);
             canvas.height = imageHeight(image);
@@ -353,9 +423,10 @@ export class WebGPUGameRenderer {
                     throw new Error(`LUT ${assetId} must be opaque`);
                 }
             }
-            this.validatedLuts.add(assetId);
+            generation.opaque = true;
         }
-        const { texture } = await this.getTexture(assetId, "nearest");
+        const texture = await this.generationTexture(assetId, generation, frame);
+        this.assertUsable();
         return new LabeledTexture(texture.texture, { label: `game-lut-${assetId}`, format: "rgba8unorm",
             width: texture.width, height: texture.height,
             meta: { colorSpace: "srgb", alpha: "premultiplied", bindingKind: "texture_2d" } });
@@ -402,15 +473,26 @@ export class WebGPUGameRenderer {
         }
     }
     async renderFrame(frame, interpolation, particles) {
+        const assets = { generations: new Set(), uploadedBytes: 0 };
+        try {
+            return await this.renderAssetFrame(frame, interpolation, assets, particles);
+        }
+        finally {
+            this.releaseFrameAssets(assets);
+        }
+    }
+    async renderAssetFrame(frame, interpolation, assets, particles) {
         const bloomRadius = this.effects.reduce((maximum, effect) => effect.kind === "bloom" ? Math.max(maximum, effect.radius) : maximum, 0);
         const overscanPixels = Math.ceil(bloomRadius * 2);
         const overscanWorld = overscanPixels * frame.width / (Math.max(1, this.canvas.width) * projectedCamera(frame, interpolation).zoom);
         const items = visibleItems(frame, interpolation, overscanWorld, particles && { field: particles });
-        const sampling = new Map(items.map((item) => [item.assetId, item.sampling]));
-        const assetIds = [...sampling.keys()];
-        const textureResults = await Promise.all(assetIds.map((assetId) => this.getTexture(assetId, sampling.get(assetId) ?? "nearest")));
+        const assetIds = [...new Set(items.map((item) => item.assetId))];
+        const textureResults = await Promise.all(assetIds.map((assetId) => this.getTexture(assetId, assets)));
         const textureById = new Map(assetIds.map((assetId, index) => [assetId, textureResults[index]]));
-        const hudTexture = this.updateHud(frame, await loadGameUiImages(frame, (assetId) => this.assets.get(assetId)));
+        const hudRevision = this.hudRevision;
+        const hudImages = await loadGameUiImages(frame, (assetId) => this.assets.get(assetId));
+        this.assertUsable();
+        const hudTexture = this.updateHud(frame, hudImages, hudRevision);
         const count = items.length + (hudTexture ? 1 : 0);
         this.ensureInstanceCapacity(count);
         const instances = new Float32Array(count * INSTANCE_FLOATS);
@@ -421,7 +503,7 @@ export class WebGPUGameRenderer {
             if (!item || !result) {
                 continue;
             }
-            const texture = result.texture;
+            const texture = result;
             const rect = texture.width === 1 && texture.height === 1 ? { x: 0, y: 0, width: 1, height: 1 } : sourceRect(item, texture.width, texture.height);
             const tint = parseTint(item.tint);
             const subRect = item.frame !== undefined || item.cell !== undefined;
@@ -432,13 +514,13 @@ export class WebGPUGameRenderer {
             const du = (rect.width - 2 * insetX) / texture.width;
             const dv = (rect.height - 2 * insetY) / texture.height;
             writeInstance(instances, index, item.x, item.y, item.width, item.height, item.flipX ? u + du : u, item.flipY ? v + dv : v, item.flipX ? -du : du, item.flipY ? -dv : dv, tint[0], tint[1], tint[2], item.opacity, item.rotation, item.unlit ? 1 : 0);
-            appendBatch(batches, texture, item.blend, index);
+            appendBatch(batches, texture, item.blend, index, item.sampling);
         }
         if (hudTexture) {
             const scale = frame.camera.zoom;
             const projected = projectedCamera(frame, interpolation);
             writeInstance(instances, items.length, projected.x, projected.y, frame.width / scale, frame.height / scale, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1);
-            appendBatch(batches, hudTexture, "normal", items.length);
+            appendBatch(batches, hudTexture, "normal", items.length, "nearest");
         }
         const projected = projectedCamera(frame, interpolation);
         const camera = new Float32Array([projected.x, projected.y,
@@ -504,7 +586,7 @@ export class WebGPUGameRenderer {
                                 ? hasEffects ? this.effectAdditivePipeline : this.additivePipeline
                                 : hasEffects ? this.effectSpritePipeline : this.pipeline);
                         }
-                        pass.setBindGroup(0, batch.texture.bindGroup);
+                        pass.setBindGroup(0, batch.bindGroup);
                         pass.draw(6, batch.count, 0, batch.first);
                     }
                 }
@@ -518,7 +600,7 @@ export class WebGPUGameRenderer {
                         effectContext: this.effectContext, effectExecutor: this.effectExecutor,
                         effectRecipeRunner: this.effectRecipeRunner, effectRegistry: this.effectRegistry,
                         srgbTarget: this.srgbTarget, lutTarget: this.lutTarget, toSrgbPipeline: this.toSrgbPipeline,
-                        toLinearPipeline: this.toLinearPipeline, getLutTexture: (id, size) => this.getLutTexture(id, size),
+                        toLinearPipeline: this.toLinearPipeline, getLutTexture: (id, size) => this.getLutTexture(id, size, assets),
                         convertColor: (command, input, target, pipeline) => this.convertColor(command, input, target, pipeline) });
                     const presentGroup = this.device.createBindGroup({ layout: this.presentLayout, entries: [
                             { binding: 0, resource: this.sampler }, { binding: 1, resource: source.createView() },
@@ -548,14 +630,16 @@ export class WebGPUGameRenderer {
                 }
             }
         });
+        this.assertUsable();
         this.device.queue.submit([encoder.finish()]);
-        const textureBytes = [...this.textures.values(), ...this.placeholders.values(), this.fallback, this.particleDot,
+        this.releaseFrameAssets(assets);
+        const textureBytes = [...this.liveAssetTextures, ...this.placeholders.values(), this.fallback, this.particleDot,
             ...(this.hudTexture ? [this.hudTexture] : [])].reduce((sum, entry) => sum + entry.width * entry.height * 4, 0);
         return {
             backend: this.backend,
             visibleSprites: items.length,
             drawCalls: batches.length + this.effects.reduce((sum, effect) => sum + (effect.kind === "bloom" ? 4 : effect.kind === "lut" ? 3 : 1), 0) + (hasEffects ? 1 : 0) + (sceneLighting ? 1 : 0),
-            uploadedBytes: textureResults.reduce((sum, result) => sum + result.uploadedBytes, 0),
+            uploadedBytes: assets.uploadedBytes,
             textureBytes,
             targetBytes: (this.sourceTarget && this.effectTarget ? (this.sourceTarget.width * this.sourceTarget.height +
                 this.effectTarget.width * this.effectTarget.height + (this.effects.some((effect) => effect.kind === "bloom") ?
@@ -565,11 +649,12 @@ export class WebGPUGameRenderer {
             instanceBufferBytes: this.instanceCapacity * INSTANCE_FLOATS * 4,
         };
     }
-    updateHud(frame, images) {
+    updateHud(frame, images, revision) {
         if (frame.hud.length === 0 && !frame.ui) {
             return undefined;
         }
-        const key = JSON.stringify([this.canvas.width, this.canvas.height, frame.hud, frame.ui, [...images.keys()]]);
+        const key = JSON.stringify([this.canvas.width, this.canvas.height, frame.gameId, frame.fonts,
+            frame.hud, frame.ui, [...images.keys()], revision]);
         if (key !== this.hudKey) {
             const canvas = this.hudCanvas ?? document.createElement("canvas");
             paintWebGPUHud(canvas, this.canvas.width, this.canvas.height, frame, images);
@@ -605,11 +690,14 @@ export class WebGPUGameRenderer {
         this.lutTarget = undefined;
     }
     invalidateAsset(assetId) {
+        this.hudRevision++;
         this.assets.invalidate(assetId);
-        const texture = this.textures.get(assetId);
-        texture?.texture.destroy();
+        const generation = this.textures.get(assetId);
         this.textures.delete(assetId);
-        this.validatedLuts.delete(assetId);
+        if (generation) {
+            generation.retired = true;
+            this.retireGeneration(generation);
+        }
     }
     dispose() {
         if (this.disposed) {
@@ -635,9 +723,14 @@ export class WebGPUGameRenderer {
             entry.texture.destroy();
         }
         this.placeholders.clear();
-        for (const entry of this.textures.values()) {
+        for (const generation of this.assetGenerations) {
+            generation.retired = true;
+        }
+        for (const entry of this.liveAssetTextures) {
             entry.texture.destroy();
         }
+        this.liveAssetTextures.clear();
+        this.assetGenerations.clear();
         this.textures.clear();
         this.assets.clear();
         this.context.unconfigure();