@onerjs/core 9.0.1 → 9.0.3

package/Materials/Textures/textureProcessor.js

@@ -1,6 +1,7 @@
 import { ProceduralTexture } from "./Procedurals/proceduralTexture.pure.js";
 
 import { Color4 } from "../../Maths/math.color.pure.js";
+import { _AllTransformsMatch, _CopyTextureMetadata, _HasNonIdentityTransform, _KeepMatchingCoordinates } from "./textureSampling.functions.js";
 const _ShaderName = "textureProcessor";
 /**
  * Specifies the color space of a texture operand.
@@ -136,9 +137,43 @@ function _MaxConstants(a, b) {
     return new Color4(Math.max(a.r, b.r), Math.max(a.g, b.g), Math.max(a.b, b.b), Math.max(a.a, b.a));
 }
 /** @internal */
+function _DivideConstants(a, b) {
+    const eps = 0.00001;
+    return new Color4(a.r / Math.max(b.r, eps), a.g / Math.max(b.g, eps), a.b / Math.max(b.b, eps), a.a / Math.max(b.a, eps));
+}
+/** @internal */
 function _LerpConstants(a, b, t) {
     return new Color4(a.r + (b.r - a.r) * t.r, a.g + (b.g - a.g) * t.g, a.b + (b.b - a.b) * t.b, a.a + (b.a - a.a) * t.a);
 }
