@driftengine/core 4.8.2 → 4.8.4

package/dist/render/shaders/sdfText.d.ts

@@ -6,4 +6,4 @@
  * the alpha test is not uniform control flow.
  */
 export declare const SDF_TEXT_VERT = "#version 300 es\nprecision highp float;\n\nlayout(location = 0) in vec3 aPosition;\nlayout(location = 1) in vec2 aUv;\n\nuniform mat4 uViewProj;\nuniform mat4 uModel;\n\nout vec2 vUv;\n\nvoid main() {\n  vUv = aUv;\n  gl_Position = uViewProj * uModel * vec4(aPosition, 1.0);\n}\n";
-export declare const SDF_TEXT_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\n\n/* An array of one: every surface texture is an array, and an atlas is read at layer 0. */\nuniform mediump sampler2DArray uAtlas;\nuniform vec3 uColor;\nuniform float uOpacity;\n/* Texels the field spans, from the atlas metrics. Scales the antialiasing band. */\nuniform float uDistanceRange;\nuniform vec2 uAtlasSize;\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  return linearToSrgb(c);\n}\n\n\n/*\n * The middle of the three channels.\n *\n * A single-channel field rounds every corner off at small sizes, because one distance\n * cannot describe two edges meeting. Three channels carry the corner and the median\n * recovers it.\n */\nfloat median(vec3 rgb) {\n  return max(min(rgb.r, rgb.g), min(max(rgb.r, rgb.g), rgb.b));\n}\n\nvoid main() {\n  vec3 sampled = textureLod(uAtlas, vec3(vUv, 0.0), 0.0).rgb;\n  float distance = median(sampled) - 0.5;\n\n  /*\n   * The band is one pixel wide *in screen space*, which is what lets one atlas serve every\n   * size. A constant band is tuned for one size and is wrong at all the others.\n   */\n  vec2 texelsPerPixel = fwidth(vUv) * uAtlasSize;\n  float pixelRange = max(0.5 * (texelsPerPixel.x + texelsPerPixel.y), 0.0001);\n  float coverage = clamp(distance * uDistanceRange / pixelRange + 0.5, 0.0, 1.0);\n\n  outColor = vec4(applyOutputTransform(uColor), coverage * uOpacity);\n}\n";
+export declare const SDF_TEXT_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\n\n/* An array of one: every surface texture is an array, and an atlas is read at layer 0. */\nuniform mediump sampler2DArray uAtlas;\nuniform vec3 uColor;\nuniform float uOpacity;\n/* Texels the field spans, from the atlas metrics. Scales the antialiasing band. */\nuniform float uDistanceRange;\nuniform vec2 uAtlasSize;\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB, 3 the highlight shoulder then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\n\nvec3 highlightShoulder(vec3 c) {\n  float m = max(c.r, max(c.g, c.b));\n  if (m <= 0.8) return c;\n  float e = m - 0.8;\n  return c * ((0.8 + 0.2 * e / (e + 0.2)) / m);\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);\n  return linearToSrgb(c);\n}\n\n\n/*\n * The middle of the three channels.\n *\n * A single-channel field rounds every corner off at small sizes, because one distance\n * cannot describe two edges meeting. Three channels carry the corner and the median\n * recovers it.\n */\nfloat median(vec3 rgb) {\n  return max(min(rgb.r, rgb.g), min(max(rgb.r, rgb.g), rgb.b));\n}\n\nvoid main() {\n  vec3 sampled = textureLod(uAtlas, vec3(vUv, 0.0), 0.0).rgb;\n  float distance = median(sampled) - 0.5;\n\n  /*\n   * The band is one pixel wide *in screen space*, which is what lets one atlas serve every\n   * size. A constant band is tuned for one size and is wrong at all the others.\n   */\n  vec2 texelsPerPixel = fwidth(vUv) * uAtlasSize;\n  float pixelRange = max(0.5 * (texelsPerPixel.x + texelsPerPixel.y), 0.0001);\n  float coverage = clamp(distance * uDistanceRange / pixelRange + 0.5, 0.0, 1.0);\n\n  outColor = vec4(applyOutputTransform(uColor), coverage * uOpacity);\n}\n";

package/dist/render/shaders/skinBlur.d.ts

@@ -0,0 +1 @@
+export declare const SKIN_BLUR_FRAG: string;

package/dist/render/shaders/skinBlur.js

