@driftengine/core 4.2.1 → 4.4.0

package/src/render/driftLight/layout.ts

@@ -0,0 +1,177 @@
+/**
+ * Where DriftLight's volume exists: the bricks some light reaches, the grid that finds them, and
+ * which lights reach each one.
+ *
+ * **Sparse, because light is.** A candle reaches a metre and a courtyard is forty, so a dense grid
+ * would be almost entirely zeros: a brick is kept only where a light's reach touches it, by the
+ * exact sphere-against-box test rather than the box-against-box one, which takes the corner bricks a
+ * sphere's box reaches and the sphere does not.
+ *
+ * **A brick is four samples a side and shares its faces with its neighbours**, so it spans three
+ * spacings and two bricks that meet agree on the samples between them. That is what lets the shader
+ * filter inside one brick with the hardware's trilinear lookup and never see a seam where it crosses
+ * into the next.
+ *
+ * **Numbered in the index's own order**, x fastest, so a layout depends on where the lights are and
+ * not on the order a scene listed them in: two loads of one scene produce one atlas.
+ *
+ * What it gives up: the index is dense over the lights' bounding box, so lights spread thinly over a
+ * kilometre would make a large, mostly empty grid. It refuses one past `MAX_INDEX_AXIS` bricks on
+ * any axis and says to make one field per region instead; what would change that is a hashed
+ * index, which costs the shader a probe loop.
+ */
+
+/** Samples on each axis of a brick. The first and last are shared with the neighbour. */
+export const BRICK_SAMPLES = 4;
+
+/**
+ * Bricks on each axis of the index, which is a 3D texture: 256 is the least `MAX_3D_TEXTURE_SIZE`
+ * WebGL2 promises, and a limit on the cell count alone would pass a grid 300 bricks long and one
+ * wide that a device is free to refuse. At a metre a brick, a field 256 m on a side.
+ */
+export const MAX_INDEX_AXIS = 256;
+
+/** What the layout reads of a light: where it is and how far it reaches. */
+export interface LightReach {
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  readonly radius: number;
+}
+
+export interface LightFieldLayout {
+  /** Metres between two samples. */
+  readonly spacing: number;
+  /** Metres a brick spans: three spacings. */
+  readonly span: number;
+  /** The world position of brick (0, 0, 0)'s first sample. */
+  readonly origin: readonly [number, number, number];
+  /** Bricks on each axis of the index. */
+  readonly dims: readonly [number, number, number];
+  /** Per index cell, x fastest: the brick's number plus one, or 0 where there is no brick. */
+  readonly index: Uint32Array;
+  /** How many bricks there are. */
+  readonly count: number;
+  /** Each brick's cell in the index, three integers a brick. */
+  readonly brickCoords: Int32Array;
+  /** Where brick `b`'s lights start in `lights`; `lightStart[b + 1]` is where they end. */
+  readonly lightStart: Uint32Array;
+  /** The lights reaching each brick, in the order the scene listed them. */
+  readonly lights: Uint32Array;
+}
+
+const EMPTY: LightFieldLayout = {
+  spacing: 0,
+  span: 0,
+  origin: [0, 0, 0],
+  dims: [0, 0, 0],
+  index: new Uint32Array(0),
+  count: 0,
+  brickCoords: new Int32Array(0),
+  lightStart: new Uint32Array(1),
+  lights: new Uint32Array(0),
+};
+
+/** The bricks `lights` reach at `spacing` metres between samples. Built once; not a frame path. */
+export function layoutLightField(lights: readonly LightReach[], spacing: number): LightFieldLayout {
+  if (!(spacing > 0)) {
+    throw new Error(`layoutLightField: spacing is ${String(spacing)} and must be positive.`);
+  }
+  const span = spacing * (BRICK_SAMPLES - 1);
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  let reaching = 0;
+  for (const light of lights) {
+    if (!(light.radius > 0)) continue;
+    reaching += 1;
+    const at = [light.x, light.y, light.z];
+    for (let axis = 0; axis < 3; axis++) {
+      min[axis] = Math.min(min[axis] as number, (at[axis] as number) - light.radius);
+      max[axis] = Math.max(max[axis] as number, (at[axis] as number) + light.radius);
+    }
+  }
+  if (reaching === 0) return EMPTY;
+
+  const origin = min.map((value) => Math.floor(value / span) * span) as [number, number, number];
+  const dims = max.map(
+    (value, axis) => Math.floor((value - (origin[axis] as number)) / span) + 1,
+  ) as [number, number, number];
+  if (dims.some((across) => across > MAX_INDEX_AXIS)) {
+    throw new Error(
+      `layoutLightField: these lights span ${dims.join(' x ')} bricks against a limit of ` +
+        `${MAX_INDEX_AXIS} on each axis. Give each region of the world a field of its own, or a ` +
+        'coarser spacing.',
+    );
+  }
+  const cells = dims[0] * dims[1] * dims[2];
+
+  /* Which cells a light reaches, visited twice: once to mark and count, once to list. */
+  const visit = (each: (light: number, cell: number) => void): void => {
+    lights.forEach((light, number) => {
+      if (!(light.radius > 0)) return;
+      const at = [light.x, light.y, light.z];
+      const low = [0, 0, 0];
+      const high = [0, 0, 0];
+      for (let axis = 0; axis < 3; axis++) {
+        const o = origin[axis] as number;
+        const p = at[axis] as number;
+        low[axis] = Math.max(0, Math.floor((p - light.radius - o) / span));
+        high[axis] = Math.min(
+          (dims[axis] as number) - 1,
+          Math.floor((p + light.radius - o) / span),
+        );
+      }
+      const reach2 = light.radius * light.radius;
+      for (let k = low[2] as number; k <= (high[2] as number); k++) {
+        for (let j = low[1] as number; j <= (high[1] as number); j++) {
+          for (let i = low[0] as number; i <= (high[0] as number); i++) {
+            const cell = [i, j, k];
+            let d2 = 0;
+            for (let axis = 0; axis < 3; axis++) {
+              const lo = (origin[axis] as number) + (cell[axis] as number) * span;
+              const p = at[axis] as number;
+              const out = Math.max(lo - p, 0, p - (lo + span));
+              d2 += out * out;
+            }
+            if (d2 <= reach2) each(number, i + dims[0] * (j + dims[1] * k));
+          }
+        }
+      }
+    });
+  };
+
+  const index = new Uint32Array(cells);
+  let pairs = 0;
+  visit((_, cell) => {
+    index[cell] = 1;
+    pairs += 1;
+  });
+  let count = 0;
+  for (let cell = 0; cell < cells; cell++) if (index[cell] !== 0) index[cell] = ++count;
+
+  const brickCoords = new Int32Array(count * 3);
+  for (let cell = 0; cell < cells; cell++) {
+    const brick = (index[cell] as number) - 1;
+    if (brick < 0) continue;
+    brickCoords[brick * 3] = cell % dims[0];
+    brickCoords[brick * 3 + 1] = Math.floor(cell / dims[0]) % dims[1];
+    brickCoords[brick * 3 + 2] = Math.floor(cell / (dims[0] * dims[1]));
+  }
+
+  const lightStart = new Uint32Array(count + 1);
+  visit((_, cell) => {
+    lightStart[index[cell] as number] = (lightStart[index[cell] as number] as number) + 1;
+  });
+  for (let brick = 0; brick < count; brick++) {
+    lightStart[brick + 1] = (lightStart[brick + 1] as number) + (lightStart[brick] as number);
+  }
+  const filled = lightStart.slice(0, count);
+  const listed = new Uint32Array(pairs);
+  visit((light, cell) => {
+    const brick = (index[cell] as number) - 1;
+    listed[filled[brick] as number] = light;
+    filled[brick] = (filled[brick] as number) + 1;
+  });
+
+  return { spacing, span, origin, dims, index, count, brickCoords, lightStart, lights: listed };
+}

