@aura3d/rendering 1.5.2 → 2.0.0

package/dist/WebGL2Device.js

@@ -1,6 +1,6 @@
 import { RenderDeviceError, } from "./RenderDevice.js";
 import { Texture, isCompressedTextureFormat, isFloatColorTextureFormat } from "./Texture.js";
-import { TextureBinding } from "./TextureBinding.js";
+import { isTextureBinding, TextureBinding } from "./TextureBinding.js";
 import {} from "./VertexFormat.js";
 import { WebGL2StateCache } from "./WebGL2StateCache.js";
 import { BLOOM_BRIGHT_LUT_HEIGHT, BLOOM_BRIGHT_LUT_WIDTH, BLOOM_COMPOSITE_LUT_SIZE, OUTLINE_BLEND_LUT_WIDTH, OUTLINE_LIMB_RADIX, createOutlineBlendLut, createOutlineGradientBound, createBloomBrightThresholdLut, createBloomCompositeLut } from "./postprocess/NativeLdrEffectLuts.js";
@@ -169,6 +169,16 @@ export class WebGL2Device {
     maxVertexAttributes;
     anisotropicFilteringExtension;
     maxTextureAnisotropy;
+    /**
+     * WS-2.6 — subscribers for context loss and restoration.
+     *
+     * The device has tracked `contextLost` since before 1.6 and acted on it internally, but nothing
+     * could *observe* it: there was no callback, so a consumer could only poll `diagnostics()`. That is
+     * why the parity table listed context-loss recovery as a gap while the listeners existed — the
+     * device layer was never the gap, the absence of a public signal was.
+     */
+    deviceLostListeners = new Set();
+    deviceRestoredListeners = new Set();
     contextLostListener;
     contextRestoredListener;
     canvas;
@@ -196,6 +206,16 @@ export class WebGL2Device {
     constructor(gl, canvas, errorCheckMode) {
         this.errorCheckMode = errorCheckMode;
         this.gl = gl;
+        // A browser returns the same WebGL2 context object after `webglcontextrestored`.
+        // The controller that owned it before the loss is disposed before a replacement
+        // device mounts, and Chromium can leave an INVALID_OPERATION from that stale
+        // resource teardown in the context's error queue. A fresh device must establish
+        // its own error boundary; otherwise its first valid uniform upload or presentation
+        // is blamed for an error produced by the previous owner.
+        for (let index = 0; index < 16 && gl.getError() !== gl.NO_ERROR; index += 1) {
+            // Drain only errors that predate this device. Normal frame/strict checks still
+            // report every error generated after construction.
+        }
         this.maxVertexAttributes = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
         this.anisotropicFilteringExtension = gl.getExtension("EXT_texture_filter_anisotropic");
         this.maxTextureAnisotropy = this.anisotropicFilteringExtension
@@ -230,15 +250,53 @@ export class WebGL2Device {
                 this.contextLost = true;
                 this.lastError = "CONTEXT_LOST";
                 this.frameActive = false;
+                // WS-2.6: notify subscribers. Errors in a listener must not prevent the others from running,
+                // nor leave the device in a half-notified state during an already-degraded condition.
+                for (const listener of [...this.deviceLostListeners]) {
+                    try {
+                        listener();
+                    }
+                    catch {
+                        // A listener that throws is the listener's problem; the device stays consistent.
+                    }
+                }
             });
             this.contextRestoredListener = (() => {
                 this.contextLost = false;
                 this.lastError = null;
+                for (const listener of [...this.deviceRestoredListeners]) {
+                    try {
+                        listener();
+                    }
+                    catch {
+                        // As above.
+                    }
+                }
             });
             canvas.addEventListener("webglcontextlost", this.contextLostListener);
             canvas.addEventListener("webglcontextrestored", this.contextRestoredListener);
         }
     }
