@driftengine/core 4.8.2 → 4.8.3

package/src/render/shaders/rush.ts

@@ -25,6 +25,7 @@ import { DEPTH_OF_FIELD_GLSL } from './depthOfField.ts';
 import { AUTO_EXPOSURE_GLSL } from './exposure.ts';
 import { LOCAL_EXPOSURE_GLSL } from './localExposure.ts';
 import { FILM_LOOK_GLSL } from './filmLook.ts';
+import { HIGHLIGHT_SHOULDER_GLSL } from './outputTransform.ts';
 
 export const RUSH_FRAG = `#version 300 es
 precision highp float;
@@ -242,9 +243,11 @@ vec3 acesFilmic(vec3 x) {
   return clamp(ACES_OUTPUT * (a / b), 0.0, 1.0);
 }
 
+${HIGHLIGHT_SHOULDER_GLSL}
 vec3 grade(vec3 c) {
   if (uOutputTransform == 0) return c;
   if (uOutputTransform == 2) c = acesFilmic(c);
+  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);
   return linearToSrgb(c);
 }
 
@@ -335,7 +338,8 @@ vec3 finish(vec3 light) {
 }
 
 void main() {
-  vec3 scene = textureLod(uScene, vUv, 0.0).rgb;
+  vec4 sampled = textureLod(uScene, vUv, 0.0);
+  vec3 scene = sampled.rgb;
   if (uMotionStrength > 0.0) scene = cameraBlur(scene);
   /*
    * Defocus after the camera smear and before everything else, because a lens is the last thing
@@ -350,8 +354,15 @@ void main() {
    * not then darkened again along its own trail. mix from 1 rather than a multiply by the
    * strength, so the parameter reads as "how much of this occlusion", and 0 is exactly the
    * frame that existed before the effect did.
+   *
+   * **Scaled by the surface's share of the pixel**, which the scene carries in its alpha
+   * (sceneCoverage.ts): the occlusion was measured from the depth the opaque world left, and a
+   * pane, a puff of smoke or a caption in front of a corner wrote no depth, so darkening all of the
+   * pixel darkened them by a corner they hide. Where nothing blended landed the share is 1 and
+   * this is the frame it was.
    */
-  float ao = mix(1.0, textureLod(uAo, vUv + uAoOffset, 0.0).r, uAoStrength);
+  float share = clamp(sampled.a, 0.0, 1.0);
+  float ao = mix(1.0, textureLod(uAo, vUv + uAoOffset, 0.0).r, uAoStrength * share);
 
   /*
    * Distance from the centre, corrected so the falloff is a circle on screen rather than

package/src/render/shaders/temporalResolve.ts

@@ -211,11 +211,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;
@@ -248,7 +255,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;
@@ -261,7 +268,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;
@@ -320,6 +327,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/src/render/ssrPass.ts

@@ -8,6 +8,7 @@ import { compileProgram, uniformLocations } from './shader.ts';
 import { FULLSCREEN_VERT } from './shaders/fullscreen.ts';
 import { SSR_RESOLVE_FRAG } from './shaders/ssrResolve.ts';
 import { SSR_TRACE_FRAG } from './shaders/ssrTrace.ts';
+import { blendKeeping } from './sceneCoverage.ts';
 
 /**
  * Screen-space reflection on WebGL2: a scissored trace per surface, then one composite.
@@ -202,7 +203,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);

package/src/render/surfaceTexture.ts

@@ -70,6 +70,17 @@ export interface SurfaceMaterial<Texture = SurfaceTexture> {
   /** Repeats across the mesh's own UV range, per axis. Applies to every map the material holds. */
   uScale?: number;
   vScale?: number;
+  /**
+   * Where the texture starts, per axis, added after the scale: a surface samples
+   * `uv · scale + offset`. Applies to every map, and to a cutout's shadow and depth as well.
+   *
+   * **What picks a cell of a flipbook or an atlas through the material**, so one quad draws any
+   * cell: a strip of four frames is `uScale: 0.25` and `uOffset: frame * 0.25`. Without it a
+   * consumer built one quad mesh per cell — 106 meshes for four strips — because the only way to
+   * move a texture was to move the geometry's own coordinates.
+   */
+  uOffset?: number;
+  vOffset?: number;
   /** Alpha below which a fragment is discarded. See `uAlbedoCutout`. */
   cutout?: number;
   /**

package/src/render/textRenderer.ts

@@ -2,6 +2,7 @@ import type { TextStyle } from './textLayout.ts';
 import { MAX_CELLS, TEXT_CUBE, TextLayout, deviceSnappedOrigin } from './textLayout.ts';
 import { compileProgram, uniformLocations } from './shader.ts';
 import { TEXT_FRAG, TEXT_VERT } from './shaders/text.ts';
+import { blendCovering } from './sceneCoverage.ts';
 
 /**
  * Text as geometry, on WebGL2.
@@ -112,7 +113,7 @@ export class TextRenderer {
     const reversed = current === gl.GREATER || current === gl.GEQUAL;
     gl.depthFunc(reversed ? gl.GEQUAL : gl.LEQUAL);
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    blendCovering(gl, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
 
     setVec2(gl, this.uniforms['uViewport'], viewportWidth, viewportHeight);
     /* Snapped with the cell below: a whole pitch on a fractional origin still splits a stroke.

package/src/render/vertexDefaults.ts

@@ -105,6 +105,7 @@ export const OUTPUT_TRANSFORM_CODE: Readonly<Record<string, number>> = {
   none: 0,
   srgb: 1,
   aces: 2,
+  shoulder: 3,
 };
 
 /**

package/src/render/waterRenderer.ts

@@ -10,6 +10,7 @@ import { bindPointLights } from './lightBudget.ts';
 import type { PointLightSet } from './lightBudget.ts';
 import { DEFAULT_RENDER_QUALITY } from './renderQuality.ts';
 import { createResolvedWater, resolveWater, waterAppearance } from './waterDraw.ts';
+import { blendCovering } from './sceneCoverage.ts';
 
 /**
  * An endless wave surface. Game-agnostic: it takes a height, colours and a
@@ -325,7 +326,7 @@ export class WaterRenderer {
     gl.uniform1i(u['uReflectionFilterTaps'] ?? null, this.reflectionFilterTaps);
 
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    blendCovering(gl, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
     // Waves are displaced far enough that back faces show at grazing angles.
     gl.disable(gl.CULL_FACE);
 

package/src/render/windStreakRenderer.ts

@@ -11,6 +11,7 @@ import {
   type WindStreakSettings,
 } from './windStreakDraw.ts';
 import type { WindField } from './windField.ts';
+import { blendCovering } from './sceneCoverage.ts';
 
 /**
  * Makes the wind visible once it is strong enough to be worth seeing.
@@ -112,7 +113,7 @@ export class WindStreakRenderer {
     gl.uniform3fv(u['uTint'] ?? null, tint);
 
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    blendCovering(gl, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
     gl.depthMask(false);
     gl.disable(gl.CULL_FACE);
     gl.bindVertexArray(this.vao);