package/src/render/driftLight/lightField.ts

@@ -0,0 +1,227 @@
+/**
+ * DriftLight: a scene's many fixed lights summed into one volume, which stands in for them wherever
+ * they are not shaded one by one.
+ *
+ * **The problem it answers.** A frame shades a few hundred lights at most, chosen nearest the
+ * camera, and a scene of thousands of candles left every one past that choice dark: a wall with a
+ * dozen candles beside it lit nothing until the camera walked up to it. This sums every fixed light
+ * once, occluded by the scene's distance field, into sparse bricks of light and direction; the lit
+ * shader shades exactly where the frame's choice is complete (`PointLightBuffer.complete`) and reads
+ * the volume past it, crossfading across a band so nothing pops. A light is never counted twice:
+ * the split is per pixel, and the field's own lights carry a mark (`inLightField`) the selection
+ * turns into the sign of their weight.
+ *
+ * **Baked a few bricks a step, by the scene.** `bake(bricks)` does the number asked, so a scene paces
+ * it as it paces anything else it builds behind a loading screen, and the build is deterministic:
+ * the engine reads no clock. The volume is not summed into the frame until every brick has landed,
+ * then fades in over `fadeSec`, so a field completing in view does not pop; a field baked behind a
+ * loading screen asks for no fade.
+ *
+ * **The lights are summed as they stood when the field was made**, from a copy: a scene dimming its
+ * lamps at dawn rewrites the very objects it gave the field, and a bake paced into the morning
+ * would otherwise sum lamps already out. `scale` dims what was summed.
+ *
+ * What it gives up is stated where each part does it: specular from summed lights (`bake.ts`),
+ * flicker past the choice (the volume holds each light's steady colour), and occlusion by anything
+ * that moves (only the fields given at construction shadow it).
+ */
+
+import type { GlobalFieldInstance } from '../gi/globalField.ts';
+import { distanceToInstances } from '../gi/globalField.ts';
+import { halfBits } from '../halfFloat.ts';
+import { BRICK_TEXELS, bakeBrick } from './bake.ts';
+import type { FieldLight } from './bake.ts';
+import type { PointLightFalloff } from './falloff.ts';
+import { BRICK_SAMPLES, layoutLightField } from './layout.ts';
+import type { LightFieldLayout } from './layout.ts';
+
+/** Seconds the summed light takes to fade in once the field is whole. */
+export const FIELD_FADE_SEC = 0.5;
+/** How fast the shading radius grows back, per second, when the choice reaches further again. */
+const RADIUS_GROWTH_PER_SEC = 2;
+/** Bricks along each axis of the atlas: 256 texels a side, the least 3D texture WebGL2 promises. */
+const ATLAS_BRICKS: readonly [number, number, number] = [32, 64, 64];
+/** A brick's footprint in the atlas: its light block and its direction block side by side. */
+const BRICK_WIDTH = BRICK_SAMPLES * 2;
+
+/** A light a field sums: a `PointLightSource`, whose `inLightField` the field sets. */
+export interface LightFieldSource extends FieldLight {
+  inLightField?: boolean;
+}
+
+export interface LightFieldOptions {
+  /** How the renderer shades a point light, which the sum has to match. */
+  readonly falloff: PointLightFalloff;
+  /** Metres between samples; a third of a metre by default, so a brick spans a metre. */
+  readonly spacing?: number;
+  /** The scene's placed distance fields, which occlude the light. None leaves it unoccluded. */
+  readonly fields?: readonly GlobalFieldInstance[];
+  /** Metres over which exact and summed light crossfade at the shading radius. Two by default. */
+  readonly band?: number;
+  /**
+   * Seconds the summed light fades in over once the field is whole, `FIELD_FADE_SEC` by default.
+   * Zero for a field baked behind a loading screen, which has nothing on screen to pop and may be
+   * stepped by a clock that has stopped.
+   */
+  readonly fadeSec?: number;
+}
+
+export class LightField {
+  readonly layout: LightFieldLayout;
+  /** Texels on each axis of the atlas. */
+  readonly atlasSize: readonly [number, number, number];
+  /** Bricks on each axis of the atlas, which the shader needs to find a brick's corner. */
+  readonly atlasBricks: readonly [number, number, number];
+  /** The atlas as half floats, four channels a texel, x fastest. */
+  readonly atlas: Uint16Array;
+  /** Metres over which exact and summed light crossfade. */
+  readonly band: number;
+  /** Whether a distance field occludes this field's light. */
+  readonly occluded: boolean;
+  /** Seconds the summed light fades in over once whole; zero is at once. */
+  readonly fadeSec: number;
+  /** The summed light's brightness, for a scene that dims all its lamps at once: dawn, a switch. */
+  scale = 1;
+  /** Where the frame's choice was centred, which the shader measures the radius from. */
+  readonly centre = new Float32Array(3);
+
+  private readonly lights: readonly FieldLight[];
+  private readonly falloff: PointLightFalloff;
+  private readonly distance: ((x: number, y: number, z: number) => number) | null;
+  private readonly lightBlock = new Float32Array(BRICK_TEXELS * 4);
+  private readonly directionBlock = new Float32Array(BRICK_TEXELS * 4);
+  private baked = 0;
+  private taken = 0;
+  private eased = 0;
+  private shown = 0;
+
+  constructor(lights: readonly LightFieldSource[], options: LightFieldOptions) {
+    for (const light of lights) light.inLightField = true;
+    this.lights = lights.map(({ x, y, z, radius, r, g, b, sourceRadius }) => ({
+      x,
+      y,
+      z,
+      radius,
+      r,
+      g,
+      b,
+      sourceRadius,
+    }));
+    this.falloff = options.falloff;
+    this.band = options.band ?? 2;
+    this.fadeSec = Math.max(0, options.fadeSec ?? FIELD_FADE_SEC);
+    const fields = options.fields ?? [];
+    this.occluded = fields.length > 0;
+    this.distance = this.occluded ? distanceToInstances(fields) : null;
+    this.layout = layoutLightField(lights, options.spacing ?? 1 / 3);
+
+    const count = this.layout.count;
+    const capacity = ATLAS_BRICKS[0] * ATLAS_BRICKS[1] * ATLAS_BRICKS[2];
+    if (count > capacity) {
+      throw new Error(
+        `LightField: these lights reach ${count} bricks and one field holds ${capacity}. ` +
+          'Give each region of the world a field of its own, or a coarser spacing.',
+      );
+    }
+    const ax = Math.max(1, Math.min(count, ATLAS_BRICKS[0]));
+    const ay = Math.max(1, Math.min(Math.ceil(count / ax), ATLAS_BRICKS[1]));
+    const az = Math.max(1, Math.ceil(count / (ax * ay)));
+    this.atlasBricks = [ax, ay, az];
+    this.atlasSize = [ax * BRICK_WIDTH, ay * BRICK_SAMPLES, az * BRICK_SAMPLES];
+    this.atlas = new Uint16Array(this.atlasSize[0] * this.atlasSize[1] * this.atlasSize[2] * 4);
+  }
+
+  /** Whether every brick has been baked. */
+  get ready(): boolean {
+    return this.baked >= this.layout.count;
+  }
+
+  /** How much of the bake is done, 0 to 1, for a loading screen. */
+  get progress(): number {
+    return this.layout.count === 0 ? 1 : this.baked / this.layout.count;
+  }
+
+  /** The radius, in metres from `centre`, inside which lights are shaded exactly. */
+  get radius(): number {
+    return this.eased;
+  }
+
+  /** How much of the summed light is in the frame, 0 until the field is whole, then up to 1. */
+  get presence(): number {
+    return this.shown;
+  }
+
+  /** The texel at which brick `brick`'s light block starts; its direction block is 4 along x. */
+  atlasCorner(brick: number): [number, number, number] {
+    const [ax, ay] = this.atlasBricks;
+    return [
+      (brick % ax) * BRICK_WIDTH,
+      (Math.floor(brick / ax) % ay) * BRICK_SAMPLES,
+      Math.floor(brick / (ax * ay)) * BRICK_SAMPLES,
+    ];
+  }
+
+  /** Bake up to `bricks` more bricks into the atlas, and answer how many were baked. */
+  bake(bricks: number): number {
+    const end = Math.min(this.layout.count, this.baked + Math.max(0, Math.floor(bricks)));
+    const done = end - this.baked;
+    for (let brick = this.baked; brick < end; brick++) {
+      bakeBrick(
+        this.layout,
+        brick,
+        this.lights,
+        this.falloff,
+        this.distance,
+        this.lightBlock,
+        this.directionBlock,
+      );
+      this.place(brick);
+    }
+    this.baked = end;
+    return done;
+  }
+
+  /** The bricks baked since the last call, for a backend to upload. */
+  takeBaked(): { from: number; to: number } {
+    const range = { from: this.taken, to: this.baked };
+    this.taken = this.baked;
+    return range;
+  }
+
+  /**
+   * Follow the frame's choice: `complete` from the selection, centred at (x, y, z). The radius
+   * shrinks at once, because a pixel inside it that a left-out light reaches would be shaded
+   * short, and grows back slowly, because a pixel it has not reached yet takes the summed light,
+   * which is only less exact. While nothing is summed the radius simply follows.
+   */
+  follow(complete: number, x: number, y: number, z: number, dtSec: number): void {
+    this.centre[0] = x;
+    this.centre[1] = y;
+    this.centre[2] = z;
+    const showing = this.shown > 0;
+    if (!showing || complete < this.eased) this.eased = complete;
+    else this.eased += (complete - this.eased) * (1 - Math.exp(-RADIUS_GROWTH_PER_SEC * dtSec));
+    if (this.ready) {
+      this.shown = this.fadeSec > 0 ? Math.min(1, this.shown + dtSec / this.fadeSec) : 1;
+    }
+  }
+
+  /** Write the brick just baked into its place in the atlas, as half floats. */
+  private place(brick: number): void {
+    const [x0, y0, z0] = this.atlasCorner(brick);
+    const [w, h] = this.atlasSize;
+    for (let k = 0; k < BRICK_SAMPLES; k++) {
+      for (let j = 0; j < BRICK_SAMPLES; j++) {
+        for (let i = 0; i < BRICK_SAMPLES; i++) {
+          const from = (i + BRICK_SAMPLES * (j + BRICK_SAMPLES * k)) * 4;
+          const light = (((z0 + k) * h + (y0 + j)) * w + (x0 + i)) * 4;
+          const direction = light + BRICK_SAMPLES * 4;
+          for (let c = 0; c < 4; c++) {
+            this.atlas[light + c] = halfBits(this.lightBlock[from + c] as number);
+            this.atlas[direction + c] = halfBits(this.directionBlock[from + c] as number);
+          }
+        }
+      }
+    }
+  }
+}

