@driftengine/core 4.8.7 → 4.9.0

package/dist/render/vertexDefaults.js

@@ -110,7 +110,16 @@ export const OUTPUT_TRANSFORM_CODE = {
     srgb: 1,
     aces: 2,
     shoulder: 3,
+    filmic: 4,
 };
+/**
+ * The code a **forward** pass grades with: the transform's own, except `filmic`, which only the
+ * composite carries the constants for, and which a pass grading itself therefore draws as `aces`.
+ * Both backends' `gradeCode` read this, so neither can hand a forward stage a code it lacks.
+ */
+export function forwardTransformCode(transform) {
+    return transform === 'filmic' ? 2 : (OUTPUT_TRANSFORM_CODE[transform] ?? 0);
+}
 /**
  * How far the speed rush reaches, and how far a motion-blurred pixel may travel, both in UV.
  *
@@ -119,3 +128,18 @@ export const OUTPUT_TRANSFORM_CODE = {
  */
 export const RUSH_REACH_UV = 0.012;
 export const MOTION_BLUR_MAX_UV = 0.03;
+/**
+ * A longest smear as `setCameraMotionBlur` takes it: a share of the frame, above zero and at most
+ * half, and the default where the number is not one. Shared, so both backends cap one way.
+ */
+export function clampMotionShare(share) {
+    return Number.isFinite(share) && share > 0 ? Math.min(share, 0.5) : MOTION_BLUR_MAX_UV;
+}
+/**
+ * Said once where a draw names where it was last frame and the frame blurs by motion, but keeps no
+ * motion target to blur that draw by: each object's own motion is drawn only under a
+ * reconstruction on WebGPU, and anywhere else the camera's motion alone smears the frame.
+ */
+export const OBJECT_BLUR_UNKEPT = "[driftengine] motion blur follows each draw's own motion only under a reconstruction " +
+    "(DriftTR, WebGPU), which draws the motion target it reads; here the camera's motion alone " +
+    'blurs the frame, and a moving object is smeared only as the camera moved past it.';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/core",
-  "version": "4.8.7",
+  "version": "4.9.0",
   "description": "The runtime of DriftEngine, a WebGPU game engine with a WebGL2 fallback: renderer, loop, input, cameras, scene graph and physics",
   "license": "Apache-2.0",
   "type": "module",
@@ -29,8 +29,8 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@driftengine/drft": "4.8.7",
-    "@driftengine/physics": "4.8.7",
+    "@driftengine/drft": "4.9.0",
+    "@driftengine/physics": "4.9.0",
     "gl-matrix": "^3.4.3"
   },
   "author": "Drift Technologies",
@@ -67,8 +67,8 @@
     "prepack": "node ../../scripts/build.mjs @driftengine/core"
   },
   "devDependencies": {
-    "@driftengine/nav": "4.8.7",
-    "@driftengine/network": "4.8.7",
-    "@driftengine/texture": "4.8.7"
+    "@driftengine/nav": "4.9.0",
+    "@driftengine/network": "4.9.0",
+    "@driftengine/texture": "4.9.0"
   }
 }

package/src/index.ts

@@ -454,6 +454,8 @@ export type { ReflectionOptions, ReflectiveSample } from './render/gi/reflection
  */
 export { GRADE_PLACEHOLDER_SIZE, MAX_GRADE_SIZE, identityGradeLut } from './render/colourGrade.ts';
 export type { ColourGradeLut } from './render/colourGrade.ts';
+export { DEFAULT_FILMIC_CURVE } from './render/filmicCurve.ts';
+export type { FilmicCurve } from './render/filmicCurve.ts';
 /**
  * How bloom answers past its threshold — a ramp in place of the subtraction, and a tint for each
  * of the pyramid's `BLOOM_LEVELS` octaves — the third argument of `setBloom`.
@@ -513,6 +515,20 @@ export type {
   SurfaceModel,
   SurfaceModelKind,
 } from './render/surfaceModel.ts';
+/*
+ * What a draw lays over its surface beyond its material — a rim of light, a dissolve, wrinkle
+ * normals by region — set per draw with `setSurfaceOverlay`, its images regions of one atlas.
+ */
+/* Every opaque lit surface reflecting the frame by its own material: `screenSpaceReflections`. */
+export { DEFAULT_FRAME_REFLECTIONS } from './render/frameReflections.ts';
+export type { FrameReflections } from './render/frameReflections.ts';
+export type {
+  OverlayRegion,
+  SurfaceDissolve,
+  SurfaceOverlay,
+  SurfaceRim,
+  SurfaceWrinkle,
+} from './render/surfaceOverlay.ts';
 /*
  * A baked lightmap: the page a consumer decoded, which `createLightmap` uploads as a lightmapped
  * material's `modelMap`, and the region of it a material or an instance reads.

package/src/render/atmosphere.ts

@@ -47,6 +47,19 @@ export interface Atmosphere {
   /** Linear mode only: where haze begins, and where it is total. */
   fogNear?: number;
   fogFar?: number;
