@driftengine/core 4.4.2 → 4.6.0

package/src/render/backend/drawFog.ts

@@ -0,0 +1,31 @@
+/**
+ * How a draw meets the medium between it and the eye: the value of the mesh shader's
+ * `uFogEnabled`, which both backends write from this one rule.
+ *
+ * **A surface recedes into the medium; light added to the frame fades in it.** A surface that
+ * covers what is behind it is mixed toward the medium's colour with distance, which is the haze
+ * standing in front of it. An additive draw covers nothing: what is behind it has already been
+ * fogged, and mixing the draw toward the medium's colour and then *adding* it puts that haze into
+ * the frame a second time. So a glow by day added the sky's grey in the shape of the glow, and
+ * added more of it the thicker the air — reported as solid grey cones under every street lamp on
+ * a hazy morning. Faded instead, added light loses what the medium scatters out of it and adds
+ * nothing of its own, which is how the same shader already treats the glow behind frosted glass.
+ *
+ * What fading gives up is the one thing mixing did for a glow: at great distance it disappears
+ * into the air instead of greying into it. That is what light in fog does. What would make it
+ * wrong is an additive draw standing for *lit air* rather than light — and that is what
+ * `drawLightVolume` is for, which is fogged by neither rule.
+ */
+
+/** Out of the medium entirely: `TranslucentMeshOptions.fog` set to false. */
+export const FOG_OFF = 0;
+/** Mixed toward the medium's colour with distance: every surface, and the pass's default. */
+export const FOG_RECEDE = 1;
+/** Scaled down by what the medium scatters and given none of its colour: added light. */
+export const FOG_FADE = 2;
+
+/** The medium rule for a draw that asked for fog or not, and adds its light or covers. */
+export function fogModeOf(fog: boolean, additive: boolean): number {
+  if (!fog) return FOG_OFF;
+  return additive ? FOG_FADE : FOG_RECEDE;
+}

package/src/render/backend/materialChanges.ts

@@ -18,11 +18,14 @@
  * slot on the backend that keeps slots, and comparing every field would cost more than the slot.
  */
 