package/src/render/driftLight/uniforms.ts

@@ -0,0 +1,61 @@
+/**
+ * What the lit shader is told about a DriftLight field this pass, decided once for both backends.
+ *
+ * **Decided here and bound there**, by the 2026-08-13 rule: each backend only uploads these numbers
+ * to the names `driftLight.ts` declares, so the two cannot come to disagree about when the field is
+ * on or what radius a pass uses. Off, which the shader reads as `light.x` of zero, until a field is
+ * whole; and during a probe bake the radius is zero, because the exact lights were chosen for the
+ * camera and a probe stands somewhere else: a probe sees every fixed light through the volume.
+ *
+ * **The radius is handed over measured from the eye**, because the shader measures from the
+ * `uCameraPos` it already has rather than spending a uniform on the choice's centre. A point within
+ * `r − |eye − centre|` of the eye is within `r` of the centre, so taking the offset off keeps every
+ * pixel the shader shades exactly inside the radius the selection promised. A mirror's camera, far
+ * from the centre, gets a smaller radius and more of the volume, which is the safe direction.
+ */
+
+import type { LightField } from './lightField.ts';
+
+export interface DriftLightUniforms {
+  /** How much of the summed light is in, the radius, the band, the scale. */
+  readonly light: Float32Array;
+  /** The first brick's first sample, and the metres between samples. */
+  readonly origin: Float32Array;
+}
+
+export function createDriftLightUniforms(): DriftLightUniforms {
+  return {
+    light: new Float32Array(4),
+    origin: new Float32Array(4),
+  };
+}
+
+/**
+ * Fill `out` for `field`, or for no field, seen from `eye`; `probePass` while a probe's faces are
+ * being drawn.
+ */
+export function resolveDriftLight(
+  field: LightField | null,
+  probePass: boolean,
+  eye: ArrayLike<number>,
+  out: DriftLightUniforms,
+): void {
+  if (field === null || !field.ready || field.presence <= 0 || field.layout.count === 0) {
+    out.light.fill(0);
+    return;
+  }
+  const { layout } = field;
+  const offset = Math.hypot(
+    (eye[0] ?? 0) - (field.centre[0] as number),
+    (eye[1] ?? 0) - (field.centre[1] as number),
+    (eye[2] ?? 0) - (field.centre[2] as number),
+  );
+  out.light[0] = field.presence;
+  out.light[1] = probePass ? 0 : Math.max(0, field.radius - offset);
+  out.light[2] = field.band;
+  out.light[3] = field.scale;
+  out.origin[0] = layout.origin[0];
+  out.origin[1] = layout.origin[1];
+  out.origin[2] = layout.origin[2];
+  out.origin[3] = layout.spacing;
+}