@@ -0,0 +1,103 @@
+/**
+ * Skin's screen-space scattering: one axis of the blur that spreads the diffuse pass by Burley's
+ * profile, and on the second axis the sum the frame takes back. `skinBlur.ts` beside the render
+ * directory is the kernel's reference and says what it gives up.
+ *
+ * **One pass, run twice**: along x into a target of its own, keeping the profile in the alpha, then
+ * along y blended additively into the frame — its colour added, the frame's alpha kept.
+ *
+ * **Refuses what is not the same skin**: a neighbour that wrote no skin, or one further in depth
+ * than four of the profile's widest distances, takes no weight, and what is kept is divided by
+ * what was kept, so a cheek's light does not pull toward the black beside its silhouette. A tap
+ * part skin is counted for the part it is: the target is read as coverage-weighted, which is what
+ * a filtered tap across an edge already is.
+ */
+import { glslIsFarDepth, glslSceneDepthToNdc } from '../depthConvention.js';
+import { SKIN_BLUR_EDGES, SKIN_BLUR_TAPS, SKIN_PROFILES } from '../skinBlur.js';
+const list = (values) => values.map((v) => v.toFixed(2)).join(', ');
+export const SKIN_BLUR_FRAG = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+
+/** The diffuse pass, or the first axis' result: diffuse in rgb, the profile as (index + 1) / 8. */
+uniform sampler2D uSkin;
+/** highp, for the reason the ambient occlusion blur gives: eight bits of depth find false edges. */
+uniform highp sampler2D uDepth;
+/** One texel along the axis being blurred, in UV. The other component is zero. */
+uniform vec2 uStep;
+/** A depth sample to view-space metres, as the ambient occlusion blur takes it. */
+uniform vec4 uDepthToViewZ;
+/** How many pixels a metre spans at a metre's distance. */
+uniform float uFocal;
+/** Each profile's scatter distance per channel, in metres. */
+uniform vec4 uProfiles[${SKIN_PROFILES}];
+
+out vec4 fragColor;
+
+const float TAPS[${SKIN_BLUR_TAPS.length}] = float[${SKIN_BLUR_TAPS.length}](${list(SKIN_BLUR_TAPS)});
+const float EDGES[${SKIN_BLUR_EDGES.length}] = float[${SKIN_BLUR_EDGES.length}](${list(SKIN_BLUR_EDGES)});
+
+float viewZ(float depth) {
+  float ndc = ${glslSceneDepthToNdc('depth')};
+  return (uDepthToViewZ.x * ndc + uDepthToViewZ.y) / (uDepthToViewZ.z * ndc + uDepthToViewZ.w);
+}
+
+/** Burley's profile across a line, integrated from 0 to x: one half at infinity. */
+vec3 burleyMass(float x, vec3 d) {
+  return 0.5 - (exp(-x / d) + 3.0 * exp(-x / (3.0 * d))) * 0.125;
+}
+
+void main() {
+  vec4 own = textureLod(uSkin, vUv, 0.0);
+  /*
+   * Not skin: nothing here to spread, and nothing to add. Any alpha is skin, because a pixel a
+   * silhouette crosses under multisampling resolves to its covered share of the profile's code, and
+   * its colour to that share of the diffuse, which is exactly what it owes the frame.
+   */
+  if (own.a < 1e-4) {
+    fragColor = vec4(0.0);
+    return;
+  }
+  float depth = textureLod(uDepth, vUv, 0.0).r;
+  if (${glslIsFarDepth('depth')}) {
+    fragColor = own;
+    return;
+  }
+  /* A part-covered pixel's code is its share of the whole: read it as the nearest, which is the
+     right profile at half coverage and up, and a neighbouring one only on a silhouette below it. */
+  int profile = clamp(int(own.a * 8.0 + 0.5) - 1, 0, ${SKIN_PROFILES - 1});
+  vec3 d = max(uProfiles[profile].xyz, vec3(1e-6));
+  float widest = max(d.r, max(d.g, d.b));
+  float z = abs(viewZ(depth));
+  /* The widest distance in pixels here: under half of one, there is nothing to spread across. */
+  float pixels = widest * uFocal / max(z, 1e-4);
+  if (pixels < 0.5) {
+    fragColor = own;
+    return;
+  }
+  vec3 centre = 2.0 * burleyMass(EDGES[0] * widest, d);
+  vec3 sum = own.rgb * centre;
+  vec3 weight = centre;
+  for (int i = 1; i < ${SKIN_BLUR_TAPS.length}; i++) {
+    vec3 outer = i < ${SKIN_BLUR_EDGES.length} ? burleyMass(EDGES[min(i, ${SKIN_BLUR_EDGES.length - 1})] * widest, d) : vec3(0.5);
+    vec3 w = outer - burleyMass(EDGES[i - 1] * widest, d);
+    for (int side = -1; side <= 1; side += 2) {
+      vec2 uv = vUv + uStep * (float(side) * TAPS[i] * pixels);
+      vec4 tap = textureLod(uSkin, uv, 0.0);
+      float tapZ = abs(viewZ(textureLod(uDepth, uv, 0.0).r));
+      float keep = clamp(1.0 - abs(tapZ - z) / (4.0 * widest), 0.0, 1.0);
+      /*
+       * How much of the tap is skin: a filtered tap astride a silhouette is part skin and part
+       * the black beside it, in colour and in alpha alike, so its alpha over this pixel's says the
+       * share, and the colour is already that share of the skin's — counted as such, it neither
+       * darkens the edge nor drops out.
+       */
+      float cover = clamp(tap.a / own.a, 0.0, 1.0);
+      sum += tap.rgb * w * keep;
+      weight += w * (cover * keep);
+    }
+  }
+  fragColor = vec4(sum / weight, own.a);
+}
+`;

package/dist/render/shaders/skinning.d.ts

@@ -14,4 +14,6 @@
  * What would make it wrong is a second vertex flag: four variants dedupe less well than two, so
  * re-measure before adding one.
  */
-export declare const SKINNING_GLSL = "\n/**\n * The joint palette, four texels a matrix, one row.\n *\n * A texture rather than a `uniform mat4[]`. The 2026-08-07 rule that keeps samples out of\n * unprovable branches is about *implicit derivatives*, which a vertex stage does not compute, so\n * it has nothing to say here \u2014 and `texelFetch` takes an integer coordinate with no level\n * inferred at all. What a uniform array would have cost is the cap: MAX_VERTEX_UNIFORM_VECTORS is\n * 256 on the WebGL2 floor and this shader already spends fifteen, which leaves sixty joints.\n *\n * What this costs is a texture upload per skinned draw. What would make it wrong is a profile\n * showing that upload is the limit; the fix is one texture for every character with a row offset.\n */\nuniform highp sampler2D uJointPalette;\n\nlayout(location = 11) in vec4 aJoints;\nlayout(location = 12) in vec4 aWeights;\n\n/** One joint's matrix, read as four consecutive texels of row 0. */\nmat4 jointMatrix(int index) {\n  int x = index * 4;\n  return mat4(\n    texelFetch(uJointPalette, ivec2(x, 0), 0),\n    texelFetch(uJointPalette, ivec2(x + 1, 0), 0),\n    texelFetch(uJointPalette, ivec2(x + 2, 0), 0),\n    texelFetch(uJointPalette, ivec2(x + 3, 0), 0));\n}\n\n/**\n * The four influences, weighted.\n *\n * Weights are normalised by the importer rather than here: normalising per vertex per frame costs\n * a divide on every vertex to correct data an importer should have fixed once, and `gltfSkin.ts`\n * warns when a set does not sum to one. What would make it wrong is a caller building a MeshData\n * by hand with unnormalised weights, which shades slightly dark or bright rather than breaking.\n */\nmat4 skinMatrix() {\n  return jointMatrix(int(aJoints.x)) * aWeights.x\n       + jointMatrix(int(aJoints.y)) * aWeights.y\n       + jointMatrix(int(aJoints.z)) * aWeights.z\n       + jointMatrix(int(aJoints.w)) * aWeights.w;\n}\n";
+export declare const SKINNING_GLSL = "\n/**\n * The joint palette, four texels a matrix, one row.\n *\n * A texture rather than a `uniform mat4[]`. The 2026-08-07 rule that keeps samples out of\n * unprovable branches is about *implicit derivatives*, which a vertex stage does not compute, so\n * it has nothing to say here \u2014 and `texelFetch` takes an integer coordinate with no level\n * inferred at all. What a uniform array would have cost is the cap: MAX_VERTEX_UNIFORM_VECTORS is\n * 256 on the WebGL2 floor and this shader already spends fifteen, which leaves sixty joints.\n *\n * What this costs is a texture upload per skinned draw. What would make it wrong is a profile\n * showing that upload is the limit; the fix is one texture for every character with a row offset.\n */\nuniform highp sampler2D uJointPalette;\n\nlayout(location = 11) in vec4 aJoints;\nlayout(location = 12) in vec4 aWeights;\n/*\n * **The fifth to eighth influences, read only by a pipeline built for a mesh that has them.**\n *\n * Declared in every skinned variant at the last two locations WebGL2 guarantees \u2014 13 is the channel,\n * and an instanced draw, which takes 11 to 15, cannot skin \u2014 and fed zeros by the absent-attribute\n * constants for a mesh with four. `SKIN_EIGHT` is a pipeline constant rather than a permutation,\n * so the generated vertex stages do not double: off, the device compiles the second sum away and a\n * four-influence mesh pays nothing; on, it is four more palette reads a vertex.\n */\nconst bool SKIN_EIGHT = false;  // wgsl:override\nlayout(location = 14) in vec4 aJoints2;\nlayout(location = 15) in vec4 aWeights2;\n\n/** One joint's matrix, read as four consecutive texels of row 0. */\nmat4 jointMatrix(int index) {\n  int x = index * 4;\n  return mat4(\n    texelFetch(uJointPalette, ivec2(x, 0), 0),\n    texelFetch(uJointPalette, ivec2(x + 1, 0), 0),\n    texelFetch(uJointPalette, ivec2(x + 2, 0), 0),\n    texelFetch(uJointPalette, ivec2(x + 3, 0), 0));\n}\n\n/**\n * The four influences, weighted.\n *\n * Weights are normalised by the importer rather than here: normalising per vertex per frame costs\n * a divide on every vertex to correct data an importer should have fixed once, and `gltfSkin.ts`\n * warns when a set does not sum to one. What would make it wrong is a caller building a MeshData\n * by hand with unnormalised weights, which shades slightly dark or bright rather than breaking.\n */\nmat4 skinMatrix() {\n  mat4 m = jointMatrix(int(aJoints.x)) * aWeights.x\n         + jointMatrix(int(aJoints.y)) * aWeights.y\n         + jointMatrix(int(aJoints.z)) * aWeights.z\n         + jointMatrix(int(aJoints.w)) * aWeights.w;\n  if (SKIN_EIGHT) {\n    m += jointMatrix(int(aJoints2.x)) * aWeights2.x\n       + jointMatrix(int(aJoints2.y)) * aWeights2.y\n       + jointMatrix(int(aJoints2.z)) * aWeights2.z\n       + jointMatrix(int(aJoints2.w)) * aWeights2.w;\n  }\n  return m;\n}\n\n";
+/** The source above with the eight-influence switch on, for a WebGL2 program built for such a mesh. */
+export declare function skinEight(source: string): string;

package/dist/render/shaders/skinning.js

@@ -31,6 +31,18 @@ uniform highp sampler2D uJointPalette;
 
 layout(location = 11) in vec4 aJoints;
 layout(location = 12) in vec4 aWeights;
+/*
+ * **The fifth to eighth influences, read only by a pipeline built for a mesh that has them.**
+ *
+ * Declared in every skinned variant at the last two locations WebGL2 guarantees — 13 is the channel,
+ * and an instanced draw, which takes 11 to 15, cannot skin — and fed zeros by the absent-attribute
+ * constants for a mesh with four. \`SKIN_EIGHT\` is a pipeline constant rather than a permutation,
+ * so the generated vertex stages do not double: off, the device compiles the second sum away and a
+ * four-influence mesh pays nothing; on, it is four more palette reads a vertex.
+ */
+const bool SKIN_EIGHT = false;  // wgsl:override
+layout(location = 14) in vec4 aJoints2;
+layout(location = 15) in vec4 aWeights2;
 
 /** One joint's matrix, read as four consecutive texels of row 0. */
 mat4 jointMatrix(int index) {
@@ -51,9 +63,24 @@ mat4 jointMatrix(int index) {
  * by hand with unnormalised weights, which shades slightly dark or bright rather than breaking.
  */
 mat4 skinMatrix() {
-  return jointMatrix(int(aJoints.x)) * aWeights.x
-       + jointMatrix(int(aJoints.y)) * aWeights.y
-       + jointMatrix(int(aJoints.z)) * aWeights.z
-       + jointMatrix(int(aJoints.w)) * aWeights.w;
+  mat4 m = jointMatrix(int(aJoints.x)) * aWeights.x
+         + jointMatrix(int(aJoints.y)) * aWeights.y
+         + jointMatrix(int(aJoints.z)) * aWeights.z
+         + jointMatrix(int(aJoints.w)) * aWeights.w;
+  if (SKIN_EIGHT) {
+    m += jointMatrix(int(aJoints2.x)) * aWeights2.x
+       + jointMatrix(int(aJoints2.y)) * aWeights2.y
+       + jointMatrix(int(aJoints2.z)) * aWeights2.z
+       + jointMatrix(int(aJoints2.w)) * aWeights2.w;
+  }
+  return m;
 }
+
 `;