+import { FOG_RECEDE } from './drawFog.ts';
+
 /** What of a draw's own options its material carries. */
 export interface DrawMaterialOptions {
   readonly opacity: number;
   readonly lit: boolean;
-  readonly fog: boolean;
+  /** How it meets the medium, as `fogModeOf` says; the pass's own is `FOG_RECEDE`. */
+  readonly fog: number;
   readonly toneMapped: boolean;
   /** Whether the draw refracts this time, which a backend decides by whether it has a snapshot. */
   readonly refracting: boolean;
@@ -31,7 +34,11 @@ export interface DrawMaterialOptions {
 /** Whether a draw's options differ from the pass's, so it takes a material and leaves one to restore. */
 export function ownsMaterial(options: DrawMaterialOptions): boolean {
   return (
-    options.opacity < 1 || !options.lit || !options.fog || !options.toneMapped || options.refracting
+    options.opacity < 1 ||
+    !options.lit ||
+    options.fog !== FOG_RECEDE ||
+    !options.toneMapped ||
+    options.refracting
   );
 }
 

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

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

@@ -1,38 +1,66 @@
-import { INSTANCE_FLOATS, INSTANCE_STRIDE, packInstances } from '../../instances.ts';
+import { cullInstances, instancesBox } from '../../instanceCull.ts';
+import {
+  INSTANCE_FLOATS,
+  INSTANCE_STRIDE,
+  createMeshInstances,
+  packInstances,
+} from '../../instances.ts';
 import type { MeshInstances } from '../../instances.ts';
 import type { Mesh } from '../../mesh.ts';
+import type { FrustumPlanes } from '../../../math/frustum.ts';
 
 /**
- * One mesh's per-instance buffer, bound to that mesh's own vertex array.
+ * One batch of a mesh: its per-instance buffer and a vertex array of its own.
  *
  * The twin of the WebGPU batch and deliberately the same shape, because which floats go where is
- * a decision shared through `instances.ts` and only the binding is per-backend.
+ * a decision shared through `instances.ts` and only the binding is per-backend. The vertex array is
+ * the batch's rather than the mesh's (`Mesh.createInstanceArray`), which is what lets one mesh carry
+ * a batch per region.
  *
- * The staging array is allocated here and rewritten in place, so a frame re-uploading a moving
+ * **A culling batch holds a second buffer and array**, for the instances `cullInstances` keeps each
+ * camera draw. The full set stays in the first, because a shadow pass, a mirror and a probe each
+ * see a different part of the batch than the camera does, and they draw from it.
+ *
+ * Staging arrays are allocated here and rewritten in place, so a frame re-uploading or re-culling a
  * batch allocates nothing.
  */
 export class InstancedBatch {
   readonly mesh: Mesh;
   readonly capacity: number;
+  /** Whether the camera draw culls this batch. See `InstancedOptions.cull`. */
+  readonly cull: boolean;
+  /** The world box around every live instance, fitted at upload. See `instancesBox`. */
+  readonly box = new Float32Array([1, 1, 1, -1, -1, -1]);
   private readonly buffer: WebGLBuffer;
+  private readonly vao: WebGLVertexArrayObject;
   private readonly staging: Float32Array;
+  private readonly kept: {
+    readonly buffer: WebGLBuffer;
+    readonly vao: WebGLVertexArrayObject;
+    readonly instances: MeshInstances;
+  } | null;
 
-  constructor(gl: WebGL2RenderingContext, mesh: Mesh, capacity: number) {
-    const buffer = gl.createBuffer();
-    if (buffer === null) throw new Error('InstancedBatch: createBuffer failed');
+  constructor(gl: WebGL2RenderingContext, mesh: Mesh, capacity: number, cull = false) {
     this.mesh = mesh;
     this.capacity = capacity;
-    this.buffer = buffer;
+    this.cull = cull;
     this.staging = new Float32Array(capacity * INSTANCE_FLOATS);
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    gl.bufferData(gl.ARRAY_BUFFER, capacity * INSTANCE_STRIDE, gl.DYNAMIC_DRAW);
-    /* `DYNAMIC_DRAW` because a batch of vehicles is rewritten every frame — advisory, but a
-       driver told the truth can place the buffer where a rewrite is cheap. */
-    mesh.attachInstances(gl, buffer, INSTANCE_STRIDE);
+    this.buffer = allocate(gl, capacity);
+    this.vao = mesh.createInstanceArray(gl, this.buffer, INSTANCE_STRIDE);
+    if (cull) {
+      const buffer = allocate(gl, capacity);
+      this.kept = {
+        buffer,
+        vao: mesh.createInstanceArray(gl, buffer, INSTANCE_STRIDE),
+        instances: createMeshInstances(capacity),
+      };
+    } else {
+      this.kept = null;
+    }
   }
 
-  /** Pack and push the live prefix, in one call. */
   upload(gl: WebGL2RenderingContext, data: MeshInstances): void {
+    if (this.cull) instancesBox(data, this.mesh.bounds, this.box);
     const count = Math.min(data.count, this.capacity);
     if (count === 0) return;
     packInstances(data, this.staging);
@@ -40,7 +68,45 @@ export class InstancedBatch {
     gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.staging, 0, count * INSTANCE_FLOATS);
   }
 
+  /** Draw the first `count` uploaded instances: every draw but a culling camera draw. */
+  draw(gl: WebGL2RenderingContext, count: number): void {
+    this.mesh.drawInstancesThrough(gl, this.vao, count);
+  }
+
+  /**
+   * Cull `data` against `frustum`, upload what survives into the second buffer and draw it. Returns
+   * how many were drawn — 0 draws nothing. Only for a batch made with `cull`.
+   */
+  drawCulled(gl: WebGL2RenderingContext, data: MeshInstances, frustum: FrustumPlanes): number {
+    const kept = this.kept;
+    if (kept === null) return 0;
+    const count = cullInstances(data, this.mesh.bounds, frustum, kept.instances);
+    if (count === 0) return 0;
+    packInstances(kept.instances, this.staging);
+    gl.bindBuffer(gl.ARRAY_BUFFER, kept.buffer);
+    gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.staging, 0, count * INSTANCE_FLOATS);
+    this.mesh.drawInstancesThrough(gl, kept.vao, count);
+    return count;
+  }
+
   dispose(gl: WebGL2RenderingContext): void {
+    gl.deleteVertexArray(this.vao);
     gl.deleteBuffer(this.buffer);
+    if (this.kept !== null) {
+      gl.deleteVertexArray(this.kept.vao);
+      gl.deleteBuffer(this.kept.buffer);
+    }
   }
 }
+
+/**
+ * An instance buffer sized to capacity. `DYNAMIC_DRAW` because a batch of vehicles is rewritten
+ * every frame — advisory, but a driver told the truth can place the buffer where a rewrite is cheap.
+ */
+function allocate(gl: WebGL2RenderingContext, capacity: number): WebGLBuffer {
+  const buffer = gl.createBuffer();
+  if (buffer === null) throw new Error('InstancedBatch: createBuffer failed');
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  gl.bufferData(gl.ARRAY_BUFFER, Math.max(1, capacity) * INSTANCE_STRIDE, gl.DYNAMIC_DRAW);
+  return buffer;
+}