+/**
+ * Clamps a scatter anisotropy the same way the renderer does before converting between single- and
+ * multi-scatter albedo, so that |aniso| = 1 doesn't collapse the conversion.
+ * @internal
+ */
+function _EffectiveScatterAnisotropy(aniso) {
+    return Math.min(Math.max(aniso, -0.9999), 0.9999);
+}
+/** @internal */
+function _MultiScatterToSingleScatterAlbedoConstant(multiScatter, aniso) {
+    const convert = (value) => {
+        const rhoMs = Math.min(Math.max(value, 0), 1);
+        let s = 4.09712 + 4.20863 * rhoMs - Math.sqrt(9.59217 + 41.6808 * rhoMs + 17.7126 * rhoMs * rhoMs);
+        if (rhoMs === 0) {
+            s = 1;
+        }
+        return (1 - s * s) / Math.max(1 - aniso * s * s, 0.0000001);
+    };
+    return new Color4(convert(multiScatter.r), convert(multiScatter.g), convert(multiScatter.b), multiScatter.a);
+}
+/** @internal */
+function _SingleScatterToMultiScatterAlbedoConstant(singleScatter, aniso) {
+    const convert = (value) => {
+        const ssAlbedo = Math.min(Math.max(value, 0), 1);
+        const s = Math.sqrt(Math.max((1 - ssAlbedo) / Math.max(1 - aniso * ssAlbedo, 0.0000001), 0));
+        return ((1 - s) * (1 - 0.139 * s)) / (1 + 1.17 * s);
+    };
+    return new Color4(convert(singleScatter.r), convert(singleScatter.g), convert(singleScatter.b), singleScatter.a);
+}
 /**
  * @internal
  * Determine the output texture size from a list of operands, using the largest input texture.
@@ -158,49 +193,8 @@ function _ResolveOutputSize(operands) {
     }
     return result;
 }
-/**
- * @internal
- * Returns true when the texture has a non-identity UV transform (offset, scale, or rotation).
- */
-function _HasNonIdentityTransform(texture) {
-    return !texture.getTextureMatrix().isIdentity();
-}
-/**
- * @internal
- * Returns true when every texture in the list shares the same UV transform matrix.
- * A single texture (or empty list) trivially satisfies this.
- */
-function _AllTransformsMatch(textures) {
-    if (textures.length <= 1) {
-        return true;
-    }
-    const ref = textures[0].getTextureMatrix();
-    for (let i = 1; i < textures.length; i++) {
-        if (!ref.equals(textures[i].getTextureMatrix())) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * @internal
- * Copy sampling metadata from a source texture onto the output ProceduralTexture.
- * `coordinatesIndex` and wrap modes are always copied.
- * When `includeTransform` is true the UV offset/scale/rotation are also copied
- * (used when all inputs share the same transform and it is propagated rather than baked).
- */
-function _CopyTextureMetadata(from, to, includeTransform) {
-    to.coordinatesIndex = from.coordinatesIndex;
-    to.wrapU = from.wrapU;
-    to.wrapV = from.wrapV;
-    if (includeTransform) {
-        const src = from;
-        to.uOffset = src.uOffset ?? 0;
-        to.vOffset = src.vOffset ?? 0;
-        to.uScale = src.uScale ?? 1;
-        to.vScale = src.vScale ?? 1;
-        to.wAng = src.wAng ?? 0;
-    }
+function _KeepMatchingOperandCoordinates(name, operands) {
+    return _KeepMatchingCoordinates(`Texture processor '${name}'`, operands, (operand) => operand.texture, (operand) => ({ ...operand, texture: null }));
 }
 /**
  * @internal
@@ -458,6 +452,7 @@ export async function MultiplyTexturesAsync(name, a, b, scene, outputColorSpace,
         const factor = _MultiplyConstants(_EvalConstant(a), _EvalConstant(b));
         return { texture: null, factor: outputChannelMask ? _ApplyOutputChannelMask(factor, outputChannelMask) : factor };
     }
+    [a, b] = _KeepMatchingOperandCoordinates(name, [a, b]);
     const allTextures = [];
     if (a.texture) {
         allTextures.push(a.texture);
@@ -524,6 +519,7 @@ export async function MaxTexturesAsync(name, a, b, scene, outputColorSpace, outp
         const factor = _MaxConstants(_EvalConstant(a), _EvalConstant(b));
         return { texture: null, factor: outputChannelMask ? _ApplyOutputChannelMask(factor, outputChannelMask) : factor };
     }
+    [a, b] = _KeepMatchingOperandCoordinates(name, [a, b]);
     const allTextures = [];
     if (a.texture) {
         allTextures.push(a.texture);
@@ -562,6 +558,218 @@ export async function MaxTexturesAsync(name, a, b, scene, outputColorSpace, outp
     }
     return result;
 }
+/**
+ * Component-wise safe division of two texture operands: `result = a / max(b, 0.00001)`.
+ *
+ * Each operand can be a texture, a constant factor, or a texture scaled by a factor.
+ * Division by zero is guarded with a small epsilon so the result is always finite.
+ *
+ * If both operands are constant (no textures), the operation is performed on the CPU and
+ * the result is returned as a factor-only operand with no texture allocated.
+ *
+ * When operands are results of previous operations (i.e. they carry a `dispose` function),
+ * their intermediate textures are automatically released after the GPU pass completes.
+ *
+ * @param name - Name for the resulting procedural texture (used only when a GPU pass is needed)
+ * @param a - Numerator operand
+ * @param b - Denominator operand
+ * @param scene - Scene to create the texture in (used only when a GPU pass is needed)
+ * @param outputColorSpace - Optional output color space.
+ * @param outputChannelMask - Optional bitmask of channels to write.
+ * @param outputOptions - Optional render-target type, sampling, and mipmap settings.
+ * @returns An operand whose `texture` holds the GPU result, or whose `factor` holds the CPU-folded constant
+ */
+export async function DivideTexturesAsync(name, a, b, scene, outputColorSpace, outputChannelMask, outputOptions) {
+    if (!a.texture && !b.texture) {
+        const factor = _DivideConstants(_EvalConstant(a), _EvalConstant(b));
+        return { texture: null, factor: outputChannelMask ? _ApplyOutputChannelMask(factor, outputChannelMask) : factor };
+    }
+    [a, b] = _KeepMatchingOperandCoordinates(name, [a, b]);
+    const allTextures = [];
+    if (a.texture) {
+        allTextures.push(a.texture);
+    }
+    if (b.texture) {
+        allTextures.push(b.texture);
+    }
+    const canPropagate = _AllTransformsMatch(allTextures);
+    const bakeTransform = !canPropagate;
+    const defines = [
+        "OP_DIVIDE",
+        ..._BuildOperandDefines(a, "A", bakeTransform),
+        ..._BuildOperandDefines(b, "B", bakeTransform),
+        ...(outputChannelMask ? _BuildOutputChannelMaskDefines(outputChannelMask) : []),
+    ];
+    if (outputColorSpace) {
+        defines.push("OUTPUT_SRGB");
+    }
+    const pt = _CreateProcessorTexture(name, defines, _ResolveOutputSize([a, b]), scene, outputColorSpace, outputOptions);
+    _SetOperandUniforms(pt, a, "textureA", "factorA", bakeTransform);
+    _SetOperandUniforms(pt, b, "textureB", "factorB", bakeTransform);
+    try {
+        await _RenderAsync(pt);
+    }
+    catch (error) {
+        a.dispose?.();
+        b.dispose?.();
+        throw error;
+    }
+    a.dispose?.();
+    b.dispose?.();
+    _CopyTextureMetadata(allTextures[0], pt, canPropagate);
+    const result = { texture: pt, dispose: () => pt.dispose() };
+    if (outputColorSpace) {
+        result.colorSpace = outputColorSpace;
+    }
+    return result;
+}
+/**
+ * Compute the component-wise fraction `result = a / (a + b * (1 - a))` in a single GPU pass.
+ *
+ * For OpenPBR this is the transmission fraction of the dielectric's transmitted light, where `a` is
+ * the transmission weight T and `b` the subsurface weight S (subsurface covers only the remaining
+ * `1 - T`). The subsurface fraction is `1 - result`. The denominator `T + S(1 - T)` equals
+ * `1 - (1 - T)(1 - S)` but avoids subtracting values near one, and fusing the whole expression into
+ * one pass means no intermediate is quantized; only the final output is. The denominator is guarded
+ * with `max(..., 0.00001)`, so the result is 0 where both inputs are 0.
+ *
+ * If both operands are constant (no textures), the operation is performed on the CPU and
+ * the result is returned as a factor-only operand with no texture allocated.
+ *
+ * When operands are results of previous operations (i.e. they carry a `dispose` function),
+ * their intermediate textures are automatically released after the GPU pass completes.
+ *
+ * @param name - Name for the resulting procedural texture (used only when a GPU pass is needed)
+ * @param a - Transmission weight operand (T)
+ * @param b - Subsurface weight operand (S)
+ * @param scene - Scene to create the texture in (used only when a GPU pass is needed)
+ * @param outputColorSpace - Optional output color space.
+ * @param outputChannelMask - Optional bitmask of channels to write.
+ * @param outputOptions - Optional render-target type, sampling, and mipmap settings.
+ * @returns An operand whose `texture` holds the GPU result, or whose `factor` holds the CPU-folded constant
+ */
+export async function TransmissionFractionAsync(name, a, b, scene, outputColorSpace, outputChannelMask, outputOptions) {
+    if (!a.texture && !b.texture) {
+        const ca = _EvalConstant(a);
+        const cb = _EvalConstant(b);
+        const fraction = (x, y) => x / Math.max(x + y * (1 - x), 0.00001);
+        const factor = new Color4(fraction(ca.r, cb.r), fraction(ca.g, cb.g), fraction(ca.b, cb.b), fraction(ca.a, cb.a));
+        return { texture: null, factor: outputChannelMask ? _ApplyOutputChannelMask(factor, outputChannelMask) : factor };
+    }
+    [a, b] = _KeepMatchingOperandCoordinates(name, [a, b]);
+    const allTextures = [];
+    if (a.texture) {
+        allTextures.push(a.texture);
+    }
+    if (b.texture) {
+        allTextures.push(b.texture);
+    }
+    const canPropagate = _AllTransformsMatch(allTextures);
+    const bakeTransform = !canPropagate;
+    const defines = [
+        "OP_TRANSMISSION_FRACTION",
+        ..._BuildOperandDefines(a, "A", bakeTransform),
+        ..._BuildOperandDefines(b, "B", bakeTransform),
+        ...(outputChannelMask ? _BuildOutputChannelMaskDefines(outputChannelMask) : []),
+    ];
+    if (outputColorSpace) {
+        defines.push("OUTPUT_SRGB");
+    }
+    const pt = _CreateProcessorTexture(name, defines, _ResolveOutputSize([a, b]), scene, outputColorSpace, outputOptions);
+    _SetOperandUniforms(pt, a, "textureA", "factorA", bakeTransform);
+    _SetOperandUniforms(pt, b, "textureB", "factorB", bakeTransform);
+    try {
+        await _RenderAsync(pt);
+    }
+    catch (error) {
+        a.dispose?.();
+        b.dispose?.();
+        throw error;
+    }
+    a.dispose?.();
+    b.dispose?.();
+    _CopyTextureMetadata(allTextures[0], pt, canPropagate);
+    const result = { texture: pt, dispose: () => pt.dispose() };
+    if (outputColorSpace) {
+        result.colorSpace = outputColorSpace;
+    }
+    return result;
+}
+/** @internal */
+function _TransmissionScatterAlbedoConstant(transmissionColor, transmissionScatter) {
+    const extinction = [transmissionColor.r, transmissionColor.g, transmissionColor.b].map((value) => -Math.log(Math.max(value, 0.0000001)));
+    const scatter = [transmissionScatter.r, transmissionScatter.g, transmissionScatter.b];
+    const shift = Math.min(0, ...extinction.map((value, i) => value - scatter[i]));
+    const albedo = scatter.map((value, i) => value / Math.max(extinction[i] - shift, 0.00001));
+    return new Color4(albedo[0], albedo[1], albedo[2], transmissionScatter.a);
+}
+/**
+ * Recover the single-scatter albedo of an OpenPBR 1.1 transmission volume, `scatter / extinction`, using the
+ * renderer's extinction: the absorption `-log(transmissionColor) - transmissionScatter` is shifted so its
+ * smallest channel is non-negative, and the extinction is recomputed from it. The transmission depth cancels
+ * out of the ratio, so both operands are given per unit depth. The result alpha is taken from the scatter operand.
+ *
+ * If both operands are constant (no textures), the operation is performed on the CPU and
+ * the result is returned as a factor-only operand with no texture allocated.
+ *
+ * When operands are results of previous operations (i.e. they carry a `dispose` function),
+ * their intermediate textures are automatically released after the GPU pass completes.
+ *
+ * @param name - Name for the resulting procedural texture (used only when a GPU pass is needed)
+ * @param transmissionColor - Linear transmission color operand
+ * @param transmissionScatter - Transmission scatter operand
+ * @param scene - Scene to create the texture in (used only when a GPU pass is needed)
+ * @param outputColorSpace - Optional output color space.
+ * @param outputChannelMask - Optional bitmask of channels to write.
+ * @param outputOptions - Optional render-target type, sampling, and mipmap settings.
+ * @returns An operand whose `texture` holds the GPU result, or whose `factor` holds the CPU-folded constant
+ */
+export async function TransmissionScatterToSingleScatterAlbedoAsync(name, transmissionColor, transmissionScatter, scene, outputColorSpace, outputChannelMask, outputOptions) {
+    let a = transmissionColor;
+    let b = transmissionScatter;
+    if (!a.texture && !b.texture) {
+        const factor = _TransmissionScatterAlbedoConstant(_EvalConstant(a), _EvalConstant(b));
+        return { texture: null, factor: outputChannelMask ? _ApplyOutputChannelMask(factor, outputChannelMask) : factor };
+    }
+    [a, b] = _KeepMatchingOperandCoordinates(name, [a, b]);
+    const allTextures = [];
+    if (a.texture) {
+        allTextures.push(a.texture);
+    }
+    if (b.texture) {
+        allTextures.push(b.texture);
+    }
+    const canPropagate = _AllTransformsMatch(allTextures);
+    const bakeTransform = !canPropagate;
+    const defines = [
+        "OP_TRANSMISSION_SCATTER_ALBEDO",
+        ..._BuildOperandDefines(a, "A", bakeTransform),
+        ..._BuildOperandDefines(b, "B", bakeTransform),
+        ...(outputChannelMask ? _BuildOutputChannelMaskDefines(outputChannelMask) : []),
+    ];
+    if (outputColorSpace) {
+        defines.push("OUTPUT_SRGB");
+    }
+    const pt = _CreateProcessorTexture(name, defines, _ResolveOutputSize([a, b]), scene, outputColorSpace, outputOptions);
+    _SetOperandUniforms(pt, a, "textureA", "factorA", bakeTransform);
+    _SetOperandUniforms(pt, b, "textureB", "factorB", bakeTransform);
+    try {
+        await _RenderAsync(pt);
+    }
+    catch (error) {
+        a.dispose?.();
+        b.dispose?.();
+        throw error;
+    }
+    a.dispose?.();
+    b.dispose?.();
+    _CopyTextureMetadata(allTextures[0], pt, canPropagate);
+    const result = { texture: pt, dispose: () => pt.dispose() };
+    if (outputColorSpace) {
+        result.colorSpace = outputColorSpace;
+    }
+    return result;
+}
 /**
  * Linearly interpolate between two texture operands: `result = mix(a, b, t)`.
  *
@@ -588,11 +796,12 @@ export async function MaxTexturesAsync(name, a, b, scene, outputColorSpace, outp
  * @param outputOptions - Optional render-target type, sampling, and mipmap settings.
  * @returns An operand whose `texture` holds the GPU result, or whose `factor` holds the CPU-folded constant
  */
-export async function LerpTexturesAsync(name, a, b, t, scene, outputColorSpace, outputChannelMask, outputOptions) {
+export async function LerpTexturesAsync(name, a, b, t, scene, outputColorSpace = TextureColorSpace.Linear, outputChannelMask, outputOptions) {
     if (!a.texture && !b.texture && !t.texture) {
         const factor = _LerpConstants(_EvalConstant(a), _EvalConstant(b), _EvalConstant(t));
         return { texture: null, factor: outputChannelMask ? _ApplyOutputChannelMask(factor, outputChannelMask) : factor };
     }
+    [a, b, t] = _KeepMatchingOperandCoordinates(name, [a, b, t]);
     const allTextures = [];
     if (a.texture) {
         allTextures.push(a.texture);
@@ -612,7 +821,7 @@ export async function LerpTexturesAsync(name, a, b, t, scene, outputColorSpace,
         ..._BuildLerpBlendDefines(t, bakeTransform),
         ...(outputChannelMask ? _BuildOutputChannelMaskDefines(outputChannelMask) : []),
     ];
-    if (outputColorSpace) {
+    if (outputColorSpace == TextureColorSpace.SRGB) {
         defines.push("OUTPUT_SRGB");
     }
     const pt = _CreateProcessorTexture(name, defines, _ResolveOutputSize([a, b, t]), scene, outputColorSpace, outputOptions);
@@ -795,4 +1004,195 @@ export async function ExtractChannelAsync(name, input, channel, scene, outputCol
     }
     return await MultiplyTexturesAsync(name, { ...input, channel }, CreateFactorOperand(new Color4(1, 1, 1, 1)), scene, outputColorSpace, outputChannelMask, outputOptions);
 }
+/**
+ * Convert a multi-scatter albedo operand to single-scatter albedo using the OpenPBR/KHR
+ * approximation. RGB is clamped to `[0, 1]` before conversion and alpha is preserved.
+ *
+ * If the operand is constant, the conversion is performed on the CPU. Otherwise it is baked
+ * into a linear procedural texture. Input color-space conversion, channel selection, factors,
+ * UV transforms, metadata propagation, and intermediate disposal follow the other unary texture
+ * processor operations.
+ *
+ * @param name - Name for the resulting procedural texture (used only when a GPU pass is needed)
+ * @param input - Multi-scatter albedo operand to convert
+ * @param scene - Scene to create the texture in (used only when a GPU pass is needed)
+ * @param aniso - Scattering anisotropy in `[-1, 1]`. `0` (default) is isotropic; positive values are
+ *   forward-scattering. Matches `multiScatterToSingleScatterAlbedo(rho_ms, aniso)` in helperFunctions.
+ *   Clamped to `[-0.9999, 0.9999]`, as in the renderer.
+ * @param scale - Optional operand multiplied into `input` (RGBA) before conversion, in the same pass. Use it
+ *   instead of a separate {@link MultiplyTexturesAsync} so that the product (e.g. scatter strength times
+ *   multi-scatter color) isn't quantized before the nonlinear conversion.
+ * @returns An operand containing the converted single-scatter albedo
+ */
+export async function MultiScatterToSingleScatterAlbedoAsync(name, input, scene, aniso = 0, scale) {
+    aniso = _EffectiveScatterAnisotropy(aniso);
+    if (!input.texture && !scale?.texture) {
+        const multiScatter = scale ? _MultiplyConstants(_EvalConstant(input), _EvalConstant(scale)) : _EvalConstant(input);
+        return { texture: null, factor: _MultiScatterToSingleScatterAlbedoConstant(multiScatter, aniso) };
+    }
+    const operands = scale ? _KeepMatchingOperandCoordinates(name, [input, scale]) : [input];
+    const allTextures = operands.map((operand) => operand.texture).filter((texture) => !!texture);
+    const canPropagate = _AllTransformsMatch(allTextures);
+    const bakeTransform = !canPropagate;
+    const defines = [..._BuildOperandDefines(operands[0], "A", bakeTransform), "OP_MULTI_SCATTER_TO_SINGLE_SCATTER"];
+    if (operands[1]) {
+        defines.push(..._BuildOperandDefines(operands[1], "B", bakeTransform), "MULTI_SCATTER_SCALE_B");
+    }
+    const pt = _CreateProcessorTexture(name, defines, _ResolveOutputSize(operands), scene);
+    _SetOperandUniforms(pt, operands[0], "textureA", "factorA", bakeTransform);
+    if (operands[1]) {
+        _SetOperandUniforms(pt, operands[1], "textureB", "factorB", bakeTransform);
+    }
+    pt.setFloat("scatterAniso", aniso);
+    const disposeOperands = () => operands.forEach((operand) => operand.dispose?.());
+    try {
+        await _RenderAsync(pt);
+    }
+    catch (error) {
+        disposeOperands();
+        throw error;
+    }
+    disposeOperands();
+    _CopyTextureMetadata(allTextures[0], pt, canPropagate);
+    return { texture: pt, dispose: () => pt.dispose() };
+}
+/**
+ * Convert a single-scatter albedo operand to multi-scatter albedo using the OpenPBR/KHR
+ * approximation. This is the inverse of {@link MultiScatterToSingleScatterAlbedoAsync}.
+ * RGB is clamped to `[0, 1]` before conversion and alpha is preserved.
+ *
+ * If the operand is constant, the conversion is performed on the CPU. Otherwise it is baked
+ * into a linear procedural texture. Input color-space conversion, channel selection, factors,
+ * UV transforms, metadata propagation, and intermediate disposal follow the other unary texture
+ * processor operations.
+ *
+ * @param name - Name for the resulting procedural texture (used only when a GPU pass is needed)
+ * @param input - Single-scatter albedo operand to convert
+ * @param scene - Scene to create the texture in (used only when a GPU pass is needed)
+ * @param aniso - Scattering anisotropy in `[-1, 1]`. `0` (default) is isotropic; positive values are
+ *   forward-scattering. This inverts the anisotropic multi→single mapping: `s^2 = (1 - rho_ss) /
+ *   (1 - aniso * rho_ss)`, then `rho_ms = (1 - s)(1 - 0.139 s)/(1 + 1.17 s)`. Clamped to
+ *   `[-0.9999, 0.9999]`, as in the renderer.
+ * @param outputOptions - Optional render-target type, sampling, and mipmap settings.
+ * @returns An operand containing the converted multi-scatter albedo
+ */
+export async function SingleScatterToMultiScatterAlbedoAsync(name, input, scene, aniso = 0, outputOptions) {
+    aniso = _EffectiveScatterAnisotropy(aniso);
+    if (!input.texture) {
+        return { texture: null, factor: _SingleScatterToMultiScatterAlbedoConstant(_EvalConstant(input), aniso) };
+    }
+    const defines = [..._BuildOperandDefines(input, "A", false), "OP_SINGLE_SCATTER_TO_MULTI_SCATTER"];
+    const pt = _CreateProcessorTexture(name, defines, _ResolveOutputSize([input]), scene, undefined, outputOptions);
+    _SetOperandUniforms(pt, input, "textureA", "factorA", false);
+    pt.setFloat("scatterAniso", aniso);
+    try {
+        await _RenderAsync(pt);
+    }
+    catch (error) {
+        input.dispose?.();
+        throw error;
+    }
+    input.dispose?.();
+    _CopyTextureMetadata(input.texture, pt, true);
+    return { texture: pt, dispose: () => pt.dispose() };
+}
+/**
+ * Compute the OpenPBR thin-walled scatter weights from a transmission operand (T) and a
+ * scatter-strength operand (S).  Both operands are read from their R channel (after the operand's
+ * channel swizzle and factor), and each weight is broadcast to all four output channels.
+ *
+ * For each texel:
+ * ```
+ *   transmission_weight = T * (1 - S)
+ *   subsurface_weight   = T * S / (1 - T*(1-S))
+ * ```
+ *
+ * These are the OpenPBR weight values when a thin-walled glTF material combines
+ * KHR_materials_transmission (T = transmissionFactor * transmissionTexture) and
+ * KHR_materials_scatter (S = scatterStrengthFactor * scatterStrengthTexture):
+ * `scatterStrengthFactor` converts a fraction of the coherent transmission budget into
+ * scattered (subsurface) transmission while keeping the total translucency constant.
+ *
+ * When both operands are constants the computation is performed entirely on the CPU.
+ * When either operand has a texture, each weight is computed from T and S in a single GPU pass, so
+ * only the two outputs are quantized. Near T = 1 the subsurface weight divides two small values, and
+ * quantizing intermediates (e.g. T * S or 1 - S to 8 bits) would change it drastically.
+ *
+ * @param name - Base name for any procedural textures created
+ * @param transmission - T operand (transmissionFactor × optional transmissionTexture, R channel)
+ * @param scatter - S operand (scatterStrengthFactor × optional scatterStrengthTexture, R channel)
+ * @param scene - Scene used for GPU passes when textures are involved
+ * @returns `{ transmission, subsurface }` – two operands ready to assign to
+ *   `transmissionWeightTexture` / `subsurfaceWeightTexture` (and the corresponding scalar factors)
+ */
+export async function ThinWalledScatterWeightsAsync(name, transmission, scatter, scene) {
+    [transmission, scatter] = _KeepMatchingOperandCoordinates(name, [transmission, scatter]);
+    // Constant-only fast path — compute entirely on the CPU.
+    if (!transmission.texture && !scatter.texture) {
+        const transmissionFactor = _EvalConstant(transmission).r;
+        const scatterStrength = _EvalConstant(scatter).r;
+        const transW = transmissionFactor * (1.0 - scatterStrength);
+        const transmittedScatter = transmissionFactor * scatterStrength;
+        // 1 - T(1 - S), written to avoid cancellation near T = 1.
+        const denom = 1.0 - transmissionFactor + transmittedScatter;
+        const ssW = denom > 0.00001 ? transmittedScatter / denom : 0.0;
+        transmission.dispose?.();
+        scatter.dispose?.();
+        return {
+            transmission: { texture: null, factor: new Color4(transW, transW, transW, transW) },
+            subsurface: { texture: null, factor: new Color4(ssW, ssW, ssW, ssW) },
+        };
+    }
+    // GPU path. Each weight is computed from T and S in one pass, so there are no intermediate textures to
+    // quantize. T and S are consumed by both passes and released only after both have run.
+    try {
+        const transW = await _RenderThinWalledWeightAsync(`${name}_transWeight`, "OP_THIN_WALLED_TRANSMISSION_WEIGHT", transmission, scatter, scene);
+        try {
+            const ssW = await _RenderThinWalledWeightAsync(`${name}_subWeight`, "OP_THIN_WALLED_SUBSURFACE_WEIGHT", transmission, scatter, scene);
+            return { transmission: transW, subsurface: ssW };
+        }
+        catch (error) {
+            transW.dispose?.();
+            throw error;
+        }
+    }
+    finally {
+        transmission.dispose?.();
+        scatter.dispose?.();
+    }
+}
+/**
+ * Renders one thin-walled scatter weight from the transmission and scatter strength operands. The operands
+ * are not disposed, since both weights are computed from them.
+ * @param name - Name for the resulting procedural texture
+ * @param op - Shader operation define
+ * @param transmission - T operand
+ * @param scatter - S operand
+ * @param scene - Scene to create the texture in
+ * @returns An operand whose `texture` holds the weight
+ */
+async function _RenderThinWalledWeightAsync(name, op, transmission, scatter, scene) {
+    const allTextures = [];
+    if (transmission.texture) {
+        allTextures.push(transmission.texture);
+    }
+    if (scatter.texture) {
+        allTextures.push(scatter.texture);
+    }
+    const canPropagate = _AllTransformsMatch(allTextures);
+    const bakeTransform = !canPropagate;
+    const defines = [op, ..._BuildOperandDefines(transmission, "A", bakeTransform), ..._BuildOperandDefines(scatter, "B", bakeTransform)];
+    const pt = _CreateProcessorTexture(name, defines, _ResolveOutputSize([transmission, scatter]), scene);
+    _SetOperandUniforms(pt, transmission, "textureA", "factorA", bakeTransform);
+    _SetOperandUniforms(pt, scatter, "textureB", "factorB", bakeTransform);
+    try {
+        await _RenderAsync(pt);
+    }
+    catch (error) {
+        pt.dispose();
+        throw error;
+    }
+    _CopyTextureMetadata(allTextures[0], pt, canPropagate);
+    return { texture: pt, dispose: () => pt.dispose() };
+}
 //# sourceMappingURL=textureProcessor.js.map