+/** The source above with the eight-influence switch on, for a WebGL2 program built for such a mesh. */
+export function skinEight(source) {
+    const off = 'const bool SKIN_EIGHT = false;';
+    if (!source.includes(off))
+        throw new Error('skinEight: the source carries no SKIN_EIGHT switch');
+    return source.replace(off, 'const bool SKIN_EIGHT = true;');
+}

package/dist/render/shaders/temporalResolve.js

@@ -202,11 +202,18 @@ vec3 historyCatmullRom(vec2 uv) {
 }
 
 void main() {
-  vec3 current = textureLod(uScene, vUv, 0.0).rgb;
+  /*
+   * **The alpha is this frame's and takes no history.** It is how much of the pixel is still the
+   * opaque surface (sceneCoverage.ts), which the composite's occlusion reads after this has
+   * replaced the scene, so it passes through untouched. The history is read for its colour alone.
+   */
+  vec4 sampled = textureLod(uScene, vUv, 0.0);
+  vec3 current = sampled.rgb;
+  float share = sampled.a;
 
   /* Nothing to blend towards: the first frame, a resize, a cut, or the effect switched off. */
   if (uHistoryBlend <= 0.0) {
-    fragColor = vec4(current, 1.0);
+    fragColor = vec4(current, share);
     flickerOut = freshRecord(current);
     flickerMotionOut = vec4(0.0);
     return;
@@ -239,7 +246,7 @@ void main() {
   vec4 previous = uReprojection * clip;
   /* Behind the previous eye: there is no last-frame position to sample. */
   if (previous.w <= 0.0) {
-    fragColor = vec4(current, 1.0);
+    fragColor = vec4(current, share);
     flickerOut = freshRecord(current);
     flickerMotionOut = vec4(metres, 0.0, 0.0, 0.0);
     return;
@@ -252,7 +259,7 @@ void main() {
    * as a smear for as long as the camera kept turning.
    */
   if (wasUv.x < 0.0 || wasUv.x > 1.0 || wasUv.y < 0.0 || wasUv.y > 1.0) {
-    fragColor = vec4(current, 1.0);
+    fragColor = vec4(current, share);
     flickerOut = freshRecord(current);
     flickerMotionOut = vec4(metres, 0.0, 0.0, 0.0);
     return;
@@ -311,6 +318,6 @@ void main() {
     repeated * still
   );
   flickerMotionOut = vec4(metres, swingOut, 0.0, 0.0);
-  fragColor = vec4(mix(current, bounded, blend), 1.0);
+  fragColor = vec4(mix(current, bounded, blend), share);
 }
 `;

package/dist/render/shadowCasters.d.ts

@@ -2,6 +2,7 @@ import { type GlassOptions, type ResolvedGlass } from './glass.ts';
 import type { ReadonlyMat4 } from 'gl-matrix';
 import type { InstanceData } from './instancedMesh.ts';
 import type { InstancedHandle, MeshHandle, ScatterHandle } from './backend/api.ts';
+import type { ClothBindingHandle, ClothParticlesHandle } from './backend/api.ts';
 import type { MeshInstances } from './instances.ts';
 import type { SurfaceMaterial } from './surfaceTexture.ts';
 import type { SurfaceTextureHandle } from './backend/api.ts';
@@ -60,6 +61,11 @@ export declare function castsDepth(material: SceneCasterMaterial | undefined): b
  * states from the other side, so a caster is exactly one of the two.
  */
 export declare function glassOf(material: SceneCasterMaterial | undefined, out: ResolvedGlass): boolean;
+/** A skinned caster's cloth: the mesh's binding and the character's particles. See `setCloth`. */
+export interface ShadowCasterCloth {
+    readonly binding: ClothBindingHandle;
+    readonly particles: ClothParticlesHandle;
+}
 export interface ShadowCasterSink {
     /** A rigid mesh at a model transform: the world, a prop, a static piece of scenery. */
     mesh(mesh: MeshHandle, model: ReadonlyMat4, material?: SceneCasterMaterial): void;
@@ -73,7 +79,13 @@ export interface ShadowCasterSink {
      *
      * Sixteen floats a joint, column-major, exactly as `Skeleton.palette` produces.
      */
-    skinnedMesh(mesh: MeshHandle, model: ReadonlyMat4, palette: Float32Array, material?: SceneCasterMaterial): void;
+    skinnedMesh(mesh: MeshHandle, model: ReadonlyMat4, palette: Float32Array, material?: SceneCasterMaterial, 
+    /**
+     * The cloth the visible draw places this mesh by, if any — for the reason the palette is not
+     * optional in spirit: a garment cast from its skinning alone throws a shadow that does not
+     * move as the cloth does.
+     */
+    cloth?: ShadowCasterCloth): void;
     /**
      * An instanced batch of rigid meshes, placed by the same matrices the visible draw uses.
      *

package/dist/render/skinBlur.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Skin's screen-space scattering, as `shaders/skinBlur.ts` spreads it: the reference its tests hold
+ * the kernel to, and nothing at run time calls it.
+ *
+ * **What it spreads.** With `skinScattering: 'screen-space'`, a skin draw writes its specular to the
+ * frame and its diffuse — the light that went beneath the surface — to a target of its own, with the
+ * profile it scatters by in the alpha. Before anything blended is drawn, that target is blurred
+ * along the screen's two axes by Burley's normalised diffusion, one width per channel, and added
+ * back: light that entered a cheek leaves it a centimetre away, reddest furthest, across the
+ * pixels that centimetre covers at the cheek's distance. The pre-integrated fit stays in the lit
+ * stage for what this cannot see — a terminator's curvature — and this carries what that cannot:
+ * light crossing a shadow's edge, or a nostril's rim, in the picture rather than in a fit.
+ *
+ * **Separable, which the profile is not**: two 1D passes with Burley's profile integrated across a
+ * line, as Jimenez's separable subsurface scattering does. What it gives up is the radial shape, a
+ * blur a little squarer than the profile; what it buys is thirteen taps an axis rather than a disc.
+ *
+ * **Each tap is the profile's mass over its cell, in closed form**, so a channel's weights sum to
+ * one before any are refused, and a channel that travels a quarter as far as the widest keeps most
+ * of its light at the centre. The taps are placed in units of the widest channel's distance and
+ * closer together near the centre, where the profile's sharp peak is.
+ */
+/** The taps' distances from the centre, one side, in units of the widest channel's distance. */
+export declare const SKIN_BLUR_TAPS: readonly [0, 0.4, 1.1, 2.1, 3.5, 5.6, 9];
+/**
+ * Where each tap's cell ends, in the same units: halfway to the next tap, and the last cell runs
+ * to infinity, so the profile's whole mass is somewhere.
+ */
+export declare const SKIN_BLUR_EDGES: readonly [0.2, 0.75, 1.6, 2.8, 4.55, 7.3];
+/** How many profiles a frame's skin can name: `SkinModel.profile`. */
+export declare const SKIN_PROFILES = 8;
+/**
+ * Burley's profile across a line, `(e^(−x/d) + e^(−x/3d)) / 8d`, integrated from 0 to `x`: half of
+ * it lies on each side, so this reaches ½ at infinity.
+ */
+export declare function burleyMass(x: number, d: number): number;
+/**
+ * Tap `tap`'s weight for one channel scattering `d`, the taps spaced by `widest`: the centre's cell
+ * is both sides of it, every other cell one side, and a tap on each side takes this weight.
+ */
+export declare function skinBlurWeight(tap: number, d: number, widest: number): number;

package/dist/render/skinBlur.js

@@ -0,0 +1,49 @@
+/**
+ * Skin's screen-space scattering, as `shaders/skinBlur.ts` spreads it: the reference its tests hold
+ * the kernel to, and nothing at run time calls it.
+ *
+ * **What it spreads.** With `skinScattering: 'screen-space'`, a skin draw writes its specular to the
+ * frame and its diffuse — the light that went beneath the surface — to a target of its own, with the
+ * profile it scatters by in the alpha. Before anything blended is drawn, that target is blurred
+ * along the screen's two axes by Burley's normalised diffusion, one width per channel, and added
+ * back: light that entered a cheek leaves it a centimetre away, reddest furthest, across the
+ * pixels that centimetre covers at the cheek's distance. The pre-integrated fit stays in the lit
+ * stage for what this cannot see — a terminator's curvature — and this carries what that cannot:
+ * light crossing a shadow's edge, or a nostril's rim, in the picture rather than in a fit.
+ *
+ * **Separable, which the profile is not**: two 1D passes with Burley's profile integrated across a
+ * line, as Jimenez's separable subsurface scattering does. What it gives up is the radial shape, a
+ * blur a little squarer than the profile; what it buys is thirteen taps an axis rather than a disc.
+ *
+ * **Each tap is the profile's mass over its cell, in closed form**, so a channel's weights sum to
+ * one before any are refused, and a channel that travels a quarter as far as the widest keeps most
+ * of its light at the centre. The taps are placed in units of the widest channel's distance and
+ * closer together near the centre, where the profile's sharp peak is.
+ */
+/** The taps' distances from the centre, one side, in units of the widest channel's distance. */
+export const SKIN_BLUR_TAPS = [0, 0.4, 1.1, 2.1, 3.5, 5.6, 9];
+/**
+ * Where each tap's cell ends, in the same units: halfway to the next tap, and the last cell runs
+ * to infinity, so the profile's whole mass is somewhere.
+ */
+export const SKIN_BLUR_EDGES = [0.2, 0.75, 1.6, 2.8, 4.55, 7.3];
+/** How many profiles a frame's skin can name: `SkinModel.profile`. */
+export const SKIN_PROFILES = 8;
+/**
+ * Burley's profile across a line, `(e^(−x/d) + e^(−x/3d)) / 8d`, integrated from 0 to `x`: half of
+ * it lies on each side, so this reaches ½ at infinity.
+ */
+export function burleyMass(x, d) {
+    return 0.5 - (Math.exp(-x / d) + 3 * Math.exp(-x / (3 * d))) / 8;
+}
+/**
+ * Tap `tap`'s weight for one channel scattering `d`, the taps spaced by `widest`: the centre's cell
+ * is both sides of it, every other cell one side, and a tap on each side takes this weight.
+ */
+export function skinBlurWeight(tap, d, widest) {
+    if (tap === 0)
+        return 2 * burleyMass(SKIN_BLUR_EDGES[0] * widest, d);
+    const inner = SKIN_BLUR_EDGES[tap - 1] * widest;
+    const outer = tap < SKIN_BLUR_EDGES.length ? SKIN_BLUR_EDGES[tap] * widest : Infinity;
+    return (outer === Infinity ? 0.5 : burleyMass(outer, d)) - burleyMass(inner, d);
+}

package/dist/render/skinScatter.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The skin model's arithmetic, as `shaders/flat/skin.ts` computes it: the reference its tests hold
+ * the fit to, and nothing at run time calls it.
+ *
+ * **Pre-integrated, after Penner 2011, with the profile integrated rather than looked up.** Light
+ * entering skin leaves it a little way off, so on a curved surface a point is lit by its
+ * neighbours' `N·L` as well as its own: the clamped cosine averaged around a ring of the surface's
+ * curvature, weighted by the diffusion profile at each neighbour's distance. The profile is Burley's
+ * normalised diffusion, one per channel, at a scatter distance `d` — the model's `radius` times its
+ * scatter colour — projected onto the ring's plane, as a cylinder's cross-section sees it. The
+ * result depends on `N·L` and on one number per channel, `k = d × curvature`, and at `k = 0` it is
+ * Lambert's.
+ *
+ * **Fitted rather than tabulated**, so no seventeenth sampler and no image: the ring average is the
+ * clamped cosine convolved with an angular kernel, so it splits into the cosine's first harmonic —
+ * scaled by one number, `κ₁(k)` — and a smoothed `|cos θ|` carrying every even harmonic:
+ *
+ *     D(c, k) = ½ (κ₁ c + A √(c² + ε²) + B)
+ *
+ * with `κ₁`, `A`, `ε` and `B` closed forms in `k` that are exactly `1, 1, 0, 0` at `k = 0`. The
+ * test measures it against the integral done numerically: **worst 0.0105 over `k` to 10**, beyond
+ * which the shader holds `k` — a scatter ten times the surface's own radius, where the answer is
+ * nearly flat already.
+ */
+/** Schlick's base for skin, at index 1.4: `((1 − n) / (1 + n))²`. */
+export declare const SKIN_F0: number;
+/** The largest `k` the fit is held to, and where the shader clamps it. */
+export declare const SKIN_MAX_K = 10;
+/**
+ * The fit's eight numbers, found by minimising its worst error against the numeric integral over
+ * `c` in [−1, 1] and `k` in (0, 10]:
+ *
+ * - `kappa`: `κ₁ = (1 + a k² + b k³)^(−1/6)` — the first harmonic's share, quadratic at zero and
+ *   falling as `1/√k`, as the integral's does;
+ * - `spread`: `A = (1 + a k³)^(−1/6)`;
+ * - `soften`: `ε = a k / (1 + b k)`, how far `|c|` is rounded at the terminator;
+ * - `floor`: `B = (1 − A)(a + b (1 − A))`, the even part's floor as `A` gives up `|c|`.
+ */
+export declare const SKIN_FIT: {
+    readonly kappa: readonly [22.6772, 101.349];
+    readonly spread: 838.87;
+    readonly soften: readonly [1.3081, 3.65743];
+    readonly floor: readonly [0.508537, 0.129496];
+};
+/** The ring-averaged `N·L` for one channel: `c` is `N·L`, `k` that channel's scatter × curvature. */
+export declare function skinRing(c: number, k: number): number;
+/**
+ * How far into a penumbra skin's light reaches, as a width the shadow is assumed to have: the
+ * lamp loop reads a shadow where its derivative cannot be taken, so its width in the world is not
+ * known there. Two centimetres is a soft edge across a face.
+ */
+export declare const SKIN_PENUMBRA_WIDTH = 0.02;
+/**
+ * A shadow on skin, one channel at scatter distance `d`: the shadow's own value raised to
+ * `1 / (1 + d / width)`, so light reaches further into the penumbra the further that channel
+ * travels beneath the surface — red furthest, which is the red edge a shadow on skin has — and a
+ * shadow stays whole at 0 and absent at 1. **What it gives up** is the profile itself: Penner
+ * convolves a sharpened shadow with it, which needs the penumbra's width in the world and hardens
+ * the narrow channels' edge where nothing widened the map to make room.
+ */
+export declare function skinPenumbra(shadow: number, d: number): number;
+/**
+ * Light through a thin part, one channel: `transmission × exp(−thickness / d)` of the light behind,
+ * by how squarely it is behind. A part as thick as its curvature's diameter — an ear's rim at a few
+ * millimetres, a cheek at ten centimetres — passes red through the one and nothing through the other.
+ */
+export declare function skinTransmission(backNdl: number, thickness: number, d: number, transmission: number): number;

package/dist/render/skinScatter.js

@@ -0,0 +1,80 @@
+/**
+ * The skin model's arithmetic, as `shaders/flat/skin.ts` computes it: the reference its tests hold
+ * the fit to, and nothing at run time calls it.
+ *
+ * **Pre-integrated, after Penner 2011, with the profile integrated rather than looked up.** Light
+ * entering skin leaves it a little way off, so on a curved surface a point is lit by its
+ * neighbours' `N·L` as well as its own: the clamped cosine averaged around a ring of the surface's
+ * curvature, weighted by the diffusion profile at each neighbour's distance. The profile is Burley's
+ * normalised diffusion, one per channel, at a scatter distance `d` — the model's `radius` times its
+ * scatter colour — projected onto the ring's plane, as a cylinder's cross-section sees it. The
+ * result depends on `N·L` and on one number per channel, `k = d × curvature`, and at `k = 0` it is
+ * Lambert's.
+ *
+ * **Fitted rather than tabulated**, so no seventeenth sampler and no image: the ring average is the
+ * clamped cosine convolved with an angular kernel, so it splits into the cosine's first harmonic —
+ * scaled by one number, `κ₁(k)` — and a smoothed `|cos θ|` carrying every even harmonic:
+ *
+ *     D(c, k) = ½ (κ₁ c + A √(c² + ε²) + B)
+ *
+ * with `κ₁`, `A`, `ε` and `B` closed forms in `k` that are exactly `1, 1, 0, 0` at `k = 0`. The
+ * test measures it against the integral done numerically: **worst 0.0105 over `k` to 10**, beyond
+ * which the shader holds `k` — a scatter ten times the surface's own radius, where the answer is
+ * nearly flat already.
+ */
+/** Schlick's base for skin, at index 1.4: `((1 − n) / (1 + n))²`. */
+export const SKIN_F0 = ((1 - 1.4) / (1 + 1.4)) ** 2;
+/** The largest `k` the fit is held to, and where the shader clamps it. */
+export const SKIN_MAX_K = 10;
+/**
+ * The fit's eight numbers, found by minimising its worst error against the numeric integral over
+ * `c` in [−1, 1] and `k` in (0, 10]:
+ *
+ * - `kappa`: `κ₁ = (1 + a k² + b k³)^(−1/6)` — the first harmonic's share, quadratic at zero and
+ *   falling as `1/√k`, as the integral's does;
+ * - `spread`: `A = (1 + a k³)^(−1/6)`;
+ * - `soften`: `ε = a k / (1 + b k)`, how far `|c|` is rounded at the terminator;
+ * - `floor`: `B = (1 − A)(a + b (1 − A))`, the even part's floor as `A` gives up `|c|`.
+ */
+export const SKIN_FIT = {
+    kappa: [22.6772, 101.349],
+    spread: 838.87,
+    soften: [1.3081, 3.65743],
+    floor: [0.508537, 0.129496],
+};
+/** The ring-averaged `N·L` for one channel: `c` is `N·L`, `k` that channel's scatter × curvature. */
+export function skinRing(c, k) {
+    const q = Math.min(Math.max(k, 0), SKIN_MAX_K);
+    const k2 = q * q;
+    const kappa = (1 + SKIN_FIT.kappa[0] * k2 + SKIN_FIT.kappa[1] * k2 * q) ** (-1 / 6);
+    const spread = (1 + SKIN_FIT.spread * k2 * q) ** (-1 / 6);
+    const soften = (SKIN_FIT.soften[0] * q) / (1 + SKIN_FIT.soften[1] * q);
+    const given = 1 - spread;
+    const floor = given * (SKIN_FIT.floor[0] + SKIN_FIT.floor[1] * given);
+    return 0.5 * (kappa * c + spread * Math.sqrt(c * c + soften * soften) + floor);
+}
+/**
+ * How far into a penumbra skin's light reaches, as a width the shadow is assumed to have: the
+ * lamp loop reads a shadow where its derivative cannot be taken, so its width in the world is not
+ * known there. Two centimetres is a soft edge across a face.
+ */
+export const SKIN_PENUMBRA_WIDTH = 0.02;
+/**
+ * A shadow on skin, one channel at scatter distance `d`: the shadow's own value raised to
+ * `1 / (1 + d / width)`, so light reaches further into the penumbra the further that channel
+ * travels beneath the surface — red furthest, which is the red edge a shadow on skin has — and a
+ * shadow stays whole at 0 and absent at 1. **What it gives up** is the profile itself: Penner
+ * convolves a sharpened shadow with it, which needs the penumbra's width in the world and hardens
+ * the narrow channels' edge where nothing widened the map to make room.
+ */
+export function skinPenumbra(shadow, d) {
+    return Math.max(shadow, 0) ** (1 / (1 + d / SKIN_PENUMBRA_WIDTH));
+}
+/**
+ * Light through a thin part, one channel: `transmission × exp(−thickness / d)` of the light behind,
+ * by how squarely it is behind. A part as thick as its curvature's diameter — an ear's rim at a few
+ * millimetres, a cheek at ten centimetres — passes red through the one and nothing through the other.
+ */
+export function skinTransmission(backNdl, thickness, d, transmission) {
+    return transmission * Math.exp(-thickness / Math.max(d, 1e-6)) * Math.max(backNdl, 0);
+}

package/dist/render/skinnedClothRun.d.ts

@@ -0,0 +1,26 @@
+import type { SkinnedClothSetup } from '@driftengine/physics';
+import type { ClothParticlesHandle, RendererApi } from './backend/api.ts';
+/** A garment a renderer solves, from `createSkinnedCloth`. */
+export interface SkinnedClothSolver {
+    /** What `setCloth(binding, particles)` draws the garment's bound meshes by. */
+    readonly particles: ClothParticlesHandle;
+    /** Where the solver runs: on the device, or on the CPU beneath a backend without compute. */
+    readonly runsOn: 'device' | 'cpu';
+    /**
+     * One frame: the rig's pose — each joint's global matrix, model space, sixteen floats a joint,
+     * and the model matrix — and `dt` seconds, run as whole fixed steps; the particles at the frame's
+     * `alpha` are then what the frame draws. **Once a frame, before the draws**, as
+     * `updateClothParticles` is: a second in one frame would reach every draw of it on WebGPU.
+     */
+    step(globals: Float32Array, model: Float32Array, dt: number): void;
+    /**
+     * The air the cloth drags toward from the next step, world space, metres a second: the frame's
+     * sample of the scene's one `WindField`, so a garment moves with everything else in the air.
+     */
+    setWind(x: number, y: number, z: number): void;
+    /** Back to the skinned pose, settled, as a teleport resets it. */
+    reset(): void;
+    dispose(): void;
+}
+/** A garment for `renderer`, from a set-up checked by name. */
+export declare function createSkinnedCloth(renderer: RendererApi, setup: SkinnedClothSetup): SkinnedClothSolver;

package/dist/render/skinnedClothRun.js

@@ -0,0 +1,84 @@
+/**
+ * A skinned cloth for a renderer: `@driftengine/physics`' solver, run as compute on WebGPU — the
+ * particles never leave the device — and as `SkinnedCloth` on the CPU under WebGL2, which has no
+ * compute. One schedule, `ClothControl`, and the same kernels either way; what a frame draws is
+ * `particles`, through `setCloth(binding, cloth.particles)`.
+ *
+ * **A function rather than renderer methods, so a game pays for it only by importing it.** See
+ * `backend/webgpu/computeHost.ts` for the door it reaches the device through, and why.
+ *
+ * **The CPU fallback's cost**, measured on a desktop part: a few hundred particles are a
+ * millisecond a frame on the main thread, and 4,500 are twenty — a garment that size wants the
+ * device. The device solver ran 4,500 particles in 0.65 ms a frame, most of it the dispatches
+ * rather than the particles (`demo/dev/skinnedCloth.html?bench=1`).
+ */
+import { SkinnedCloth } from '@driftengine/physics';
+import { computeHostOf } from './backend/webgpu/computeHost.js';
+import { GpuSkinnedCloth } from './backend/webgpu/gpuSkinnedCloth.js';
+/** A garment for `renderer`, from a set-up checked by name. */
+export function createSkinnedCloth(renderer, setup) {
+    const host = computeHostOf(renderer);
+    return host === null ? new CpuCloth(renderer, setup) : new DeviceCloth(host, setup);
+}
+class DeviceCloth {
+    host;
+    runsOn = 'device';
+    particles;
+    cloth;
+    constructor(host, setup) {
+        this.host = host;
+        this.cloth = new GpuSkinnedCloth(host.device(), setup);
+        this.particles = this.cloth.particles;
+    }
+    step(globals, model, dt) {
+        if (this.host.lost())
+            return;
+        this.cloth.advance(globals, model, dt, this.host.changeFrame());
+    }
+    setWind(x, y, z) {
+        this.cloth.setWind(x, y, z);
+    }
+    reset() {
+        if (this.host.lost())
+            return;
+        this.cloth.reset();
+    }
+    /** Its buffers at once — its work is submitted — and its textures with the frame's. */
+    dispose() {
+        this.cloth.dispose();
+        this.host.retire(this.cloth.particles.textures);
+    }
+    /** The particles where the last step left them: the parity check's door, waits on the device. */
+    read() {
+        return this.cloth.read();
+    }
+}
+class CpuCloth {
+    renderer;
+    runsOn = 'cpu';
+    particles;
+    cloth;
+    /** The frame's particles at `alpha`, before they go up. */
+    staging;
+    constructor(renderer, setup) {
+        this.renderer = renderer;
+        this.cloth = new SkinnedCloth(setup);
+        this.particles = renderer.createClothParticles(this.cloth.count);
+        this.staging = new Float32Array(this.cloth.count * 3);
+    }
+    step(globals, model, dt) {
+        this.cloth.setPose(globals, model);
+        this.cloth.advance(dt);
+        this.cloth.interpolate(this.cloth.alpha, this.staging);
+        this.renderer.updateClothParticles(this.particles, this.staging);
+    }
+    setWind(x, y, z) {
+        this.cloth.setWind(x, y, z);
+    }
+    reset() {
+        this.cloth.reset();
+    }
+    dispose() {
+        this.renderer.disposeClothParticles(this.particles);
+    }
+}

package/dist/render/ssrPass.js

@@ -5,6 +5,7 @@ import { compileProgram, uniformLocations } from './shader.js';
 import { FULLSCREEN_VERT } from './shaders/fullscreen.js';
 import { SSR_RESOLVE_FRAG } from './shaders/ssrResolve.js';
 import { SSR_TRACE_FRAG } from './shaders/ssrTrace.js';
+import { blendKeeping } from './sceneCoverage.js';
 /**
  * Screen-space reflection on WebGL2: a scissored trace per surface, then one composite.
  *
@@ -160,7 +161,7 @@ export class SsrPass {
         gl.disable(gl.CULL_FACE);
         gl.enable(gl.BLEND);
         /* Premultiplied `over`: the trace already multiplied its colour by the coverage it found. */
-        gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+        blendKeeping(gl, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
         gl.useProgram(this.resolve);
         gl.activeTexture(gl.TEXTURE0);
         gl.bindTexture(gl.TEXTURE_2D, this.reflection);