@driftengine/assets 4.12.0 → 4.13.0

package/README.md

@@ -3,7 +3,7 @@
 Model readers, the loader that streams a `.drft` file onto the screen, and the textures a phone
 samples.
 
-**Cost: 27.1 KB gzipped on top of core.** Measured by `scripts/size-gate.test.mjs`, which fails if it
+**Cost: 29.2 KB gzipped on top of core.** Measured by `scripts/size-gate.test.mjs`, which fails if it
 drifts more than 3% — the number is a fact about the build rather than a claim in a document.
 
 - **Readers.** glTF and GLB, OBJ, STL, USD and 3MF, and experimentally FBX and Blender's `.blend`,

package/dist/drftLoader.d.ts

@@ -1,6 +1,6 @@
 /** Loading a `.drft` into drawable parts progressively, without stalling the frame. */
 import type { MeshData } from '@driftengine/drft';
-import type { RendererApi } from '@driftengine/core';
+import type { RendererApi, ShadowCasters, Vec3 } from '@driftengine/core';
 import type { SurfaceTextureHandle } from '@driftengine/core';
 import type { DrftMaterial } from '@driftengine/drft';
 import type { DrftFieldPlacement } from './fieldPlacement.ts';
@@ -328,6 +328,8 @@ export declare class DrftLoader {
     private arrived;
     /** A streamed world's regions, kept apart from the parts and never merged. See `regionStore.ts`. */
     private readonly regionStore;
+    /** What `draw`, `casters` and `prepare` do with the parts. See `partDraws.ts`. */
+    private readonly partDraws;
     constructor(renderer: RendererApi, options?: DrftLoaderOptions);
     get progress(): DrftLoadProgress;
     /**
@@ -444,6 +446,41 @@ export declare class DrftLoader {
         readonly y: number;
         readonly z: number;
     } | null;
+    /**
+     * Draw this frame's parts into the open mesh pass, each by every rule a baked container needs:
+     * its whole material, its copies through the instanced path, a blended part translucent and
+     * writing no depth, glass as glass, its own reflectivity. Returns the draws issued.
+     *
+     * **The one call a model wants**, because each rule missed is a wrong picture rather than an
+     * error: a repeated arch drawn once, a decal as a black patch, foliage without its alpha test.
+     * What it gives up, and what drawing `parts` by hand is for, is a per-part override; see
+     * `PartDraws`.
+     */
+    draw(): number;
+    /**
+     * Every part that stands in the light, for `drawShadowCasters` or a mirror's replay: all but a
+     * decal, which would shadow its own surface, each with its material so a cutout casts the shape
+     * in its texture, glass as glass and copies as copies. Always this frame's parts.
+     */
+    readonly casters: ShadowCasters;
+    /**
+     * Compile what every part's draw will take, off the frame, and wait for it. Call it once the load
+     * has finished, behind whatever is showing then; one frame drawn there as well compiles the
+     * shadow passes' own pipelines, which this cannot reach, and the first frame a player sees then
+     * waits on nothing.
+     */
+    prepare(): Promise<void>;
+    /**
+     * A directional light's matrix covering the model whole, as fitted, into `out`, through
+     * `computeLightMatrixForBounds`; returns the depth span for `shadowDepthSpan`, or null until
+     * `HEAD` has said how large the model is.
+     *
+     * **What it gives up** is the bounds' own: they are the file's, fitted, so a `transform` that
+     * moves a mesh moves it past them, and a model far larger than what the viewer sees spreads the
+     * map over all of it — a city wants the map around the viewer instead, through
+     * `computeLightMatrix`.
+     */
+    shadowFit(lightDir: Vec3, shadowMapSize: number, out: Float32Array): number | null;
     /**
      * Start loading, and resolve when the last byte has been read.
      *

package/dist/drftLoader.js

@@ -1,5 +1,6 @@
 /** Loading a `.drft` into drawable parts progressively, without stalling the frame. */
-import { MeshBuilder, concatMeshes, placeMesh } from '@driftengine/core';
+import { MeshBuilder, computeLightMatrixForBounds, concatMeshes, placeMesh, } from '@driftengine/core';
+import { PartDraws } from './partDraws.js';
 import { placeFields } from './fieldPlacement.js';
 import { TextureSet, textureColorSpaces } from './drftTextures.js';
 import { bcPlan, createBcDecoder } from './bcLoad.js';
@@ -11,6 +12,9 @@ import { drawKeyOf, resolveDrawGrouping } from './drawKey.js';
 import { streamDrft, CODEC_JPEG, CODEC_PNG, CODEC_RAW, CODEC_WEBP, DrftError, expandAssembly, } from '@driftengine/drft';
 import { RegionStore, fitCopies } from './regionStore.js';
 import { DEFAULT_REVEAL_SEC, DEFAULT_UPLOAD_MS_PER_FRAME, DEFAULT_UPLOADS_PER_FRAME, isDocumentResponse, mayBeginMore, } from './uploadBudget.js';
+/** `shadowFit`'s fitted bounds, rewritten in place on each call. */
+const FIT_MIN = [0, 0, 0];
+const FIT_MAX = [0, 0, 0];
 /**
  * A `.drft` loaded progressively: the model builds up on screen instead of appearing.
  *
@@ -162,10 +166,13 @@ export class DrftLoader {
     arrived = 0;
     /** A streamed world's regions, kept apart from the parts and never merged. See `regionStore.ts`. */
     regionStore;
+    /** What `draw`, `casters` and `prepare` do with the parts. See `partDraws.ts`. */
+    partDraws;
     constructor(renderer, options = {}) {
         this.renderer = renderer;
         this.options = options;
         this.regionStore = new RegionStore(renderer, () => this.fit);
+        this.partDraws = new PartDraws(renderer);
     }
     get progress() {
         return this.state;
@@ -388,6 +395,58 @@ export class DrftLoader {
     get placement() {
         return this.fit;
     }
+    /**
+     * Draw this frame's parts into the open mesh pass, each by every rule a baked container needs:
+     * its whole material, its copies through the instanced path, a blended part translucent and
+     * writing no depth, glass as glass, its own reflectivity. Returns the draws issued.
+     *
+     * **The one call a model wants**, because each rule missed is a wrong picture rather than an
+     * error: a repeated arch drawn once, a decal as a black patch, foliage without its alpha test.
+     * What it gives up, and what drawing `parts` by hand is for, is a per-part override; see
+     * `PartDraws`.
+     */
+    draw() {
+        return this.partDraws.draw(this.revealed, this.textureSet);
+    }
+    /**
+     * Every part that stands in the light, for `drawShadowCasters` or a mirror's replay: all but a
+     * decal, which would shadow its own surface, each with its material so a cutout casts the shape
+     * in its texture, glass as glass and copies as copies. Always this frame's parts.
+     */
+    casters = (sink) => this.partDraws.cast(sink, this.revealed, this.textureSet);
+    /**
+     * Compile what every part's draw will take, off the frame, and wait for it. Call it once the load
+     * has finished, behind whatever is showing then; one frame drawn there as well compiles the
+     * shadow passes' own pipelines, which this cannot reach, and the first frame a player sees then
+     * waits on nothing.
+     */
+    prepare() {
+        return this.partDraws.prepare(this.revealed, this.textureSet);
+    }
+    /**
+     * A directional light's matrix covering the model whole, as fitted, into `out`, through
+     * `computeLightMatrixForBounds`; returns the depth span for `shadowDepthSpan`, or null until
+     * `HEAD` has said how large the model is.
+     *
+     * **What it gives up** is the bounds' own: they are the file's, fitted, so a `transform` that
+     * moves a mesh moves it past them, and a model far larger than what the viewer sees spreads the
+     * map over all of it — a city wants the map around the viewer instead, through
+     * `computeLightMatrix`.
+     */
+    shadowFit(lightDir, shadowMapSize, out) {
+        const fit = this.fit;
+        const b = this.bounds;
+        if (fit === null || b.length < 6)
+            return null;
+        const { scale, x, y, z } = fit;
+        FIT_MIN[0] = b[0] * scale + x;
+        FIT_MIN[1] = b[1] * scale + y;
+        FIT_MIN[2] = b[2] * scale + z;
+        FIT_MAX[0] = b[3] * scale + x;
+        FIT_MAX[1] = b[4] * scale + y;
+        FIT_MAX[2] = b[5] * scale + z;
+        return computeLightMatrixForBounds(lightDir, FIT_MIN, FIT_MAX, shadowMapSize, out);
+    }
     /**
      * Start loading, and resolve when the last byte has been read.
      *

package/dist/index.d.ts

@@ -8,6 +8,7 @@
  */
 export { DrftLoader } from './drftLoader.ts';
 export { writePartMaterial } from './partMaterial.ts';
+export { PartDraws } from './partDraws.ts';
 export { dtexTileBytes, tileGridFromDtex } from './dtexTiles.ts';
 export type { DrftFit, DrftLoaderOptions } from './drftLoader.ts';
 export { drawKeyOf, resolveDrawGrouping } from './drawKey.ts';

package/dist/index.js

@@ -17,6 +17,11 @@ export { DrftLoader } from './drftLoader.js';
  * it: a copy that left out the occlusion strength drew a bought model black.
  */
 export { writePartMaterial } from './partMaterial.js';
+/*
+ * Parts drawn, cast and prepared by every rule a container needs, which `DrftLoader.draw` is: here
+ * for a caller drawing parts of its own choosing, several loaders' or a list it filtered.
+ */
+export { PartDraws } from './partDraws.js';
 /*
  * **A `DTEX` chunk's tile table as the grid residency asks about.** The other constructor of a
  * `MaterialTileGrid` — `latentTileGrid` cuts one from a latent a baker holds, and this reads one a

package/dist/partDraws.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A loaded model's parts drawn, cast and prepared by the rules a baked container needs, so a caller
+ * gets them right by calling one method rather than by knowing each of them.
+ *
+ * **Every rule here is one that fails as a picture rather than an error**, which is why they are in
+ * one place: a part's whole material (`writePartMaterial`), or foliage loses its alpha test and a
+ * one-sided card vanishes from behind; a part's copies through the instanced path, or a repeated arch
+ * is drawn once; a blended part translucent whatever its opacity and writing no depth, since its
+ * alpha is in its texture, or a decal draws as a black patch on the stone; glass as glass, its options
+ * kept per pane so a frame allocates none; each part's own reflectivity; and in the shadow, every
+ * part but a decal, which would shadow its own surface, with its material so a cutout casts the
+ * shape in its texture. A part fades in on its `reveal`, translucent while it does.
+ *
+ * **What it gives up**: one material and one reflectivity a part, as the container says, with no
+ * per-part override; a caller who wants one (a map switched off, a part left out) draws the parts
+ * itself, which `writePartMaterial` and the fields of `DrftPart` are for. It sets no camera and opens
+ * no pass: it draws into whichever mesh pass is open, as `drawMesh` does.
+ */
+import type { RendererApi, ShadowCasterSink, SurfaceTextureHandle } from '@driftengine/core';
+import type { TextureSet } from './drftTextures.ts';
+import type { DrftPart } from './loadProgress.ts';
+/** Parts drawn, cast and prepared by every rule a container needs; `DrftLoader.draw` is one. */
+export declare class PartDraws {
+    private readonly renderer;
+    private readonly material;
+    private readonly casterMaterial;
+    /** Each pane's draw options, made once: a frame drawing glass allocates nothing. */
+    private readonly glassDraws;
+    constructor(renderer: RendererApi);
+    /** Draw every part into the open mesh pass. Returns the draws issued. */
+    draw(parts: readonly DrftPart[], textures: TextureSet<SurfaceTextureHandle> | null): number;
+    /** Offer every part that stands in the light to a shadow pass, or to a mirror's replay. */
+    cast(sink: ShadowCasterSink, parts: readonly DrftPart[], textures: TextureSet<SurfaceTextureHandle> | null): void;
+    /**
+     * Compile, off the frame, what every part's draw will take, then wait for it: each in its own
+     * material, translucent as well where it will be drawn so, through its batch where it has copies.
+     * What it cannot reach is the shadow passes' and a probe's own pipelines, which one frame drawn
+     * behind a loading screen compiles; see `RendererApi.prepareMesh`.
+     */
+    prepare(parts: readonly DrftPart[], textures: TextureSet<SurfaceTextureHandle> | null): Promise<void>;
+    /** A part's translucent draw options: glass as glass, a blended part writing no depth. */
+    private optionsFor;
+}

package/dist/partDraws.js

@@ -0,0 +1,100 @@
+import { writePartMaterial } from './partMaterial.js';
+const IDENTITY = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+/** A blended part's draw: its alpha is in its texture, and a depth it wrote would hide what is behind. */
+const BLENDED = Object.freeze({ depthWrite: false });
+const OPAQUE_PREPARED = Object.freeze({ translucent: false });
+const TRANSLUCENT_PREPARED = Object.freeze({ translucent: true });
+/** Parts drawn, cast and prepared by every rule a container needs; `DrftLoader.draw` is one. */
+export class PartDraws {
+    renderer;
+    material = {};
+    casterMaterial = {};
+    /** Each pane's draw options, made once: a frame drawing glass allocates nothing. */
+    glassDraws = new Map();
+    constructor(renderer) {
+        this.renderer = renderer;
+    }
+    /** Draw every part into the open mesh pass. Returns the draws issued. */
+    draw(parts, textures) {
+        const renderer = this.renderer;
+        let draws = 0;
+        for (const part of parts) {
+            renderer.setMaterial(writePartMaterial(part, textures, this.material));
+            renderer.setSurfaceReflectivity(part.reflectivity);
+            const opacity = part.opacity * part.reveal;
+            const options = this.optionsFor(part);
+            const instances = part.instances;
+            if (instances !== null) {
+                if (translucent(part, opacity)) {
+                    renderer.drawTranslucentInstanced(instances.batch, instances.data, opacity, options);
+                }
+                else {
+                    renderer.drawInstanced(instances.batch, instances.data);
+                }
+            }
+            else if (translucent(part, opacity)) {
+                renderer.drawTranslucentMesh(part.mesh, IDENTITY, opacity, options);
+            }
+            else {
+                renderer.drawMesh(part.mesh, IDENTITY);
+            }
+            draws++;
+        }
+        /* Nothing of the last part is left for the caller's own draws: no material, no mirror. */
+        renderer.setMaterial(null);
+        renderer.setSurfaceReflectivity(0);
+        return draws;
+    }
+    /** Offer every part that stands in the light to a shadow pass, or to a mirror's replay. */
+    cast(sink, parts, textures) {
+        const material = this.casterMaterial;
+        for (const part of parts) {
+            /* A blended part that is not glass is a decal, which would shadow the surface it lies on. */
+            if (part.blend && part.glass === null)
+                continue;
+            writePartMaterial(part, textures, material);
+            material.glass = part.glass ?? undefined;
+            if (part.instances !== null) {
+                sink.instanced?.(part.instances.batch, part.instances.data, material);
+            }
+            else {
+                sink.mesh(part.mesh, IDENTITY, material);
+            }
+        }
+    }
+    /**
+     * Compile, off the frame, what every part's draw will take, then wait for it: each in its own
+     * material, translucent as well where it will be drawn so, through its batch where it has copies.
+     * What it cannot reach is the shadow passes' and a probe's own pipelines, which one frame drawn
+     * behind a loading screen compiles; see `RendererApi.prepareMesh`.
+     */
+    async prepare(parts, textures) {
+        const renderer = this.renderer;
+        for (const part of parts) {
+            const material = writePartMaterial(part, textures, this.material);
+            const options = translucent(part, part.opacity) ? TRANSLUCENT_PREPARED : OPAQUE_PREPARED;
+            if (part.instances !== null)
+                renderer.prepareInstanced(part.instances.batch, material, options);
+            else
+                renderer.prepareMesh(part.mesh, material, options);
+        }
+        await renderer.ready();
+    }
+    /** A part's translucent draw options: glass as glass, a blended part writing no depth. */
+    optionsFor(part) {
+        const glass = part.glass;
+        if (glass !== null) {
+            let options = this.glassDraws.get(glass);
+            if (options === undefined) {
+                options = Object.freeze({ ...BLENDED, glass });
+                this.glassDraws.set(glass, options);
+            }
+            return options;
+        }
+        return part.blend ? BLENDED : undefined;
+    }
+}
+/** A blended part is drawn translucent whatever its opacity: its alpha is in its texture. */
+function translucent(part, opacity) {
+    return opacity < 1 || part.blend;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/assets",
-  "version": "4.12.0",
+  "version": "4.13.0",
   "description": "Model readers and the streaming loader for the .drft container",
   "license": "Apache-2.0",
   "type": "module",
@@ -32,11 +32,11 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@driftengine/drft": "4.12.0",
-    "@driftengine/texture": "4.12.0"
+    "@driftengine/drft": "4.13.0",
+    "@driftengine/texture": "4.13.0"
   },
   "peerDependencies": {
-    "@driftengine/core": "4.12.0"
+    "@driftengine/core": "4.13.0"
   },
   "author": "Drift Technologies",
   "repository": {

package/src/drftLoader.ts

@@ -1,13 +1,19 @@
 /** Loading a `.drft` into drawable parts progressively, without stalling the frame. */
 
 import type { MeshData } from '@driftengine/drft';
-import type { MeshHandle, RendererApi } from '@driftengine/core';
+import type { MeshHandle, RendererApi, ShadowCasters, Vec3 } from '@driftengine/core';
 import type {
   CompressedTextureSource,
   GlassOptions,
   SurfaceTextureHandle,
 } from '@driftengine/core';
-import { MeshBuilder, concatMeshes, placeMesh } from '@driftengine/core';
+import {
+  MeshBuilder,
+  computeLightMatrixForBounds,
+  concatMeshes,
+  placeMesh,
+} from '@driftengine/core';
+import { PartDraws } from './partDraws.ts';
 import type { DrftMaterial } from '@driftengine/drft';
 import type { DrftSdfvEntry } from '@driftengine/drft';
 import { placeFields } from './fieldPlacement.ts';
@@ -226,6 +232,10 @@ export interface DrftLoaderOptions {
   readonly onMesh?: (mesh: MeshData, ordinal: number) => boolean;
 }
 
+/** `shadowFit`'s fitted bounds, rewritten in place on each call. */
+const FIT_MIN: Vec3 = [0, 0, 0];
+const FIT_MAX: Vec3 = [0, 0, 0];
+
 /**
  * A `.drft` loaded progressively: the model builds up on screen instead of appearing.
  *
@@ -411,11 +421,14 @@ export class DrftLoader {
   private arrived = 0;
   /** A streamed world's regions, kept apart from the parts and never merged. See `regionStore.ts`. */
   private readonly regionStore: RegionStore;
+  /** What `draw`, `casters` and `prepare` do with the parts. See `partDraws.ts`. */
+  private readonly partDraws: PartDraws;
 
   constructor(renderer: RendererApi, options: DrftLoaderOptions = {}) {
     this.renderer = renderer;
     this.options = options;
     this.regionStore = new RegionStore(renderer, () => this.fit);
+    this.partDraws = new PartDraws(renderer);
   }
 
   get progress(): DrftLoadProgress {
@@ -657,6 +670,62 @@ export class DrftLoader {
     return this.fit;
   }
 
+  /**
+   * Draw this frame's parts into the open mesh pass, each by every rule a baked container needs:
+   * its whole material, its copies through the instanced path, a blended part translucent and
+   * writing no depth, glass as glass, its own reflectivity. Returns the draws issued.
+   *
+   * **The one call a model wants**, because each rule missed is a wrong picture rather than an
+   * error: a repeated arch drawn once, a decal as a black patch, foliage without its alpha test.
+   * What it gives up, and what drawing `parts` by hand is for, is a per-part override; see
+   * `PartDraws`.
+   */
+  draw(): number {
+    return this.partDraws.draw(this.revealed, this.textureSet);
+  }
+
+  /**
+   * Every part that stands in the light, for `drawShadowCasters` or a mirror's replay: all but a
+   * decal, which would shadow its own surface, each with its material so a cutout casts the shape
+   * in its texture, glass as glass and copies as copies. Always this frame's parts.
+   */
+  readonly casters: ShadowCasters = (sink) =>
+    this.partDraws.cast(sink, this.revealed, this.textureSet);
+
+  /**
+   * Compile what every part's draw will take, off the frame, and wait for it. Call it once the load
+   * has finished, behind whatever is showing then; one frame drawn there as well compiles the
+   * shadow passes' own pipelines, which this cannot reach, and the first frame a player sees then
+   * waits on nothing.
+   */
+  prepare(): Promise<void> {
+    return this.partDraws.prepare(this.revealed, this.textureSet);
+  }
+
+  /**
+   * A directional light's matrix covering the model whole, as fitted, into `out`, through
+   * `computeLightMatrixForBounds`; returns the depth span for `shadowDepthSpan`, or null until
+   * `HEAD` has said how large the model is.
+   *
+   * **What it gives up** is the bounds' own: they are the file's, fitted, so a `transform` that
+   * moves a mesh moves it past them, and a model far larger than what the viewer sees spreads the
+   * map over all of it — a city wants the map around the viewer instead, through
+   * `computeLightMatrix`.
+   */
+  shadowFit(lightDir: Vec3, shadowMapSize: number, out: Float32Array): number | null {
+    const fit = this.fit;
+    const b = this.bounds;
+    if (fit === null || b.length < 6) return null;
+    const { scale, x, y, z } = fit;
+    FIT_MIN[0] = (b[0] as number) * scale + x;
+    FIT_MIN[1] = (b[1] as number) * scale + y;
+    FIT_MIN[2] = (b[2] as number) * scale + z;
+    FIT_MAX[0] = (b[3] as number) * scale + x;
+    FIT_MAX[1] = (b[4] as number) * scale + y;
+    FIT_MAX[2] = (b[5] as number) * scale + z;
+    return computeLightMatrixForBounds(lightDir, FIT_MIN, FIT_MAX, shadowMapSize, out);
+  }
+
   /**
    * Start loading, and resolve when the last byte has been read.
    *

package/src/index.ts

@@ -18,6 +18,11 @@ export { DrftLoader } from './drftLoader.ts';
  * it: a copy that left out the occlusion strength drew a bought model black.
  */
 export { writePartMaterial } from './partMaterial.ts';
+/*
+ * Parts drawn, cast and prepared by every rule a container needs, which `DrftLoader.draw` is: here
+ * for a caller drawing parts of its own choosing, several loaders' or a list it filtered.
+ */
+export { PartDraws } from './partDraws.ts';
 /*
  * **A `DTEX` chunk's tile table as the grid residency asks about.** The other constructor of a
  * `MaterialTileGrid` — `latentTileGrid` cuts one from a latent a baker holds, and this reads one a

package/src/partDraws.ts

@@ -0,0 +1,138 @@
+/**
+ * A loaded model's parts drawn, cast and prepared by the rules a baked container needs, so a caller
+ * gets them right by calling one method rather than by knowing each of them.
+ *
+ * **Every rule here is one that fails as a picture rather than an error**, which is why they are in
+ * one place: a part's whole material (`writePartMaterial`), or foliage loses its alpha test and a
+ * one-sided card vanishes from behind; a part's copies through the instanced path, or a repeated arch
+ * is drawn once; a blended part translucent whatever its opacity and writing no depth, since its
+ * alpha is in its texture, or a decal draws as a black patch on the stone; glass as glass, its options
+ * kept per pane so a frame allocates none; each part's own reflectivity; and in the shadow, every
+ * part but a decal, which would shadow its own surface, with its material so a cutout casts the
+ * shape in its texture. A part fades in on its `reveal`, translucent while it does.
+ *
+ * **What it gives up**: one material and one reflectivity a part, as the container says, with no
+ * per-part override; a caller who wants one (a map switched off, a part left out) draws the parts
+ * itself, which `writePartMaterial` and the fields of `DrftPart` are for. It sets no camera and opens
+ * no pass: it draws into whichever mesh pass is open, as `drawMesh` does.
+ */
+import type {
+  GlassOptions,
+  RendererApi,
+  ShadowCasterSink,
+  SurfaceMaterial,
+  SurfaceTextureHandle,
+  TranslucentMeshOptions,
+} from '@driftengine/core';
+import type { TextureSet } from './drftTextures.ts';
+import type { DrftPart } from './loadProgress.ts';
+import { writePartMaterial } from './partMaterial.ts';
+
+const IDENTITY = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+
+/** A blended part's draw: its alpha is in its texture, and a depth it wrote would hide what is behind. */
+const BLENDED: TranslucentMeshOptions = Object.freeze({ depthWrite: false });
+const OPAQUE_PREPARED = Object.freeze({ translucent: false });
+const TRANSLUCENT_PREPARED = Object.freeze({ translucent: true });
+
+/** A caster's material: a part's, and its glass, rewritten for each part. */
+type CasterMaterial = SurfaceMaterial<SurfaceTextureHandle> & { glass?: GlassOptions };
+
+/** Parts drawn, cast and prepared by every rule a container needs; `DrftLoader.draw` is one. */
+export class PartDraws {
+  private readonly material: SurfaceMaterial<SurfaceTextureHandle> = {};
+  private readonly casterMaterial: CasterMaterial = {};
+  /** Each pane's draw options, made once: a frame drawing glass allocates nothing. */
+  private readonly glassDraws = new Map<GlassOptions, TranslucentMeshOptions>();
+
+  constructor(private readonly renderer: RendererApi) {}
+
+  /** Draw every part into the open mesh pass. Returns the draws issued. */
+  draw(parts: readonly DrftPart[], textures: TextureSet<SurfaceTextureHandle> | null): number {
+    const renderer = this.renderer;
+    let draws = 0;
+    for (const part of parts) {
+      renderer.setMaterial(writePartMaterial(part, textures, this.material));
+      renderer.setSurfaceReflectivity(part.reflectivity);
+      const opacity = part.opacity * part.reveal;
+      const options = this.optionsFor(part);
+      const instances = part.instances;
+      if (instances !== null) {
+        if (translucent(part, opacity)) {
+          renderer.drawTranslucentInstanced(instances.batch, instances.data, opacity, options);
+        } else {
+          renderer.drawInstanced(instances.batch, instances.data);
+        }
+      } else if (translucent(part, opacity)) {
+        renderer.drawTranslucentMesh(part.mesh, IDENTITY, opacity, options);
+      } else {
+        renderer.drawMesh(part.mesh, IDENTITY);
+      }
+      draws++;
+    }
+    /* Nothing of the last part is left for the caller's own draws: no material, no mirror. */
+    renderer.setMaterial(null);
+    renderer.setSurfaceReflectivity(0);
+    return draws;
+  }
+
+  /** Offer every part that stands in the light to a shadow pass, or to a mirror's replay. */
+  cast(
+    sink: ShadowCasterSink,
+    parts: readonly DrftPart[],
+    textures: TextureSet<SurfaceTextureHandle> | null,
+  ): void {
+    const material = this.casterMaterial;
+    for (const part of parts) {
+      /* A blended part that is not glass is a decal, which would shadow the surface it lies on. */
+      if (part.blend && part.glass === null) continue;
+      writePartMaterial(part, textures, material);
+      material.glass = part.glass ?? undefined;
+      if (part.instances !== null) {
+        sink.instanced?.(part.instances.batch, part.instances.data, material);
+      } else {
+        sink.mesh(part.mesh, IDENTITY, material);
+      }
+    }
+  }
+
+  /**
+   * Compile, off the frame, what every part's draw will take, then wait for it: each in its own
+   * material, translucent as well where it will be drawn so, through its batch where it has copies.
+   * What it cannot reach is the shadow passes' and a probe's own pipelines, which one frame drawn
+   * behind a loading screen compiles; see `RendererApi.prepareMesh`.
+   */
+  async prepare(
+    parts: readonly DrftPart[],
+    textures: TextureSet<SurfaceTextureHandle> | null,
+  ): Promise<void> {
+    const renderer = this.renderer;
+    for (const part of parts) {
+      const material = writePartMaterial(part, textures, this.material);
+      const options = translucent(part, part.opacity) ? TRANSLUCENT_PREPARED : OPAQUE_PREPARED;
+      if (part.instances !== null)
+        renderer.prepareInstanced(part.instances.batch, material, options);
+      else renderer.prepareMesh(part.mesh, material, options);
+    }
+    await renderer.ready();
+  }
+
+  /** A part's translucent draw options: glass as glass, a blended part writing no depth. */
+  private optionsFor(part: DrftPart): TranslucentMeshOptions | undefined {
+    const glass = part.glass;
+    if (glass !== null) {
+      let options = this.glassDraws.get(glass);
+      if (options === undefined) {
+        options = Object.freeze({ ...BLENDED, glass });
+        this.glassDraws.set(glass, options);
+      }
+      return options;
+    }
+    return part.blend ? BLENDED : undefined;
+  }
+}
+
+/** A blended part is drawn translucent whatever its opacity: its alpha is in its texture. */
+function translucent(part: DrftPart, opacity: number): boolean {
+  return opacity < 1 || part.blend;
+}