+  /**
+   * The medium only: how far along the view ray it begins, in metres. Absent or 0 is at the
+   * camera, as every world before it was drawn.
+   *
+   * The air nearer than this is perfectly clear, and what lies beyond is fogged by the air past
+   * this point alone — so a faint, bright haze can lie over a distant crowd while the figures a
+   * few metres from the camera stay sharp, which no density can do when the medium starts at the
+   * eye: there it veils the whole frame, lifting the shadows and draining the colour before it
+   * reaches anything far enough to want it. Unlike `linear`'s `fogNear`, nothing past it is a
+   * ramp: it is the same extinction, integrated from further out. **What it gives up** is the air
+   * between the camera and the start, which a real medium has; that is the point of it.
+   */
+  fogStart?: number;
   underwater: UnderwaterAtmosphere | null;
 }
 
@@ -132,7 +145,15 @@ export function resolveAtmosphere(
   out.fogHeightFalloff = atmosphere.fogHeightFalloff;
   out.fogEyeY = cameraY;
   out.fogMode = atmosphere.fogMode === 'linear' ? 1 : 0;
-  out.fogNear = atmosphere.fogNear ?? 0;
+  /*
+   * **One slot, two meanings, and never both**: the ramp's near distance in linear mode, and in
+   * the medium where it begins (`fogStart`), which the medium never read before — so a world that
+   * left a `fogNear` on an exponential fog starts nothing, and draws exactly as it did.
+   */
+  out.fogNear =
+    atmosphere.fogMode === 'linear'
+      ? (atmosphere.fogNear ?? 0)
+      : Math.max(0, Number.isFinite(atmosphere.fogStart) ? (atmosphere.fogStart ?? 0) : 0);
   out.fogFar = atmosphere.fogFar ?? 1;
   /*
    * The air medium stands in when nothing is submerged. The shaders multiply by the factor

package/src/render/backend/api.ts

@@ -7,6 +7,7 @@ import type { ProbeBakeOptions } from '../reflectionProbe.ts';
 import type { Renderer, TranslucentMeshOptions } from './webgl2/renderer.ts';
 import type { InstancedOptions, MeshInstances } from '../instances.ts';
 import type { SurfaceMaterial } from '../surfaceTexture.ts';
+import type { SurfaceOverlay } from '../surfaceOverlay.ts';
 import type { SurfaceSource } from '../compressedSource.ts';
 import type { LightmapPage } from '../lightmap.ts';
 import type { DeviceParticles } from '../particlePool.ts';
@@ -311,6 +312,7 @@ export type RendererApi = Omit<
   | 'disposeSurfaceTexture'
   | 'setSurfaceTexture'
   | 'setMaterial'
+  | 'setSurfaceOverlay'
   | 'createClothBinding'
   | 'createClothParticles'
   | 'updateClothParticles'
@@ -341,6 +343,13 @@ export type RendererApi = Omit<
   setCloth(binding: ClothBindingHandle | null, particles?: ClothParticlesHandle | null): void;
   disposeClothBinding(binding: ClothBindingHandle): void;
   disposeClothParticles(particles: ClothParticlesHandle): void;
+  /**
+   * What the following draws lay over their surfaces beyond their materials — a rim of light, a
+   * dissolve with a glowing edge, wrinkle normals by region — or null for none, which every pass
+   * starts with. Per draw, so one character's whole set of materials changes together. Its images
+   * are regions of one atlas (`SurfaceOverlay.maps`). See `surfaceOverlay.ts`.
+   */
+  setSurfaceOverlay(overlay: SurfaceOverlay | null): void;
   /**
    * Upload a caller's image, or a BC image's blocks with their stored chain where
    * `compressedFormats` has the format. See `SurfaceTextureHandle` for the boundary this guards.

package/src/render/backend/createRenderer.ts

@@ -5,6 +5,7 @@ import { BACKEND_TIMEOUT_MS, forcedBackend, selectBackend } from './select.ts';
 import { TIMED_OUT, withDeadline } from './deadline.ts';
 import { mountSplash, type MountedSplash, type SplashOptions } from '../../ui/splash.ts';
 import { gpuDrivenRefusal, gpuDrivenSupported } from '../gpudriven/pipeline.ts';
+import { browserHighDynamicRange, chooseDisplayRange } from '../displayRange.ts';
 
 /**
  * Which of the two pipelines is drawing.
@@ -149,6 +150,12 @@ export interface CreateRendererOptions {
    * badge is looked at on a deployed build.
    */
   readonly splash?: boolean | SplashOptions;
+  /**
+   * Whether the display shows a high dynamic range, asked only where `highDynamicRange` was. The
+   * browser's `(dynamic-range: high)` query by default; a host with no DOM, or one that knows
+   * better about its own display, answers instead. See `displayRange.ts`.
+   */
+  readonly highDynamicRangeDisplay?: () => boolean;
 }
 
 /** What was built, and which path built it. */
@@ -370,7 +377,17 @@ export async function createRenderer(
         const { createGpuSurface } = await import('./webgpu/device.ts');
         const { WebGPURenderer } = await import('./webgpu/renderer.ts');
         stage = 'creating the surface';
-        const surface = createGpuSurface(canvas, device);
+        const profile = resolveRenderQuality(qualityFor('webgpu'));
+        const surface = createGpuSurface(
+          canvas,
+          device,
+          chooseDisplayRange(
+            profile.highDynamicRange,
+            profile.screenEffects && profile.hdrScene,
+            profile.highDynamicRange &&
+              (options.highDynamicRangeDisplay ?? browserHighDynamicRange)(),
+          ),
+        );
         stage = 'constructing the renderer';
         return { surface, WebGPURenderer };
       })();