package/src/render/driftLight/visibility.ts

@@ -0,0 +1,58 @@
+/**
+ * How much of a light a point sees, through a signed distance field: DriftLight's occlusion.
+ *
+ * **Sphere-traced, with a penumbra from the light's own size.** A spherical light of radius R seen
+ * from a distance L fills a cone that is R * t / L across at a distance t along the way, so a surface
+ * a clearance h from the ray covers the fraction of it that h falls short of that radius. The least
+ * such ratio along the ray is the visibility: 1 in open air, 0 behind a wall, and a soft ramp at an
+ * edge that widens with the light, which is what `AGENTS.md` asks of a light with a physical size.
+ *
+ * The trace stops before the light by its own radius, or 5 cm where that is smaller, so a candle's
+ * wax does not shadow the flame sitting on it. What it gives up is exactness at a grazing corner,
+ * where one ratio stands for an area the cone only partly crosses; what would make it wrong is a
+ * field coarser than the lights it shadows, which blurs every occluder smaller than a cell.
+ */
+
+/** A signed distance: metres to the nearest surface, negative inside. */
+export type DistanceAt = (x: number, y: number, z: number) => number;
+
+/** Steps before the trace gives up and answers what it has; a light a metre off needs a dozen. */
+const MAX_STEPS = 64;
+/** The least a step advances, so a ray grazing a surface still reaches the light. */
+const MIN_STEP_M = 0.01;
+/** Where the trace starts, clear of the surface the point may be lying on. */
+const START_M = 0.02;
+
+/** The visibility, 0 to 1, of a light of radius `sourceRadius` at `to` from the point `from`. */
+export function softVisibility(
+  distance: DistanceAt,
+  fx: number,
+  fy: number,
+  fz: number,
+  tx: number,
+  ty: number,
+  tz: number,
+  sourceRadius: number,
+): number {
+  const dx = tx - fx;
+  const dy = ty - fy;
+  const dz = tz - fz;
+  const length = Math.hypot(dx, dy, dz);
+  if (length < 1e-6) return 1;
+  const ux = dx / length;
+  const uy = dy / length;
+  const uz = dz / length;
+  const radius = Math.max(sourceRadius, 1e-3);
+  const end = length - Math.max(radius, 0.05);
+  let seen = 1;
+  let t = START_M;
+  for (let step = 0; step < MAX_STEPS && t < end; step++) {
+    const h = distance(fx + ux * t, fy + uy * t, fz + uz * t);
+    if (h <= 0) return 0;
+    const cone = (radius * t) / length;
+    seen = Math.min(seen, h / cone);
+    if (seen <= 0) return 0;
+    t += Math.max(h, MIN_STEP_M);
+  }
+  return Math.min(1, seen);
+}