+    /**
+     * Subscribe to WebGL context loss. Returns an unsubscribe function.
+     *
+     * A lost context is not an error a caller can prevent — the browser reclaims GPU resources under
+     * memory pressure, on driver reset, or when a tab is backgrounded too long. What a caller can do is
+     * be told, so it can recreate resources rather than render nothing.
+     */
+    onDeviceLost(listener) {
+        this.deviceLostListeners.add(listener);
+        return () => this.deviceLostListeners.delete(listener);
+    }
+    /** Subscribe to context restoration. Returns an unsubscribe function. */
+    onDeviceRestored(listener) {
+        this.deviceRestoredListeners.add(listener);
+        return () => this.deviceRestoredListeners.delete(listener);
+    }
+    /** True while the WebGL context is lost. Polling alternative to {@link onDeviceLost}. */
+    isDeviceLost() {
+        return this.contextLost;
+    }
     createBuffer(usage, byteLength, initialData) {
         this.assertAlive();
         if (byteLength <= 0 || !Number.isInteger(byteLength)) {
@@ -574,13 +632,6 @@ export class WebGL2Device {
                 format: source.colorTexture.format
             });
         }
-        if (source.colorTexture.format !== "rgba8" && bloomPass) {
-            throw new RenderDeviceError("WebGL2 native LUT bloom accepts rgba8 input; HDR bloom must use the renderer float-bloom path before tone mapping.", "WEBGL_LDR_POSTPROCESS_FORMAT_UNSUPPORTED", {
-                targetId: source.id,
-                format: source.colorTexture.format,
-                pass: "bloom"
-            });
-        }
         if (source.colorTexture.format !== "rgba8" && (depthOfFieldPass || motionBlurPass || ssaoPass || ssrPass || taaPass || outlinePass) && !tonePass) {
             throw new RenderDeviceError("WebGL2 byte-kernel postprocess requires rgba8 input or a preceding tone-mapping pass.", "WEBGL_LDR_POSTPROCESS_FORMAT_UNSUPPORTED", {
                 targetId: source.id,
@@ -628,10 +679,11 @@ export class WebGL2Device {
         const outlineOptions = outlinePass ? normalizeNativeOutlineOptions(outlinePass.options) : undefined;
         const program = this.ensureLdrPostprocessProgram();
         const vertexArray = this.ensurePresentationVertexArray();
+        const sourceIsHdr = source.colorTexture.format !== "rgba8";
         const bloomResources = bloomOptions || depthOfFieldOptions || motionBlurOptions || ssaoOptions || ssrOptions || taaOptions || outlineOptions
-            ? this.ensureBloomPingPongResources(source.width, source.height)
+            ? this.ensureBloomPingPongResources(source.width, source.height, sourceIsHdr && Boolean(bloomOptions))
             : undefined;
-        if (bloomOptions) {
+        if (bloomOptions && !sourceIsHdr) {
             this.ensureBloomLutTextures(bloomOptions);
         }
         if (outlineOptions) {
@@ -650,7 +702,7 @@ export class WebGL2Device {
             let ldrSourceHandle = source.colorHandle;
             let temporarySourceIndex = -1;
             if (bloomOptions && bloomResources) {
-                ldrSourceHandle = this.executeNativeBloomPasses(ldrSourceHandle, bloomResources, bloomOptions, vertexArray);
+                ldrSourceHandle = this.executeNativeBloomPasses(ldrSourceHandle, bloomResources, bloomOptions, vertexArray, sourceIsHdr);
                 temporarySourceIndex = 1;
             }
             if ((depthOfFieldOptions || motionBlurOptions || ssaoOptions || ssrOptions || taaOptions || outlineOptions) && bloomResources) {
@@ -1008,6 +1060,8 @@ export class WebGL2Device {
     }
     dispose() {
         if (this.canvas && "removeEventListener" in this.canvas) {
+            this.deviceLostListeners.clear();
+            this.deviceRestoredListeners.clear();
             if (this.contextLostListener)
                 this.canvas.removeEventListener("webglcontextlost", this.contextLostListener);
             if (this.contextRestoredListener)
@@ -1223,9 +1277,9 @@ export class WebGL2Device {
             this.restoreFullscreenPresentationState(previousState, outputWidth, outputHeight);
         }
     }
-    ensureBloomPingPongResources(width, height) {
+    ensureBloomPingPongResources(width, height, hdr = false) {
         const current = this.bloomPingPongResources;
-        if (current && current.width === width && current.height === height) {
+        if (current && current.width === width && current.height === height && current.hdr === hdr) {
             return current;
         }
         this.disposeBloomPingPongResources();
@@ -1255,7 +1309,7 @@ export class WebGL2Device {
                 this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.NEAREST);
                 this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
                 this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
-                this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA8, width, height, 0, this.gl.RGBA, this.gl.UNSIGNED_BYTE, null);
+                this.gl.texImage2D(this.gl.TEXTURE_2D, 0, hdr ? this.gl.RGBA16F : this.gl.RGBA8, width, height, 0, this.gl.RGBA, hdr ? this.gl.HALF_FLOAT : this.gl.UNSIGNED_BYTE, null);
                 this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, framebuffer);
                 this.gl.framebufferTexture2D(this.gl.FRAMEBUFFER, this.gl.COLOR_ATTACHMENT0, this.gl.TEXTURE_2D, texture, 0);
                 const status = this.gl.checkFramebufferStatus(this.gl.FRAMEBUFFER);
@@ -1271,6 +1325,7 @@ export class WebGL2Device {
             const resources = {
                 width,
                 height,
+                hdr,
                 textures: [textures[0], textures[1]],
                 framebuffers: [framebuffers[0], framebuffers[1]]
             };
@@ -1412,10 +1467,10 @@ export class WebGL2Device {
         this.gl.uniform1f(this.gl.getUniformLocation(program, "u_subpixelBlend"), numberOption(fxaaOptions, "subpixelBlend", 0.75));
         this.gl.drawArrays(this.gl.TRIANGLES, 0, 3);
     }
-    executeNativeBloomPasses(sourceTexture, resources, options, vertexArray) {
+    executeNativeBloomPasses(sourceTexture, resources, options, vertexArray, hdr) {
         const brightLut = this.bloomBrightLutTexture;
         const compositeLut = this.bloomCompositeLutTexture;
-        if (!brightLut || !compositeLut) {
+        if (!hdr && (!brightLut || !compositeLut)) {
             throw new RenderDeviceError("WebGL2 bloom lookup textures were not initialized", "WEBGL_ALLOCATION_FAILED");
         }
         const [textureA, textureB] = resources.textures;
@@ -1426,9 +1481,12 @@ export class WebGL2Device {
         this.gl.useProgram(brightProgram);
         this.gl.bindVertexArray(vertexArray);
         this.bindFullscreenTexture(0, sourceTexture);
-        this.bindFullscreenTexture(1, brightLut);
+        if (brightLut)
+            this.bindFullscreenTexture(1, brightLut);
         this.gl.uniform1i(this.gl.getUniformLocation(brightProgram, "u_source"), 0);
         this.gl.uniform1i(this.gl.getUniformLocation(brightProgram, "u_brightLut"), 1);
+        this.gl.uniform1i(this.gl.getUniformLocation(brightProgram, "u_hdr"), hdr ? 1 : 0);
+        this.gl.uniform1f(this.gl.getUniformLocation(brightProgram, "u_threshold"), options.threshold);
         this.gl.drawArrays(this.gl.TRIANGLES, 0, 3);
         const blurProgram = this.ensureBloomBlurProgram();
         this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, framebufferB);
@@ -1438,6 +1496,7 @@ export class WebGL2Device {
         this.gl.uniform2i(this.gl.getUniformLocation(blurProgram, "u_size"), resources.width, resources.height);
         this.gl.uniform1i(this.gl.getUniformLocation(blurProgram, "u_radius"), options.radius);
         this.gl.uniform1i(this.gl.getUniformLocation(blurProgram, "u_horizontal"), 1);
+        this.gl.uniform1i(this.gl.getUniformLocation(blurProgram, "u_hdr"), hdr ? 1 : 0);
         this.gl.drawArrays(this.gl.TRIANGLES, 0, 3);
         this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, framebufferA);
         this.bindFullscreenTexture(0, textureB);
@@ -1448,10 +1507,13 @@ export class WebGL2Device {
         this.gl.useProgram(compositeProgram);
         this.bindFullscreenTexture(0, sourceTexture);
         this.bindFullscreenTexture(1, textureA);
-        this.bindFullscreenTexture(2, compositeLut);
+        if (compositeLut)
+            this.bindFullscreenTexture(2, compositeLut);
         this.gl.uniform1i(this.gl.getUniformLocation(compositeProgram, "u_source"), 0);
         this.gl.uniform1i(this.gl.getUniformLocation(compositeProgram, "u_blurred"), 1);
         this.gl.uniform1i(this.gl.getUniformLocation(compositeProgram, "u_compositeLut"), 2);
+        this.gl.uniform1i(this.gl.getUniformLocation(compositeProgram, "u_hdr"), hdr ? 1 : 0);
+        this.gl.uniform1f(this.gl.getUniformLocation(compositeProgram, "u_intensity"), options.intensity);
         this.gl.drawArrays(this.gl.TRIANGLES, 0, 3);
         return textureB;
     }
@@ -1792,6 +1854,8 @@ precision highp float;
 precision highp int;
 uniform sampler2D u_source;
 uniform sampler2D u_brightLut;
+uniform int u_hdr;
+uniform float u_threshold;
 out vec4 outColor;
 
 uvec4 byteTexel(sampler2D source, ivec2 coordinate) {
@@ -1800,6 +1864,12 @@ uvec4 byteTexel(sampler2D source, ivec2 coordinate) {
 
 void main() {
   ivec2 pixel = ivec2(gl_FragCoord.xy);
+  if (u_hdr == 1) {
+    vec4 source = texelFetch(u_source, pixel, 0);
+    float luma = dot(source.rgb, vec3(0.2126, 0.7152, 0.0722));
+    outColor = luma >= u_threshold ? source : vec4(0.0);
+    return;
+  }
   uvec4 source = byteTexel(u_source, pixel);
   uint colorIndex = (source.r << 16u) | (source.g << 8u) | source.b;
   uint byteIndex = colorIndex >> 3u;
@@ -1834,6 +1904,7 @@ uniform sampler2D u_source;
 uniform ivec2 u_size;
 uniform int u_radius;
 uniform int u_horizontal;
+uniform int u_hdr;
 out vec4 outColor;
 
 uvec4 sourceByte(ivec2 coordinate) {
@@ -1843,6 +1914,16 @@ uvec4 sourceByte(ivec2 coordinate) {
 
 void main() {
   ivec2 pixel = ivec2(gl_FragCoord.xy);
+  if (u_hdr == 1) {
+    vec4 sum = vec4(0.0);
+    for (int offset = -16; offset <= 16; offset += 1) {
+      if (abs(offset) > u_radius) continue;
+      ivec2 sampleCoordinate = pixel + (u_horizontal == 1 ? ivec2(offset, 0) : ivec2(0, offset));
+      sum += texelFetch(u_source, clamp(sampleCoordinate, ivec2(0), u_size - ivec2(1)), 0);
+    }
+    outColor = sum / float(u_radius * 2 + 1);
+    return;
+  }
   uvec4 sum = uvec4(0u);
   for (int offset = -16; offset <= 16; offset += 1) {
     if (abs(offset) > u_radius) {
@@ -1872,6 +1953,8 @@ precision highp int;
 uniform sampler2D u_source;
 uniform sampler2D u_blurred;
 uniform sampler2D u_compositeLut;
+uniform int u_hdr;
+uniform float u_intensity;
 out vec4 outColor;
 
 uvec4 byteTexel(sampler2D source, ivec2 coordinate) {
@@ -1884,6 +1967,12 @@ float compositeChannel(uint source, uint blurred) {
 
 void main() {
   ivec2 pixel = ivec2(gl_FragCoord.xy);
+  if (u_hdr == 1) {
+    vec4 source = texelFetch(u_source, pixel, 0);
+    vec3 blurred = texelFetch(u_blurred, pixel, 0).rgb;
+    outColor = vec4(source.rgb + blurred * u_intensity, source.a);
+    return;
+  }
   uvec4 source = byteTexel(u_source, pixel);
   uvec4 blurred = byteTexel(u_blurred, pixel);
   outColor = vec4(
@@ -2238,8 +2327,28 @@ vec3 encodeColor(vec3 color) {
   return u_outputColorSpace == 1 ? vec3(linearToSrgb(linear.r), linearToSrgb(linear.g), linearToSrgb(linear.b)) : linear;
 }
 
-float aces(float value) {
-  return (value * (2.51 * value + 0.03)) / (value * (2.43 * value + 0.59) + 0.14);
+vec3 acesRrtAndOdtFit(vec3 value) {
+  vec3 numerator = value * (value + 0.0245786) - 0.000090537;
+  vec3 denominator = value * (0.983729 * value + 0.4329510) + 0.238081;
+  return numerator / denominator;
+}
+
+vec3 acesFilmic(vec3 color) {
+  // Match current Three.js ACESFilmicToneMapping. ACES is a coupled RGB
+  // transform; a scalar approximation shifts hue and washes saturated colors.
+  const mat3 acesInput = mat3(
+    vec3(0.59719, 0.07600, 0.02840),
+    vec3(0.35458, 0.90834, 0.13383),
+    vec3(0.04823, 0.01566, 0.83777)
+  );
+  const mat3 acesOutput = mat3(
+    vec3(1.60475, -0.10208, -0.00327),
+    vec3(-0.53108, 1.10813, -0.07276),
+    vec3(-0.07367, -0.00605, 1.07602)
+  );
+  vec3 acesColor = acesInput * (color / 0.6);
+  acesColor = acesRrtAndOdtFit(acesColor);
+  return clamp(acesOutput * acesColor, 0.0, 1.0);
 }
 
 float filmic(float value) {
@@ -2279,7 +2388,7 @@ float toneMapChannel(float value) {
   float exposed = max(0.0, value * u_exposure) / max(0.0001, u_whitePoint);
   if (u_toneOperator == 0) return min(1.0, exposed);
   if (u_toneOperator == 1) return exposed / (1.0 + exposed);
-  if (u_toneOperator == 2) return aces(exposed);
+  if (u_toneOperator == 2) return exposed;
   if (u_toneOperator == 3) return filmic(exposed);
   if (u_toneOperator == 4) return uncharted2(exposed);
   if (u_toneOperator == 5) return agx(exposed);
@@ -2289,7 +2398,9 @@ float toneMapChannel(float value) {
 vec3 applyToneMapping(vec3 color) {
   if (u_hasToneMapping == 0) return color;
   vec3 decoded = decodeColor(color);
-  vec3 mapped = vec3(toneMapChannel(decoded.r), toneMapChannel(decoded.g), toneMapChannel(decoded.b));
+  vec3 mapped = u_toneOperator == 2
+    ? acesFilmic(max(vec3(0.0), decoded * u_exposure) / max(0.0001, u_whitePoint))
+    : vec3(toneMapChannel(decoded.r), toneMapChannel(decoded.g), toneMapChannel(decoded.b));
   return encodeColor(mapped);
 }
 
@@ -2422,7 +2533,7 @@ void main() {
             if (location === null) {
                 throw new RenderDeviceError("Material tried to bind a missing shader uniform", "MISSING_UNIFORM", { name });
             }
-            if (value instanceof TextureBinding) {
+            if (isTextureBinding(value)) {
                 this.uploadTextureUniform(location, value, textureUnit);
                 textureUnit += 1;
             }