@aura3d/rendering 1.4.5 → 1.5.2

package/dist/PostProcessPass.js

@@ -1,5 +1,6 @@
 import { BaseRenderPass } from "./RenderPass.js";
 import { RenderDeviceError } from "./RenderDevice.js";
+import { OUTLINE_LUMA_SCALE, createOutlineGradientBound } from "./postprocess/NativeLdrEffectLuts.js";
 export class ToneMappingPass extends BaseRenderPass {
     options;
     exposure;
@@ -511,16 +512,20 @@ export function outlinePixels(pixels, width, height, options = {}) {
     validateRange(opacity, 0, 1, "Outline opacity");
     validateOutlineColor(color);
     const edgeMask = new Uint8Array(width * height);
-    let maxGradient = 0;
+    const gradientBound = createOutlineGradientBound(threshold).numberValue;
+    let maxGradientNumerator = 0;
     for (let y = 0; y < height; y += 1) {
         for (let x = 0; x < width; x += 1) {
-            const gradient = sobelLumaGradient(pixels, width, height, x, y);
-            maxGradient = Math.max(maxGradient, gradient);
-            if (gradient >= threshold) {
+            const { gx, gy } = sobelLumaNumeratorGradient(pixels, width, height, x, y);
+            const squared = gx * gx + gy * gy;
+            if (squared > maxGradientNumerator)
+                maxGradientNumerator = squared;
+            if (outlineEdgeExceedsBound(gx, gy, gradientBound)) {
                 edgeMask[y * width + x] = 255;
             }
         }
     }
+    const maxGradient = Math.sqrt(maxGradientNumerator) / OUTLINE_LUMA_SCALE;
     const outlineMask = dilateMask(edgeMask, width, height, outlineWidth);
     const output = new Uint8Array(pixels);
     let outlinedPixels = 0;
@@ -636,6 +641,80 @@ export function depthOfFieldPixels(pixels, width, height, options) {
     }
     return { width, height, pixels: output, blurredPixels, maxBlurRadius: maxRadius, focusDepth, focusRange };
 }
+export function volumetricLightPixels(pixels, width, height, options = {}) {
+    validatePixelBuffer(pixels, width, height, "Volumetric light");
+    const depth = requireDepthTextureBinding(options.depth, "Volumetric light");
+    if (depth.width !== width || depth.height !== height) {
+        throw new Error("Volumetric light depth texture dimensions must match source pixels.");
+    }
+    const lightPosition = options.lightPosition ?? [0.5, 0.18];
+    if (lightPosition.length !== 2 || !lightPosition.every((value) => Number.isFinite(value) && value >= 0 && value <= 1)) {
+        throw new RangeError("Volumetric light position must contain two finite normalized coordinates.");
+    }
+    const color = options.color ?? [1, 0.88, 0.62];
+    if (color.length !== 3 || !color.every((value) => Number.isFinite(value) && value >= 0 && value <= 1)) {
+        throw new RangeError("Volumetric light color must contain three finite values within [0, 1].");
+    }
+    const density = numberInRange(options.density ?? 0.9, 0.01, 2, "Volumetric light density");
+    const decay = numberInRange(options.decay ?? 0.96, 0, 1, "Volumetric light decay");
+    const weight = numberInRange(options.weight ?? 0.18, 0, 2, "Volumetric light weight");
+    const exposure = numberInRange(options.exposure ?? 0.72, 0, 4, "Volumetric light exposure");
+    const samples = integerNumberInRange(options.samples ?? 32, 4, 128, "Volumetric light samples");
+    const occlusionThreshold = numberInRange(options.occlusionThreshold ?? 0.985, 0, 1, "Volumetric light occlusionThreshold");
+    const output = new Uint8Array(pixels);
+    const lightX = lightPosition[0] * (width - 1);
+    const lightY = lightPosition[1] * (height - 1);
+    let changedPixels = 0;
+    let occludedSamples = 0;
+    let maxScattering = 0;
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const deltaX = ((lightX - x) / samples) * density;
+            const deltaY = ((lightY - y) / samples) * density;
+            let sampleX = x;
+            let sampleY = y;
+            let illuminationDecay = 1;
+            let scattering = 0;
+            for (let sample = 0; sample < samples; sample += 1) {
+                sampleX += deltaX;
+                sampleY += deltaY;
+                const sx = clampInt(Math.round(sampleX), 0, width - 1);
+                const sy = clampInt(Math.round(sampleY), 0, height - 1);
+                const offset = (sy * width + sx) * 4;
+                const luminance = ((pixels[offset] ?? 0) * 0.2126 + (pixels[offset + 1] ?? 0) * 0.7152 + (pixels[offset + 2] ?? 0) * 0.0722) / 255;
+                const source = Math.max(0, luminance - 0.42) / 0.58;
+                const sampleDepth = depthAt(depth, sx, sy);
+                const visible = sampleDepth >= occlusionThreshold || source > 0.05 ? 1 : 0;
+                if (visible === 0)
+                    occludedSamples += 1;
+                scattering += source * visible * illuminationDecay * weight;
+                illuminationDecay *= decay;
+            }
+            const boost = scattering * exposure;
+            maxScattering = Math.max(maxScattering, boost);
+            const offset = (y * width + x) * 4;
+            const beforeR = pixels[offset] ?? 0;
+            const beforeG = pixels[offset + 1] ?? 0;
+            const beforeB = pixels[offset + 2] ?? 0;
+            output[offset] = clampByte(beforeR + color[0] * boost * 255);
+            output[offset + 1] = clampByte(beforeG + color[1] * boost * 255);
+            output[offset + 2] = clampByte(beforeB + color[2] * boost * 255);
+            if (output[offset] !== beforeR || output[offset + 1] !== beforeG || output[offset + 2] !== beforeB) {
+                changedPixels += 1;
+            }
+        }
+    }
+    return {
+        width,
+        height,
+        pixels: output,
+        changedPixels,
+        occludedSamples,
+        maxScattering: Number(maxScattering.toFixed(5)),
+        sampleCount: samples,
+        method: "depth-aware-radial-participating-media"
+    };
+}
 export function motionBlurPixels(pixels, width, height, options) {
     validatePixelBuffer(pixels, width, height, "Motion blur");
     const samples = options.samples ?? 5;
@@ -1253,6 +1332,7 @@ export function fxaaPixels(pixels, width, height, options = {}) {
 }
 export function fusedLdrPostprocessPixels(pixels, width, height, passes, options = {}) {
     validatePixelBuffer(pixels, width, height, "Fused LDR postprocess");
+    const bloom = passes.find((pass) => pass.name === "bloom");
     const toneMapping = passes.find((pass) => pass.name === "tone-mapping");
     const colorGrade = passes.find((pass) => pass.name === "color-grade");
     const fxaa = passes.find((pass) => pass.name === "fxaa");
@@ -1264,7 +1344,9 @@ export function fusedLdrPostprocessPixels(pixels, width, height, passes, options
         : undefined;
     const colorGradeSettings = colorGrade ? normalizeColorGradeOptions(colorGrade.options) : undefined;
     const byteLength = pixels.byteLength;
-    let current = pixels;
+    let current = bloom
+        ? bloomPixels(pixels, width, height, bloom.options).pixels
+        : pixels;
     if (toneMappingLookup || colorGradeSettings) {
         const target = options.mutateInput
             ? pixels
@@ -1272,7 +1354,7 @@ export function fusedLdrPostprocessPixels(pixels, width, height, passes, options
         const vignetteFactors = colorGradeSettings && colorGradeSettings.vignette > 0
             ? getVignetteFactors(width, height, colorGradeSettings.vignette, options.scratch)
             : undefined;
-        applyToneMappingAndColorGrade(pixels, target, width, height, toneMappingLookup, colorGradeSettings, vignetteFactors);
+        applyToneMappingAndColorGrade(current, target, width, height, toneMappingLookup, colorGradeSettings, vignetteFactors);
         current = target;
     }
     if (colorGradeSettings && colorGradeSettings.sharpening > 0) {
@@ -1536,18 +1618,37 @@ function validateOutlineColor(color) {
         }
     }
 }
-function sobelLumaGradient(pixels, width, height, x, y) {
-    const nw = lumaAt(pixels, width, height, x - 1, y - 1);
-    const n = lumaAt(pixels, width, height, x, y - 1);
-    const ne = lumaAt(pixels, width, height, x + 1, y - 1);
-    const w = lumaAt(pixels, width, height, x - 1, y);
-    const e = lumaAt(pixels, width, height, x + 1, y);
-    const sw = lumaAt(pixels, width, height, x - 1, y + 1);
-    const s = lumaAt(pixels, width, height, x, y + 1);
-    const se = lumaAt(pixels, width, height, x + 1, y + 1);
-    const gx = -nw - 2 * w - sw + ne + 2 * e + se;
-    const gy = -nw - 2 * n - ne + sw + 2 * s + se;
-    return Math.hypot(gx, gy);
+/**
+ * Sobel response of the integer luma numerator `2126 * r + 7152 * g + 722 * b`.
+ *
+ * This is the same operator as {@link sobelLumaGradient} scaled by `OUTLINE_LUMA_SCALE`, but every
+ * intermediate is an exact integer: each numerator is at most `2550000`, so a response is at most
+ * `4 * 2550000` and the squared magnitude used by {@link outlineEdgeExceedsBound} stays below 2^48,
+ * well inside the range where float64 represents integers exactly.
+ */
+function sobelLumaNumeratorGradient(pixels, width, height, x, y) {
+    const nw = lumaNumeratorAt(pixels, width, height, x - 1, y - 1);
+    const n = lumaNumeratorAt(pixels, width, height, x, y - 1);
+    const ne = lumaNumeratorAt(pixels, width, height, x + 1, y - 1);
+    const w = lumaNumeratorAt(pixels, width, height, x - 1, y);
+    const e = lumaNumeratorAt(pixels, width, height, x + 1, y);
+    const sw = lumaNumeratorAt(pixels, width, height, x - 1, y + 1);
+    const s = lumaNumeratorAt(pixels, width, height, x, y + 1);
+    const se = lumaNumeratorAt(pixels, width, height, x + 1, y + 1);
+    return {
+        gx: -nw - 2 * w - sw + ne + 2 * e + se,
+        gy: -nw - 2 * n - ne + sw + 2 * s + se
+    };
+}
+/**
+ * Exact outline edge predicate shared by the CPU kernel and the WebGL2 shader.
+ *
+ * Equivalent to `hypot(gx, gy) >= threshold` on the real numbers, but decided with integers so
+ * that it never depends on float rounding. `bound` comes from {@link createOutlineGradientBound},
+ * which pre-squares the threshold as an exact rational and rounds up.
+ */
+function outlineEdgeExceedsBound(gx, gy, bound) {
+    return gx * gx + gy * gy >= bound;
 }
 function dilateMask(mask, width, height, radius) {
     const output = new Uint8Array(mask.length);
@@ -1793,6 +1894,16 @@ function validateRange(value, min, max, label) {
         throw new Error(`${label} must be finite and within [${min}, ${max}].`);
     }
 }
+function numberInRange(value, min, max, label) {
+    validateRange(value, min, max, label);
+    return value;
+}
+function integerNumberInRange(value, min, max, label) {
+    validateRange(value, min, max, label);
+    if (!Number.isInteger(value))
+        throw new Error(`${label} must be an integer.`);
+    return value;
+}
 function clampByte(value) {
     return Math.round(Math.max(0, Math.min(255, value)));
 }
@@ -1805,6 +1916,13 @@ function lumaAt(pixels, width, height, x, y) {
     const index = (sampleY * width + sampleX) * 4;
     return (0.2126 * pixels[index] + 0.7152 * pixels[index + 1] + 0.0722 * pixels[index + 2]) / 255;
 }
+/** Integer luma numerator at a clamped coordinate, matching the outline shader exactly. */
+function lumaNumeratorAt(pixels, width, height, x, y) {
+    const sampleX = clampInt(x, 0, width - 1);
+    const sampleY = clampInt(y, 0, height - 1);
+    const index = (sampleY * width + sampleX) * 4;
+    return 2126 * pixels[index] + 7152 * pixels[index + 1] + 722 * pixels[index + 2];
+}
 function channelAt(pixels, width, height, x, y, channel) {
     const sampleX = clampInt(x, 0, width - 1);
     const sampleY = clampInt(y, 0, height - 1);