package/src/render/emptyTexture.ts

@@ -128,3 +128,44 @@ export function createEmptyTextureCube(gl: WebGL2RenderingContext): WebGLTexture
   gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);
   return texture;
 }
+
+/**
+ * The same for DriftLight's two volumes while a scene has no field: one texel of an unsigned
+ * integer, reading "no brick here", or of zero light. GLSL ES gives a 3D sampler no default and a
+ * lookup through an unbound one is the undefined read this file exists to prevent.
+ */
+export function createEmptyTexture3D(gl: WebGL2RenderingContext, integer: boolean): WebGLTexture {
+  const texture = allocate(gl, 'emptyTexture3D');
+  gl.bindTexture(gl.TEXTURE_3D, texture);
+  if (integer) {
+    gl.texImage3D(
+      gl.TEXTURE_3D,
+      0,
+      gl.R32UI,
+      1,
+      1,
+      1,
+      0,
+      gl.RED_INTEGER,
+      gl.UNSIGNED_INT,
+      new Uint32Array(1),
+    );
+  } else {
+    gl.texImage3D(
+      gl.TEXTURE_3D,
+      0,
+      gl.RGBA8,
+      1,
+      1,
+      1,
+      0,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      new Uint8Array(4),
+    );
+  }
+  gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  gl.bindTexture(gl.TEXTURE_3D, null);
+  return texture;
+}