@driftengine/core 4.4.1 → 4.5.0

package/dist/render/translucentQueue.js

@@ -1,3 +1,4 @@
+import { resolveGlass } from './glass.js';
 function newRecord() {
     return {
         mesh: null,
@@ -14,12 +15,15 @@ function newRecord() {
         refractTint: null,
         thicknessM: 0,
         refractTintStore: new Float32Array(3),
+        glass: null,
+        glassStore: { transmission: 0, frost: 0, tint: [1, 1, 1] },
     };
 }
 export class TranslucentQueue {
     pool = [];
     count = 0;
     refracting = 0;
+    glassing = 0;
     /** How many draws this frame has recorded. */
     get length() {
         return this.count;
@@ -31,6 +35,10 @@ export class TranslucentQueue {
     get refracts() {
         return this.refracting > 0;
     }
+    /** Whether anything recorded this frame is glass, so the copy it reads needs its mip chain. */
+    get glassy() {
+        return this.glassing > 0;
+    }
     /** How many records are pooled, which a test uses to assert a steady scene stops allocating. */
     get capacity() {
         return this.pool.length;
@@ -65,7 +73,12 @@ export class TranslucentQueue {
             record.tint = record.tintStore;
         }
         record.refraction = options.refraction ?? 0;
-        if (record.refraction > 0)
+        /* Glass reads the copy too, whether or not it bends: see `glass.ts`. */
+        const glassy = resolveGlass(options.glass, record.glassStore);
+        record.glass = glassy ? record.glassStore : null;
+        if (glassy)
+            this.glassing++;
+        if (record.refraction > 0 || glassy)
             this.refracting++;
         record.thicknessM = options.thicknessM ?? 0;
         const refractTint = options.refractTint ?? null;
@@ -97,5 +110,6 @@ export class TranslucentQueue {
     reset() {
         this.count = 0;
         this.refracting = 0;
+        this.glassing = 0;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/core",
-  "version": "4.4.1",
+  "version": "4.5.0",
   "description": "DriftEngine reusable browser 3D runtime",
   "license": "Apache-2.0",
   "type": "module",
@@ -29,8 +29,8 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@driftengine/drft": "4.4.1",
-    "@driftengine/physics": "4.4.1",
+    "@driftengine/drft": "4.5.0",
+    "@driftengine/physics": "4.5.0",
     "gl-matrix": "^3.4.3"
   },
   "author": "Drift Technologies",
@@ -63,8 +63,8 @@
     "prepack": "node ../../scripts/build.mjs @driftengine/core"
   },
   "devDependencies": {
-    "@driftengine/nav": "4.4.1",
-    "@driftengine/network": "4.4.1",
-    "@driftengine/texture": "4.4.1"
+    "@driftengine/nav": "4.5.0",
+    "@driftengine/network": "4.5.0",
+    "@driftengine/texture": "4.5.0"
   }
 }

package/src/index.ts

@@ -202,6 +202,15 @@ export { createPassAttachment } from './render/passTarget.ts';
  * resolve finds its geometry where the renderer's own verbs put theirs.
  */
 export { jitterClip } from './render/recon/jitter.ts';
+/*
+ * Which object a draw is, for a reconstruction that has to find where it was last frame. See
+ * `RendererApi.drawMesh`.
+ */
+/* Glass: a pane that shows what is behind it, clear or frosted. See `TranslucentMeshOptions.glass`. */
+export { resolveGlass } from './render/glass.ts';
+export type { GlassOptions, ResolvedGlass } from './render/glass.ts';
+export { createMover } from './render/recon/mover.ts';
+export type { Mover } from './render/recon/mover.ts';
 export type { FrameResource } from './render/frame/index.ts';
 /*
  * Occlusion culling, which is arithmetic rather than a GPU feature — so the class is public and a
@@ -568,6 +577,7 @@ export type { PrefilterQuality } from './render/prefilterEnvMap.ts';
 export type { ProbeBakeOptions } from './render/reflectionProbe.ts';
 export type {
   DirectionalShadowDepthLayers,
+  GlassShadows,
   OutputTransform,
   RenderQuality,
   RenderQualityOptions,

package/src/render/backend/api.ts

@@ -10,6 +10,7 @@ import type { TextStyle } from '../textLayout.ts';
 import type { SdfFont } from '../sdfFont.ts';
 import type { SdfTextStyle } from '../sdfTextLayout.ts';
 import type { FrameTimer } from './timer.ts';
+import type { Mover } from '../recon/mover.ts';
 
 /**
  * Geometry on the device, as something a consumer holds and hands back.
@@ -767,18 +768,23 @@ export type RendererApi = Omit<
     depthLayer?: number,
     tint?: Vec3 | null,
     /**
-     * Where this mesh's surface was last frame, for a reconstruction's motion target.
+     * Where this mesh's surface was last frame, for a reconstruction's motion target: a `Mover`,
+     * or last frame's model matrix.
      *
-     * **Only a reconstruction reads it**, and only on WebGPU: it is what turns a moving object's
-     * stale history from a smear into a reprojection. A draw that says nothing gets the camera's
-     * motion, derived from the depth, which is exactly right for anything that did not move and
-     * wrong in proportion to how far a mover moved. Null and omitted mean the same thing.
+     * **A `Mover` is the ordinary answer.** Make one per moving object with `createMover()` and pass
+     * it with every draw of that object; the renderer keeps last frame's model and, for a skinned
+     * draw, last frame's palette. A matrix still works exactly as it always has: the *model* matrix
+     * this mesh was drawn with last frame, not a velocity, so a rotation and a scale are as correct
+     * as a translation. Null and omitted mean the same thing: the camera's motion, derived from the
+     * depth, which is exactly right for anything that did not move and wrong in proportion to how
+     * far a mover moved.
      *
-     * It is the *model* matrix this mesh was drawn with last frame, not a velocity: the pass
-     * transforms each vertex twice and lets the perspective divide do the rest, so a rotation and a
-     * scale are as correct as a translation.
+     * **Only a reconstruction reads it**, and only on WebGPU. A mover drawn twice in one frame is
+     * two objects wearing one identity: the second draw is warned about once and records no motion.
+     * Instanced batches and meshes rewritten with `updateMesh` need none — the batch and the mesh
+     * are their own identity.
      */
-    previousModel?: ReadonlyMat4 | null,
+    previousModel?: ReadonlyMat4 | Mover | null,
   ): void;
 
   /** Release the geometry behind a handle. */

package/src/render/backend/webgl2/glassTintPrograms.ts

@@ -0,0 +1,58 @@
+/**
+ * The five programs a pane casts its colour through, one per way a caster is drawn, compiled the
+ * first time glass casts — so a scene with no glass compiles none of them.
+ *
+ * The vertex stages are the depth pass's with the world position handed on (`depth.ts`), so a
+ * pane's colour lands exactly where its depth does; the fragment is `paneTexel` for the device.
+ */
+import { compileProgram, uniformLocations } from '../../shader.ts';
+import {
+  GLASS_TINT_CUTOUT_FRAG,
+  GLASS_TINT_CUTOUT_VERT,
+  GLASS_TINT_FRAG,
+  GLASS_TINT_INSTANCED_CUTOUT_VERT,
+  GLASS_TINT_INSTANCED_VERT,
+  GLASS_TINT_SKINNED_VERT,
+  GLASS_TINT_VERT,
+} from '../../shaders/depth.ts';
+
+export interface GlassTintProgram {
+  readonly program: WebGLProgram;
+  readonly uniforms: Record<string, WebGLUniformLocation>;
+}
+
+export class GlassTintPrograms {
+  readonly rigid: GlassTintProgram;
+  readonly instanced: GlassTintProgram;
+  readonly skinned: GlassTintProgram;
+  readonly cutout: GlassTintProgram;
+  readonly instancedCutout: GlassTintProgram;
+
+  constructor(gl: WebGL2RenderingContext) {
+    const build = (vert: string, frag: string, label: string): GlassTintProgram => {
+      const program = compileProgram(gl, vert, frag, label);
+      return { program, uniforms: uniformLocations(gl, program, label) };
+    };
+    this.rigid = build(GLASS_TINT_VERT, GLASS_TINT_FRAG, 'glassTint');
+    this.instanced = build(GLASS_TINT_INSTANCED_VERT, GLASS_TINT_FRAG, 'glassTint.instanced');
+    this.skinned = build(GLASS_TINT_SKINNED_VERT, GLASS_TINT_FRAG, 'glassTint.skinned');
+    this.cutout = build(GLASS_TINT_CUTOUT_VERT, GLASS_TINT_CUTOUT_FRAG, 'glassTint.cutout');
+    this.instancedCutout = build(
+      GLASS_TINT_INSTANCED_CUTOUT_VERT,
+      GLASS_TINT_CUTOUT_FRAG,
+      'glassTint.instancedCutout',
+    );
+  }
+
+  dispose(gl: WebGL2RenderingContext): void {
+    for (const { program } of [
+      this.rigid,
+      this.instanced,
+      this.skinned,
+      this.cutout,
+      this.instancedCutout,
+    ]) {
+      gl.deleteProgram(program);
+    }
+  }
+}