melonjs 20.7.0 → 20.9.0

package/build/video/effects/sepia.d.ts

@@ -1,3 +1,10 @@
+/**
+ * additional import for TypeScript
+ * @import CanvasRenderer from "../canvas/canvas_renderer.js";
+ * @import WebGLRenderer from "../webgl/webgl_renderer.js";
+ * @import WebGPURenderer from "../webgpu/webgpu_renderer.js";
+ * @import Renderer from "../renderer.js";
+ */
 /**
  * A shader effect that applies a warm sepia (vintage photo) tone to the sprite.
  * @category Effects
@@ -10,11 +17,11 @@
  */
 export default class SepiaEffect extends ColorMatrixEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.intensity=1.0] - sepia intensity (0.0 = original, 1.0 = full sepia)
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         intensity?: number | undefined;
     });
     intensity: number;
@@ -25,4 +32,5 @@ export default class SepiaEffect extends ColorMatrixEffect {
     setIntensity(value: number): void;
 }
 import ColorMatrixEffect from "./colorMatrix.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=sepia.d.ts.map

package/build/video/effects/sepia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../src/video/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAjC6B,kBAAkB"}
+{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../src/video/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,sBAJW,QAAQ,YAEhB;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAxC6B,kBAAkB;0BAOvB,gBAAgB"}

package/build/video/effects/shadereffect.d.ts

@@ -1,6 +1,6 @@
 export default class ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {string|{glsl?: string, wgsl?: string}} body - the effect body:
      *   a GLSL string (containing a `vec4 apply(vec4 color, vec2 uv)` function —
      *   unchanged from previous versions), or an object carrying one body per
@@ -9,9 +9,16 @@ export default class ShaderEffect {
      *   body matching its {@link Renderer#shaderLanguage}; when no matching body
      *   exists the effect warns once and stays disabled (`enabled === false`),
      *   exactly like the Canvas renderer.
+     *
+     *   Written inline, a body is a JavaScript template literal, so it must
+     *   contain **no backtick anywhere — including in its comments**. One
+     *   ends the literal, and everything after it is parsed as code, which
+     *   fails further down the file with an error that names no shader.
+     *   Quoting an identifier in a comment is the usual way in. A body kept
+     *   in a `.glsl` / `.wgsl` file and preloaded has no such restriction.
      * @param {string} [precision=auto detected] - float precision ('lowp', 'mediump' or 'highp'), GLSL only
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, body: string | {
+    constructor(renderer: Renderer, body: string | {
         glsl?: string;
         wgsl?: string;
     }, precision?: string);
@@ -149,7 +156,6 @@ export default class ShaderEffect {
      */
     destroy(): void;
 }
-import GLShader from "../webgl/glshader.js";
-import WGSLEffectRealization from "./wgsl_realization.js";
+import type Renderer from "../renderer.js";
 import Texture2d from "../texture/texture2d.ts";
 //# sourceMappingURL=shadereffect.d.ts.map

package/build/video/effects/shadereffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"AAiJA;IAiCC;;;;;;;;;;;OAWG;IACH,sBAXW,aAAa,GAAC,cAAc,GAAC,cAAc,QAC3C,MAAM,GAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,cAQrC,MAAM,EAiKhB;IA3MD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAed;;;;;;;OAOG;IACH,eAAyB;IAEzB;;;;;;OAMG;IACH;eA5ByB,MAAM;eAAS,MAAM;MA4BrB;IACzB;;;OAGG;IACH,+BAA2B;IAoB3B;;;;;;;OAOG;IACH,0CAA+B;IAE/B;;;;;OAKG;IACH,0CAA+B;IAE/B;;;;OAIG;IACH,8BAAgC;IAQ/B;;;;;;OAMG;IACH,wBAJU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAIK;IACpD;;;OAGG;IACH,iBAAkC;IAClC;;;;;;OAMG;IACH,eAA6B;IAC7B;;;OAGG;IACH,mBAAqC;IAErC;;;OAGG;IACH,8BAKC;IAyBD;;;OAGG;IACH,mDAAkC;IAsBpC;;;;OAIG;IACH,uBAsBC;IAjBA;;;OAGG;IACH,2CAAyC;IAe1C;;;;OAIG;IACH,2BAQC;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,MAAM,SACN,MAAM,GAAC,OAAO,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,MAAM,QAsCrD;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CAoDxB;IAED;;;;;;;;;;;;OAYG;IACH,gBAJW,MAAM,QA0BhB;IAbC;;;OAGG;IACH,aAAkB;IAWpB;;;;;;;;;;;;;;OAcG;IACH,6BATW,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,MACN,MAAM,MACN,MAAM,QAqDhB;IAED;;;;;;;OAOG;IACH,8DAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAnBW,MAAM,SACN,SAAS,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,WACxE,QAAQ,GAAC,UAAU,GAAC,UAAU,GAAC,WAAW,GACxC,YAAY,CA0GxB;IAED;;;;;;;;;OASG;IACH,0BAJW,MAAM,QAgGhB;IA/DI;;;OAGG;IACH,4CAAkC;IA6DvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SATa,YAAY,CAsDxB;IAKD;;;OAGG;IACH,aAIC;IAED;;;OAGG;IACH,qCAIC;IAED;;;OAGG;IACH,iEAIC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,kBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAyCC;CACD;qBAjhCoB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}
+{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"AAwJA;IAiCC;;;;;;;;;;;;;;;;;;OAkBG;IACH,sBAlBW,QAAQ,QACR,MAAM,GAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,cAerC,MAAM,EAiKhB;IAlND;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAsBd;;;;;;;OAOG;IACH,oBAAyB;IAEzB;;;;;;OAMG;IACH;eAnCyB,MAAM;eAAS,MAAM;MAmCrB;IACzB;;;OAGG;IACH,+BAA2B;IAoB3B;;;;;;;OAOG;IACH,0CAA+B;IAE/B;;;;;OAKG;IACH,0CAA+B;IAE/B;;;;OAIG;IACH,8BAAgC;IAQ/B;;;;;;OAMG;IACH,wBAJU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAIK;IACpD;;;OAGG;IACH,iBAAkC;IAClC;;;;;;OAMG;IACH,eAA6B;IAC7B;;;OAGG;IACH,mBAAqC;IAErC;;;OAGG;IACH,8BAKC;IAyBD;;;OAGG;IACH,mDAAkC;IAsBpC;;;;OAIG;IACH,uBAsBC;IAjBA;;;OAGG;IACH,2CAAyC;IAe1C;;;;OAIG;IACH,2BAQC;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,MAAM,SACN,MAAM,GAAC,OAAO,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,MAAM,QAsCrD;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CAoDxB;IAED;;;;;;;;;;;;OAYG;IACH,gBAJW,MAAM,QA0BhB;IAbC;;;OAGG;IACH,aAAkB;IAWpB;;;;;;;;;;;;;;OAcG;IACH,6BATW,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,MACN,MAAM,MACN,MAAM,QAqDhB;IAED;;;;;;;OAOG;IACH,8DAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAnBW,MAAM,SACN,SAAS,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,WACxE,QAAQ,GAAC,UAAU,GAAC,UAAU,GAAC,WAAW,GACxC,YAAY,CA0GxB;IAED;;;;;;;;;OASG;IACH,0BAJW,MAAM,QAgGhB;IA/DI;;;OAGG;IACH,4CAAkC;IA6DvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SATa,YAAY,CAsDxB;IAKD;;;OAGG;IACH,aAIC;IAED;;;OAGG;IACH,qCAIC;IAED;;;OAGG;IACH,iEAIC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,kBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAyCC;CACD;0BAthCwB,gBAAgB;qBATpB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}

package/build/video/effects/shine.d.ts

@@ -36,7 +36,7 @@
  */
 export default class ShineEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - shine color as [r, g, b] (0.0–1.0)
      * @param {number} [options.speed=0.5] - sweeps per second
@@ -47,7 +47,7 @@ export default class ShineEffect extends ShaderEffect {
      * @param {number} [options.pulseDepth=0.0] - subtle base-brightness pulse amplitude (0 disables the pulse)
      * @param {number} [options.pulseSpeed=3.0] - pulse oscillation rate (radians/second)
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         color?: number[] | undefined;
         speed?: number | undefined;
         width?: number | undefined;
@@ -79,4 +79,5 @@ export default class ShineEffect extends ShaderEffect {
     setBands(value: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=shine.d.ts.map

package/build/video/effects/shine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shine.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shine.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IACC;;;;;;;;;;;OAWG;IACH,sBAXW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA2B,KAAK;QACP,KAAK;QACL,KAAK;QACL,SAAS;QACT,KAAK;QACL,KAAK;QACL,UAAU;QACV,UAAU;KACrC,EAgEA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;CACD;yBA5LwB,mBAAmB"}
+{"version":3,"file":"shine.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shine.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IACC;;;;;;;;;;;OAWG;IACH,sBAXW,QAAQ,YAEhB;QAA2B,KAAK;QACP,KAAK;QACL,KAAK;QACL,SAAS;QACT,KAAK;QACL,KAAK;QACL,UAAU;QACV,UAAU;KACrC,EAgEA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;CACD;yBAnMwB,mBAAmB;0BAOnB,gBAAgB"}

package/build/video/effects/tintPulse.d.ts

@@ -17,22 +17,17 @@
  */
 export default class TintPulseEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number[]} [options.color=[1.0, 0.0, 0.0]] - pulse color as [r, g, b] (0.0–1.0)
      * @param {number} [options.speed=2.0] - pulse speed (oscillations per second)
      * @param {number} [options.intensity=0.3] - maximum tint strength (0.0–1.0)
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         color?: number[] | undefined;
         speed?: number | undefined;
         intensity?: number | undefined;
     });
-    /**
-     * set the current time (call each frame for animation)
-     * @param {number} time - time in seconds
-     */
-    setTime(time: number): void;
     /**
      * set the pulse color
      * @param {number[]} color - pulse color as [r, g, b] (0.0–1.0)
@@ -40,4 +35,5 @@ export default class TintPulseEffect extends ShaderEffect {
     setColor(color: number[]): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=tintPulse.d.ts.map

package/build/video/effects/tintPulse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tintPulse.d.ts","sourceRoot":"","sources":["../../../src/video/effects/tintPulse.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;KACpC,EAqBA;IAED;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAjFwB,mBAAmB"}
+{"version":3,"file":"tintPulse.d.ts","sourceRoot":"","sources":["../../../src/video/effects/tintPulse.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,QAAQ,YAEhB;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;KACpC,EAqBA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAhFwB,mBAAmB;0BAOnB,gBAAgB"}

package/build/video/effects/tonemap.d.ts

@@ -0,0 +1,121 @@
+export namespace CURVES {
+    namespace reinhard {
+        let glsl: string;
+        let wgsl: string;
+        function fn(c: number): number;
+    }
+    namespace aces {
+        let glsl_1: string;
+        export { glsl_1 as glsl };
+        let wgsl_1: string;
+        export { wgsl_1 as wgsl };
+        export function fn_1(c: number): number;
+        export { fn_1 as fn };
+    }
+    namespace exponential {
+        let glsl_2: string;
+        export { glsl_2 as glsl };
+        let wgsl_2: string;
+        export { wgsl_2 as wgsl };
+        export function fn_2(c: number): number;
+        export { fn_2 as fn };
+    }
+}
+/**
+ * A shader effect that tone maps what it is applied to: values are lifted by
+ * `exposure` and brought back into display range by a curve, instead of
+ * clipping flat at white.
+ *
+ * Put it on the CAMERA, and put it LAST — after {@link BloomEffect}, so the
+ * light bloom spreads is mapped along with everything else rather than
+ * clipping where the two overlap.
+ *
+ * Three curves, chosen once at construction:
+ *
+ * | `mode` | character |
+ * |---|---|
+ * | `"aces"` | filmic: more midtone contrast, long shoulder. The default. Clamps internally, so it cannot feed `hdrOutput` |
+ * | `"reinhard"` | gentle and neutral, desaturates highlights as they climb |
+ * | `"exponential"` | channels saturate separately, so a hot core shifts toward white through its own hue |
+ *
+ * **Without `hdr: true` it is a grade, not a colour-managed pipeline.** The
+ * default render targets are `RGBA8`, so the frame reaching this is already
+ * clamped to `[0, 1]` and `exposure` is what gives the curve something to
+ * work on. With the `hdr` application setting on, the targets are half-float
+ * and the values arriving are genuinely above 1, which is what the curve is
+ * for. Either way it does not convert linear to sRGB, because nothing
+ * linearized it.
+ * @category Effects
+ * @see {@link Renderable#addPostEffect} for usage
+ * @example
+ * // the usual pairing: spread the bright parts, then map the result
+ * game.viewport.addPostEffect(new BloomEffect(renderer));
+ * game.viewport.addPostEffect(new ToneMappingEffect(renderer, { exposure: 1.6 }));
+ *
+ * @example
+ * // a hot core that shifts through its own colour on the way to white
+ * const grade = new ToneMappingEffect(renderer, {
+ *     mode: "exponential",
+ *     exposure: 2.2,
+ * });
+ * game.viewport.addPostEffect(grade);
+ * // and dip it for a moment when the player is hit
+ * grade.setExposure(0.7);
+ */
+export default class ToneMappingEffect extends ShaderEffect {
+    /**
+     * @param {Renderer} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {string} [options.mode="aces"] - curve: `"aces"`, `"reinhard"` or `"exponential"`
+     * @param {number} [options.exposure=1.0] - multiplier applied before the curve; above `1` lifts the image into the curve's shoulder
+     * @param {number} [options.white] - the post-exposure value that should come out as display white. Omitted, the curve keeps its own shoulder and nothing reaches 1 exactly
+     * @throws {Error} on an unknown `mode`, or a non-finite `exposure` or `white`
+     */
+    constructor(renderer: Renderer, options?: {
+        mode?: string | undefined;
+        exposure?: number | undefined;
+        white?: number | undefined;
+    });
+    /**
+     * which curve this instance baked, for reading back
+     * @type {string}
+     * @readonly
+     */
+    readonly mode: string;
+    /**
+     * The post-exposure value that comes out as display white, or `0`
+     * when the curve is left with its own shoulder.
+     * @type {number}
+     * @readonly
+     */
+    readonly white: number;
+    /**
+     * Set the white point: the value that should come out as display white.
+     *
+     * This is the knob a "brightness" or "peak" slider in a settings screen
+     * drives. Without it a tone curve only approaches 1 asymptotically, so
+     * nothing in the frame is ever quite white and a player who wants a
+     * brighter picture can only raise `exposure`, which lifts the midtones
+     * with it. A white point moves where the shoulder lands instead.
+     *
+     * Implemented as a scale rather than a reshaped curve: the value is run
+     * through the same curve on the CPU and the shader multiplies by its
+     * reciprocal, so `white` maps to exactly 1 and everything under it keeps
+     * the curve's shape. Values above it clip, which is what "white point"
+     * means.
+     * @param {number} white - the value to map to white; `0` or less restores the curve's own shoulder
+     * @throws {Error} if `white` is not a finite number
+     */
+    setWhite(white: number): void;
+    /**
+     * set the exposure. Cheap, and safe to drive per frame: it is a uniform,
+     * so changing it does not rebuild the program the way `mode` would.
+     * @param {number} exposure - multiplier applied before the curve; `0` maps everything to black
+     * @throws {Error} if `exposure` is not a finite number
+     */
+    setExposure(exposure: number): void;
+    exposure: number | undefined;
+}
+import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
+//# sourceMappingURL=tonemap.d.ts.map

package/build/video/effects/tonemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tonemap.d.ts","sourceRoot":"","sources":["../../../src/video/effects/tonemap.js"],"names":[],"mappings":";;;;QAwEM,eAHO,MAAM,GACJ,MAAM,CAIlB;;;;;;;QAkBG,wBADQ,MAAM,GAA0B,MAAM,CAMjD;;;;;;;;QAWG,wBADQ,MAAM,GAA0B,MAAM,CAGjD;;;;AA6FH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IACC;;;;;;;OAOG;IACH,sBAPW,QAAQ,YAEhB;QAAyB,IAAI;QACJ,QAAQ;QACR,KAAK;KAC9B,EAuCF;IAhBA;;;;OAIG;IACH,eAHU,MAAM,CAGA;IAGhB;;;;;OAKG;IACH,gBAHU,MAAM,CAGF;IAIf;;;;;;;;;;;;;;;;OAgBG;IACH,gBAHW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,QAOhB;IAFA,6BAAqC;CAGtC;yBAzUwB,mBAAmB;0BAOnB,gBAAgB"}

package/build/video/effects/vignette.d.ts

@@ -16,12 +16,12 @@
  */
 export default class VignetteEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.strength=0.15] - edge darkening power (lower = stronger darkening, higher = softer falloff)
      * @param {number} [options.size=25.0] - vignette spread multiplier (higher = smaller dark area)
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         strength?: number | undefined;
         size?: number | undefined;
     });
@@ -39,4 +39,5 @@ export default class VignetteEffect extends ShaderEffect {
     setSize(size: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=vignette.d.ts.map

package/build/video/effects/vignette.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../src/video/effects/vignette.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,QAAQ;QACR,IAAI;KAC/B,EASA;IALA,iBAAwC;IACxC,aAAgC;IAMjC;;;OAGG;IACH,sBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,cAFW,MAAM,QAKhB;CACD;yBA/EwB,mBAAmB"}
+{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../src/video/effects/vignette.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAAyB,QAAQ;QACR,IAAI;KAC/B,EASA;IALA,iBAAwC;IACxC,aAAgC;IAMjC;;;OAGG;IACH,sBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,cAFW,MAAM,QAKhB;CACD;yBAtFwB,mBAAmB;0BAOnB,gBAAgB"}

package/build/video/effects/wave.d.ts

@@ -12,22 +12,17 @@
  */
 export default class WaveEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.amplitude=0.01] - wave displacement strength (in UV space, 0.01 = subtle)
      * @param {number} [options.frequency=10.0] - number of waves across the sprite
      * @param {number} [options.speed=2.0] - wave animation speed
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         amplitude?: number | undefined;
         frequency?: number | undefined;
         speed?: number | undefined;
     });
-    /**
-     * set the current time (call each frame for animation)
-     * @param {number} time - time in seconds
-     */
-    setTime(time: number): void;
     /**
      * set the wave amplitude
      * @param {number} amplitude - displacement strength in UV space
@@ -40,4 +35,5 @@ export default class WaveEffect extends ShaderEffect {
     setFrequency(frequency: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=wave.d.ts.map

package/build/video/effects/wave.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wave.d.ts","sourceRoot":"","sources":["../../../src/video/effects/wave.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;GAWG;AACH;IACC;;;;;;OAMG;IACH,sBANW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,SAAS;QACT,SAAS;QACT,KAAK;KAChC,EAqBA;IAED;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;CACD;yBArFwB,mBAAmB"}
+{"version":3,"file":"wave.d.ts","sourceRoot":"","sources":["../../../src/video/effects/wave.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;GAWG;AACH;IACC;;;;;;OAMG;IACH,sBANW,QAAQ,YAEhB;QAAyB,SAAS;QACT,SAAS;QACT,KAAK;KAChC,EAqBA;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;CACD;yBApFwB,mBAAmB;0BAOnB,gBAAgB"}

package/build/video/gpu/batcher.d.ts

@@ -24,10 +24,16 @@ export class Batcher {
      * Initialize (or re-initialize after a context/device loss) this batcher.
      * Derived classes override this with their full `(renderer, settings)`
      * signature and own the whole body; the base implementation only stores
-     * the renderer reference.
+     * the renderer reference and ignores the settings.
+     *
+     * `settings` is declared here even though this body does not read it: a
+     * subclass cannot add a required parameter the base does not have without
+     * breaking substitutability, and the backends all take one.
      * @param {Renderer} renderer - the owning renderer
+     * @param {object} [settings] - backend-specific batcher settings, owned
+     * and documented by the derived class
      */
-    init(renderer: Renderer): void;
+    init(renderer: Renderer, settings?: object): void;
     /**
      * the renderer this batcher is bound to
      * @type {Renderer}

package/build/video/gpu/batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/batcher.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AACH,mCAAoC,IAAI,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAMC;;;;;;OAMG;IACH,eAFW,QAAQ,QAQlB;IALA;;;OAGG;IACH,+BAAwB;IAGzB;;OAEG;IACH,aAAS;IAET;;OAEG;IACH,eAAW;IAEX;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,gBAAY;CACZ;;0BA/EwB,gBAAgB"}
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/batcher.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AACH,mCAAoC,IAAI,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAMC;;;;;;;;;;;;OAYG;IAEH,eALW,QAAQ,aACR,MAAM,QAUhB;IALA;;;OAGG;IACH,+BAAwB;IAGzB;;OAEG;IACH,aAAS;IAET;;OAEG;IACH,eAAW;IAEX;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,gBAAY;CACZ;;0BAtFwB,gBAAgB"}

package/build/video/gpu/vertexformat.d.ts

@@ -1,3 +1,7 @@
+/**
+ * additional import for TypeScript
+ * @import {VertexScalar} from "./vertexformat.ts";
+ */
 /**
  * Backend-neutral vertex attribute formats.
  *
@@ -18,6 +22,10 @@
  * import it without pulling in the WebGL layer.
  * @see {@link Batcher#addAttribute}
  */
+/**
+ * The scalar component type underlying a {@link VertexFormat}.
+ */
+export type VertexScalar = "float32" | "uint8" | "sint8" | "unorm8" | "snorm8" | "uint16" | "sint16" | "unorm16" | "snorm16" | "uint32" | "sint32";
 /**
  * A vertex attribute format: component type and count.
  *
@@ -28,6 +36,24 @@
  * indefinitely.
  */
 export type VertexFormat = "float32" | "float32x2" | "float32x3" | "float32x4" | "uint8" | "uint8x2" | "uint8x4" | "sint8" | "sint8x2" | "sint8x4" | "unorm8" | "unorm8x2" | "unorm8x4" | "snorm8" | "snorm8x2" | "snorm8x4" | "uint16" | "uint16x2" | "uint16x4" | "sint16" | "sint16x2" | "sint16x4" | "unorm16" | "unorm16x2" | "unorm16x4" | "snorm16" | "snorm16x2" | "snorm16x4" | "uint32" | "uint32x2" | "uint32x3" | "uint32x4" | "sint32" | "sint32x2" | "sint32x3" | "sint32x4";
+/**
+ * What a {@link VertexFormat} resolves to.
+ *
+ * Public, because the exported `resolveVertexFormat()` returns it. Marked
+ * internal it was stripped from the declarations while that public signature
+ * kept naming it, which left the name unresolved and quietly turned the
+ * function's return type into `any` for every consumer.
+ */
+export interface VertexFormatInfo {
+    /** number of components (1, 2, 3 or 4) */
+    components: 1 | 2 | 3 | 4;
+    /** total size of the attribute in bytes */
+    bytes: number;
+    /** whether integer values are scaled into `[0, 1]` / `[-1, 1]` when read by a shader */
+    normalized: boolean;
+    /** the underlying scalar type */
+    scalar: VertexScalar;
+}
 /**
  * Whether a value is a supported vertex format name.
  * @param value - the value to test

package/build/video/gpu/vertexformat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertexformat.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/vertexformat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAoBH;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAErB,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,GAEX,OAAO,GACP,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,SAAS,GAET,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,SAAS,GACT,WAAW,GACX,WAAW,GACX,SAAS,GACT,WAAW,GACX,WAAW,GAEX,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,CAAC;AAkId;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,gBAAgB,CAS1E"}
+{"version":3,"file":"vertexformat.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/vertexformat.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;GAEG;AACH,MAAM,MAAM,YAAY,GACrB,SAAS,GACT,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAErB,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,GAEX,OAAO,GACP,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,SAAS,GAET,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,SAAS,GACT,WAAW,GACX,WAAW,GACX,SAAS,GACT,WAAW,GACX,WAAW,GAEX,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,CAAC;AAEd;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAChC,0CAA0C;IAC1C,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1B,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,wFAAwF;IACxF,UAAU,EAAE,OAAO,CAAC;IACpB,iCAAiC;IACjC,MAAM,EAAE,YAAY,CAAC;CACrB;AAkHD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,gBAAgB,CAS1E"}

package/build/video/gradient.d.ts

@@ -1,3 +1,4 @@
+
 /**
  * A Gradient object representing a linear or radial gradient fill.
  * Created via {@link Renderer#createLinearGradient} or {@link Renderer#createRadialGradient}.
@@ -58,6 +59,5 @@ export class Gradient {
      */
     destroy(): void;
 }
-import CanvasRenderTarget from "./rendertarget/canvasrendertarget.js";
 import type { Color } from "../math/color.ts";
 //# sourceMappingURL=gradient.d.ts.map

package/build/video/gradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gradient.d.ts","sourceRoot":"","sources":["../../src/video/gradient.js"],"names":[],"mappings":"AAmCA;;;;GAIG;AACH;IACC;;;OAGG;IACH,kBAHW,QAAQ,GAAC,QAAQ,UACjB,MAAM,EAAE,EA8DlB;IA3DA;;;OAGG;IACH;;;OAGG;IACH,YAA2B;IAE3B,0BAAgB;IAEhB;;;;;OAKG;IACH,QAJU,MAAM,EAAE,CAIE;IAEpB;;;;;OAKG;IACH,YAJU,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAI5B;IAEpB;;;;;OAKG;IACH,iBAJU,cAAc,GAAC,SAAS,CAIF;IAEhC;;;;;OAKG;IACH,eAJU,kBAAkB,GAAC,SAAS,CAIR;IAE9B;;;;;OAKG;IACH,QAJU,OAAO,CAIC;IAElB;;;;;OAKG;IACH,cAJU;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,EAAE,GAAC,IAAI,CAIvB;IAGzB;;;;;;;;;OASG;IACH,qBARW,MAAM,SACN,KAAK,GAAC,MAAM,GACV,QAAQ,CA0BpB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,0BAVW,wBAAwB,GACtB,cAAc,CAuC1B;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,mBATW,cAAc,GAAC,aAAa,KAC5B,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ;QAAC,MAAM,EAAE,iBAAiB,GAAC,eAAe,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAyFtF;IAED;;;;;;;;;;;OAWG;IACH,qBATW,MAAM,OACN,KAAK,GACH,KAAK,CA+CjB;IAED;;;;OAIG;IACH,0BAWC;IAED;;OAEG;IACH,gBAOC;CACD;+BAvX8B,sCAAsC;2BAF7C,kBAAkB"}
+{"version":3,"file":"gradient.d.ts","sourceRoot":"","sources":["../../src/video/gradient.js"],"names":[],"mappings":"AA8XA;;;;;;;;;;;;;;;;;GAiBG;AACH,6CANG;IAAyE,QAAQ;aAAhD,MAAM;eAAS,MAAM,GAAC,KAAK;;IAC7B,KAAK;CACpC,GAAU,QAAQ,CAiCpB;AA1YD;;;;GAIG;AACH;IACC;;;OAGG;IACH,kBAHW,QAAQ,GAAC,QAAQ,UACjB,MAAM,EAAE,EA8DlB;IA3DA;;;OAGG;IACH;;;OAGG;IACH,YAA2B;IAE3B,0BAAgB;IAEhB;;;;;OAKG;IACH,QAJU,MAAM,EAAE,CAIE;IAEpB;;;;;OAKG;IACH,YAJU,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAI5B;IAEpB;;;;;OAKG;IACH,iBAJU,cAAc,GAAC,SAAS,CAIF;IAEhC;;;;;OAKG;IACH,eAJU,kBAAkB,GAAC,SAAS,CAIR;IAE9B;;;;;OAKG;IACH,QAJU,OAAO,CAIC;IAElB;;;;;OAKG;IACH,cAJU;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,EAAE,GAAC,IAAI,CAIvB;IAGzB;;;;;;;;;OASG;IACH,qBARW,MAAM,SACN,KAAK,GAAC,MAAM,GACV,QAAQ,CA0BpB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,0BAVW,wBAAwB,GACtB,cAAc,CAuC1B;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,mBATW,QAAQ,KACR,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ;QAAC,MAAM,EAAE,iBAAiB,GAAC,eAAe,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAyFtF;IAED;;;;;;;;;;;OAWG;IACH,qBATW,MAAM,OACN,KAAK,GACH,KAAK,CA+CjB;IAED;;;;OAIG;IACH,0BAWC;IAED;;OAEG;IACH,gBAOC;CACD;2BAzXuB,kBAAkB;+BAEX,sCAAsC"}

package/build/video/renderer.d.ts

@@ -104,6 +104,42 @@ declare class Renderer {
      * @default false
      */
     supportsShaderTileLayers: boolean;
+    /**
+     * Whether the effect chain is carrying color values above 1 instead
+     * of clamping at every write. This is what the `hdr` application
+     * setting asked for and what it actually GOT: a GPU backend sets it
+     * when the setting is on and the driver can honour it, and leaves it
+     * `false` when either is missing. `false` always on the base/Canvas
+     * renderer, which has no render targets.
+     *
+     * Branch on this rather than on `settings.hdr` when a grade depends
+     * on it, because a look tuned for headroom applied to a chain that
+     * clamps is not a lesser version of that look, it is a dark picture.
+     *
+     * **Headroom through the chain, not HDR output.** The frame is
+     * presented in SDR by default, so anything still above 1 clamps on
+     * the final blit; what this buys is that nothing clamped BEFORE
+     * then, which is what makes a bloom threshold and a tone curve
+     * meaningful. To remove that last clamp as well, see
+     * {@link Renderer#supportsHDROutput} and the `hdrOutput` setting.
+     * @type {boolean}
+     * @default false
+     */
+    supportsHDR: boolean;
+    /**
+     * Whether the frame is PRESENTED in the display's full dynamic range
+     * rather than clamped to SDR on the way to the screen.
+     *
+     * The difference from {@link Renderer#supportsHDR}: that one is
+     * headroom through the effect chain, which still ends in a clamp;
+     * this one removes that clamp. Granted, not supported, and expect it
+     * to differ per backend on the same machine — only the WebGPU
+     * backend can do it, because the WebGL2 equivalent is an unapproved
+     * specification change no browser implements.
+     * @type {boolean}
+     * @default false
+     */
+    supportsHDROutput: boolean;
     /**
      * Whether this renderer backend can keep mesh geometry resident on the
      * GPU, letting a mesh supply a model matrix instead of vertices it has
@@ -543,6 +579,65 @@ declare class Renderer {
      * @param {boolean} [enable=false]
      */
     setAntiAlias(enable?: boolean): void;
+    /**
+     * Set the tone curve applied at the end of the camera's chain.
+     *
+     * The settings-screen entry point: a game can drive this straight from an
+     * options menu, and the cheap half is genuinely cheap. Changing `mode`
+     * rebuilds one shader, because the curve is baked into it; changing
+     * `exposure` or `white` is a uniform write, so either can be driven per
+     * frame (dipping exposure when the player is hit, say).
+     *
+     * **A curve is a look decision, not a companion to `hdr`.** Every curve
+     * maps 1 to less than 1, so switching one on will change a game whose art
+     * is authored against a clamp. Turn it on for art authored in linear
+     * light, or when you want a deliberate grade.
+     * @param {"none"|"aces"|"reinhard"|"exponential"} [mode="none"] - the curve, or `"none"` to remove it
+     * @param {object} [options] - curve parameters, each left as-is when omitted
+     * @param {number} [options.exposure] - multiplier applied before the curve
+     * @param {number} [options.white] - the post-exposure value to map to display white; `0` leaves the curve its own shoulder
+     * @throws {Error} on an unknown `mode`, or a non-finite `exposure` or `white`
+     * @example
+     * // straight from a settings screen
+     * renderer.setToneMapping(settings.curve, {
+     *     exposure: settings.brightness,
+     *     white: settings.peak,
+     * });
+     *
+     * // and off again
+     * renderer.setToneMapping("none");
+     */
+    setToneMapping(mode?: "none" | "aces" | "reinhard" | "exponential", options?: {
+        exposure?: number | undefined;
+        white?: number | undefined;
+    }): void;
+    /**
+     * Turn the `hdrOutput` application setting on or off at runtime.
+     *
+     * Records the request. A backend that can honour it overrides this to
+     * reconfigure the surface it presents into; read
+     * {@link Renderer#supportsHDROutput} afterwards for what was granted,
+     * which on every backend but WebGPU is `false`.
+     * @param {boolean} [enable=false] - whether to present in the display's full range
+     */
+    setHDROutput(enable?: boolean): void;
+    /**
+     * Turn the `hdr` application setting on or off at runtime.
+     *
+     * Records the request. A backend that can honour it overrides this to
+     * also move its render targets, so read {@link Renderer#supportsHDR}
+     * afterwards for what was actually granted — asking is not getting, and
+     * on this base renderer (and the Canvas one, which has no render targets)
+     * the answer is always `false`.
+     * @param {boolean} [enable=false] - whether the effect chain should carry
+     * values above 1
+     * @example
+     * renderer.setHDR(true);
+     * if (renderer.supportsHDR === false) {
+     *     // this driver refused: grade for a chain that clamps instead
+     * }
+     */
+    setHDR(enable?: boolean): void;
     /**
      * Resolve the default texture filter **mode** for this renderer, decoupled
      * from {@link Renderer#setAntiAlias} (which controls polygon-edge MSAA on GPU
@@ -572,15 +667,15 @@ declare class Renderer {
     setProjection(matrix: Matrix3d): void;
     /**
      * stroke the given shape
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} shape - a shape object to stroke
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds|Box3d|Sphere} [shape] - a shape object to stroke
      * @param {boolean} [fill=false] - fill the shape with the current color if true
      */
-    stroke(shape: Rect | RoundRect | Polygon | Line | Ellipse | Bounds, fill?: boolean): void;
+    stroke(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds | Box3d | Sphere, fill?: boolean): void;
     /**
      * fill the given shape
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} shape - a shape object to fill
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds|Box3d|Sphere} [shape] - a shape object to fill
      */
-    fill(shape: Rect | RoundRect | Polygon | Line | Ellipse | Bounds): void;
+    fill(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds | Box3d | Sphere): void;
     /**
      * tint the given image or canvas using the given color
      * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas} src - the source image to be tinted
@@ -798,7 +893,11 @@ declare class Renderer {
      *   NOTE the origin differs by backend: WebGL uses framebuffer coords
      *   (**bottom-left** origin), Canvas uses **top-left** — relevant under
      *   `video.AUTO`.
-     * @returns {Texture2d} a texture holding the captured frame
+     * @returns {Texture2d|null} a texture holding the captured frame, or `null`
+     *   when the backend has no device to capture with. The WebGPU renderer
+     *   returns null in that case and there is a spec pinning it, so this is the
+     *   honest contract: declaring a bare `Texture2d` here had every caller
+     *   skipping a check the implementation can require
      * @example
      * effect.setTexture("uScene", renderer.toFrameTexture());
      */
@@ -810,7 +909,7 @@ declare class Renderer {
             width: number;
             height: number;
         } | undefined;
-    }): Texture2d;
+    }): Texture2d | null;
 }
 declare namespace Renderer {
     let _whitePixel: any;
@@ -818,11 +917,13 @@ declare namespace Renderer {
 export default Renderer;
 import CanvasRenderTarget from "./rendertarget/canvasrendertarget.js";
 import { Vector2d } from "../math/vector2d.ts";
-import type RenderTargetPool from "./rendertarget/render_target_pool.js";
+import type ShaderEffect from "./effects/shadereffect.js";
 import Path2D from "./../geometries/path2d.ts";
+import type Application from "../application/application.ts";
 import { Color } from "./../math/color.ts";
 import RenderState from "./renderstate.js";
 import { Matrix3d } from "../math/matrix3d.ts";
+import type Mesh from "../renderable/mesh.js";
 import type { Rect } from "./../geometries/rectangle.ts";
 import { Gradient } from "./gradient.js";
 import type { Bounds } from "./../physics/bounds.ts";
@@ -830,5 +931,8 @@ import type { RoundRect } from "./../geometries/roundrect.ts";
 import type { Polygon } from "../geometries/polygon.ts";
 import type { Line } from "./../geometries/line.ts";
 import type { Ellipse } from "./../geometries/ellipse.ts";
+import type { Box3d } from "../geometries/box3d.ts";
+import type { Sphere } from "../geometries/sphere.ts";
 import type { default as Texture2d } from "./texture/texture2d.ts";
+import type { ApplicationSettings } from "../application/settings.ts";
 //# sourceMappingURL=renderer.d.ts.map