@driftengine/core 4.8.1 → 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;
   /**
@@ -335,6 +346,11 @@ export class SurfaceTexture {
   }
 
   /** Bind the effects table to `unit`, or `fallback` for a texture given none. */
+  /** Whether this texture carries an effects table, which the lit program reads only once one exists. */
+  get hasEffects(): boolean {
+    return this.effectsTable !== null;
+  }
+
   bindEffects(gl: WebGL2RenderingContext, unit: number, fallback: WebGLTexture): void {
     gl.activeTexture(gl.TEXTURE0 + unit);
     gl.bindTexture(gl.TEXTURE_2D, this.effectsTable ?? fallback);

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/viewModel.ts

@@ -0,0 +1,41 @@
+/**
+ * The slice of depth a view model is drawn into: the nearest share of the range.
+ *
+ * **A first-person view model — arms and a held weapon — must never go into the wall it is pushed
+ * against**, and clearing depth to draw it on top costs every pass that reads depth afterwards:
+ * ambient occlusion, depth of field and the fog all see a hole where the world was. Squeezing the
+ * view model's depth into the nearest sliver of the range does neither. Anything past the near
+ * plane in the world lands behind it, the world's depth is kept, and the view model still sorts
+ * against itself, at a fraction of the precision.
+ *
+ * **The near end is where the convention says it is**: 1 under reversed depth and 0 under the
+ * conventional sense, which a WebGL2 context without `EXT_clip_control` runs. Taken from the
+ * renderer's own `reversedDepth`, never from the constant, for the reason `depthConvention.ts`
+ * gives at length.
+ *
+ * **What it gives up**: a view model is in front of everything, so it cannot be drawn reaching
+ * behind a world object in its own frame — which is what a view model is for. And under temporal
+ * reconstruction its pixels take no motion of their own, because the motion pass matches the frame's
+ * depth exactly and a squeezed draw matches nothing; draw a view model with multisampling.
+ */
+
+/** The share of depth a view model is drawn into when the caller names none: the nearest 1%. */
+export const VIEW_MODEL_DEPTH_SHARE = 0.01;
+
+/**
+ * Fill `out` with the `[min, max]` window depth a view model's draws are squeezed into.
+ *
+ * `share` is clamped to `[1e-4, 1]`: zero would collapse every view-model fragment onto one depth
+ * and lose its own sorting, and more than the whole range is no squeeze.
+ */
+export function viewModelDepthRange(
+  reversed: boolean,
+  share: number,
+  out: [number, number] | Float32Array,
+): void {
+  const width = Number.isFinite(share)
+    ? Math.min(1, Math.max(1e-4, share))
+    : VIEW_MODEL_DEPTH_SHARE;
+  out[0] = reversed ? 1 - width : 0;
+  out[1] = reversed ? 1 : width;
+}

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);