@volter/blender-engine 0.1.81 → 0.1.83

package/browser/three/blender-draw-materials.ts

@@ -0,0 +1,55 @@
+import * as THREE from 'three';
+import {syncPhysicalDrawMaterial} from './blender-physical-material';
+
+type Variant = {material: THREE.MeshPhysicalMaterial; sourceVersion: number; frame: number; ready: boolean};
+const MAX_VARIANTS = 128;
+
+/** Three caches one current shader form per Material. Alternating ordinary,
+ * instanced and batched objects under that material repeatedly rebuilds its
+ * program parameters/uniform list, even when all programs are already linked.
+ * These small, disposable material identities isolate those caches without
+ * changing canonical material slots, geometry, transparency order or values. */
+export class BlenderDrawMaterials {
+  private readonly sources = new Map<THREE.Material, Map<string, Variant>>();
+  private readonly geometryKeys = new Map<THREE.BufferGeometry, string>();
+  private frame = 0;
+  private count = 0;
+
+  begin(): void { this.frame++; this.geometryKeys.clear(); }
+
+  get(source: THREE.Material, mesh: THREE.InstancedMesh | THREE.BatchedMesh): THREE.Material {
+    let geometryKey = this.geometryKeys.get(mesh.geometry);
+    if (geometryKey === undefined) {
+      geometryKey = JSON.stringify([mesh.geometry.userData['blenderUvChannels'] ?? null,
+        Object.keys(mesh.geometry.attributes).sort().map(name => [name, mesh.geometry.getAttribute(name).itemSize])]);
+      this.geometryKeys.set(mesh.geometry, geometryKey);
+    }
+    const key = `${mesh instanceof THREE.BatchedMesh ? 'batch' : 'instance'}:${geometryKey}`;
+    let variants = this.sources.get(source);
+    if (!variants) { variants = new Map(); this.sources.set(source, variants); }
+    let variant = variants.get(key);
+    if (!variant) {
+      if (this.count >= MAX_VARIANTS) return source;
+      const material = syncPhysicalDrawMaterial(source);
+      if (!material) return source;
+      variant = {material, sourceVersion: source.version, frame: this.frame, ready: true};
+      variants.set(key, variant);
+      this.count++;
+    } else if (variant.frame !== this.frame) {
+      variant.ready = syncPhysicalDrawMaterial(source, variant.material) !== null;
+      if (variant.sourceVersion !== source.version) variant.material.needsUpdate = true;
+      variant.sourceVersion = source.version;
+      variant.frame = this.frame;
+    }
+    return variant.ready ? variant.material : source;
+  }
+
+  clear(): void {
+    for (const variants of this.sources.values()) for (const {material} of variants.values()) material.dispose();
+    this.sources.clear();
+    this.geometryKeys.clear();
+    this.count = 0;
+  }
+
+  inspect() { return {variants: this.count, limit: MAX_VARIANTS}; }
+}

package/browser/three/blender-graph-material.ts

@@ -105,6 +105,23 @@ export function setMaterialGraph(
   pendings.set(material, {binding, started: false});
 }
 
+/** A disposable draw material borrows the source's live uniform values, never
+ * its owned ramp textures or geometry-dependent UV selector. Pending graphs
+ * must first draw through their source so its asynchronous compile can finish. */
+export function borrowGraphDrawBinding(source: THREE.MeshPhysicalMaterial, target: THREE.MeshPhysicalMaterial): boolean {
+  if (pendings.has(source)) return false;
+  const sourceBinding = bindings.get(source);
+  const binding = sourceBinding && !failed.has(sourceBinding.compiled.key) ? sourceBinding : undefined;
+  const held = bindings.get(target);
+  if (!binding) {
+    if (held) { bindings.delete(target); target.needsUpdate = true; }
+  } else if (!held || held.compiled.key !== binding.compiled.key || held.uniforms !== binding.uniforms) {
+    bindings.set(target, {compiled: binding.compiled, uniforms: binding.uniforms, ramps: [], channels: {}});
+    target.needsUpdate = true;
+  }
+  return true;
+}
+
 /** A binding's values: uniforms, ramp tables and textures. */
 function fill(binding: Binding, compiled: CompiledGraph, texture: (image: CompiledGraph['images'][number]) => ImageTexture): void {
   binding.compiled = compiled;

package/browser/three/blender-ordered-batches.ts

@@ -4,15 +4,16 @@ export const ORDERED_BATCH_CAPACITY = 64;
 const FAMILY_BYTES = 4 * 1024 * 1024;
 const CACHE_BYTES = 32 * 1024 * 1024;
 const MAX_DRAWS = 1024;
-type Shape = {geometry: THREE.BufferGeometry; stamp: string};
+type Shape = {geometry: THREE.BufferGeometry; stamp: string; bytes: number};
 type Family = {material: THREE.Material; shapes: Map<number, Shape>; template: THREE.BatchedMesh | null;
-  ids: Map<number, number>; draws: THREE.BatchedMesh[]; dirty: boolean; bytes: number; refused: boolean};
+  ids: Map<number, number>; draws: THREE.BatchedMesh[]; dirty: boolean; bytes: number; reservedBytes: number; refused: boolean};
 
 /** Immutable packed attributes are shared between ordered draw runs. Only the
  * matrix/indirection textures and command lists belong to an individual run.
  * All interaction and authored geometry remain on the canonical meshes. */
 export class BlenderOrderedBatches {
   private readonly families = new Map<string, Family>();
+  private readonly partitions = new Map<string, string[]>();
   private readonly registrations = new Map<string, string | null>();
   private bytes = 0;
   private drawCount = 0;
@@ -43,16 +44,26 @@ export class BlenderOrderedBatches {
       bytes += attribute.array.byteLength;
     }
     if (bytes > FAMILY_BYTES) return null;
-    const key = `multi:${material.uuid}:${order}:${JSON.stringify(layout)}`;
+    const layoutKey = `multi:${material.uuid}:${order}:${JSON.stringify(layout)}`;
+    let keys = this.partitions.get(layoutKey);
+    if (!keys) { keys = []; this.partitions.set(layoutKey, keys); }
+    // A new compatible shape must not evict every existing run when their
+    // union exceeds one bounded allocation (notably full + navigation copies).
+    // Partition deterministically, preserving established geometry membership.
+    let key = keys.find(key => this.families.get(key)!.shapes.has(geometry.id));
+    key ??= keys.find(key => this.families.get(key)!.reservedBytes + bytes <= FAMILY_BYTES);
+    if (!key) { key = `${layoutKey}:${keys.length}`; keys.push(key); }
     let family = this.families.get(key);
     if (!family) {
-      family = {material, shapes: new Map(), template: null, ids: new Map(), draws: [], dirty: true, bytes: 0, refused: false};
+      family = {material, shapes: new Map(), template: null, ids: new Map(), draws: [], dirty: true,
+        bytes: 0, reservedBytes: 0, refused: false};
       this.families.set(key, family);
     }
     const stamp = JSON.stringify(versions);
     const held = family.shapes.get(geometry.id);
     if (!held || held.stamp !== stamp) {
-      family.shapes.set(geometry.id, {geometry, stamp});
+      family.reservedBytes += bytes - (held?.bytes ?? 0);
+      family.shapes.set(geometry.id, {geometry, stamp, bytes});
       family.dirty = true;
     }
     this.registrations.set(registration, key);
@@ -150,6 +161,7 @@ export class BlenderOrderedBatches {
   clear(): void {
     for (const family of this.families.values()) this.release(family);
     this.families.clear();
+    this.partitions.clear();
     this.registrations.clear();
     this.pending = false;
   }

package/browser/three/blender-physical-material.ts

@@ -4,7 +4,7 @@
  * that MeshPhysicalMaterial does not expose as properties. */
 import * as THREE from 'three';
 import {z} from 'zod';
-import {applyGraphShader, bindGraphDraw, graphProgramKey, graphUvChannels, setGraphViewport} from './blender-graph-material';
+import {applyGraphShader, bindGraphDraw, borrowGraphDrawBinding, graphProgramKey, graphUvChannels, setGraphViewport} from './blender-graph-material';
 import {bindNamedUvChannels} from './blender-texture-samplers';
 
 const scalar = z.number().finite();
@@ -56,6 +56,27 @@ function graphShadow(material: THREE.MeshPhysicalMaterial): THREE.MeshPhysicalMa
   return shadow;
 }
 
+/** Copy physical values into an independently cached draw form. Textures and
+ * graph uniform values remain borrowed from the authoritative source material. */
+export function syncPhysicalDrawMaterial(source: THREE.Material, target?: THREE.MeshPhysicalMaterial): THREE.MeshPhysicalMaterial | null {
+  if (!(source instanceof THREE.MeshPhysicalMaterial) || !uniforms.has(source)) return null;
+  const copy = target ?? graphShadow(source);
+  if (!borrowGraphDrawBinding(source, copy)) {
+    if (!target) copy.dispose();
+    return null;
+  }
+  copy.copy(source);
+  const held = uniforms.get(source)!;
+  const values = uniforms.get(copy)!;
+  values.blenderCoatIor.value = held.blenderCoatIor.value;
+  values.blenderCoatTint.value.copy(held.blenderCoatTint.value);
+  values.blenderMapClip.value = held.blenderMapClip.value;
+  values.blenderRoughnessClip.value = held.blenderRoughnessClip.value;
+  values.blenderNormalClip.value = held.blenderNormalClip.value;
+  values.blenderWorldExtinction.value.copy(held.blenderWorldExtinction.value);
+  return copy;
+}
+
 export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, input?: Physical,
   clips: {map?: boolean; roughness?: boolean; normal?: boolean} = {}): void {
   const data = input ?? defaults;

package/browser/three/blender-runtime-view.ts

@@ -43,7 +43,6 @@ import {
 } from './blender-runtime-camera-view';
 import { DEFAULT_VIEWPORT_DISPLAY, workbenchMaterial } from './blender-workbench-material';
 import { BlenderRuntimeInstances } from './blender-runtime-instances';
-import { BlenderDepthInstances } from './blender-depth-instances';
 import { BlenderTransparentInstances } from './blender-transparent-instances';
 import { BlenderMaterialRanges } from './blender-material-ranges';
 import { BlenderMotionGeometry } from './blender-motion-geometry';
@@ -646,7 +645,6 @@ export interface PhotographRecord {
 export class BlenderRuntimeView {
   readonly root = new THREE.Group();
   private readonly instances = new BlenderRuntimeInstances(this.root);
-  private readonly depthInstances = new BlenderDepthInstances(this.root);
   private readonly materialRanges = new BlenderMaterialRanges();
   private readonly transparentInstances = new BlenderTransparentInstances(this.root);
   private readonly motionGeometry = new BlenderMotionGeometry(presenterChanged);
@@ -1233,7 +1231,6 @@ export class BlenderRuntimeView {
   }
 
   private rebuildInstances(): void {
-    this.depthInstances.setObjects(this.drawBatching && !this.rendered ? this.objects.values() : []);
     this.transparentInstances.clear();
     this.instances.rebuild(this.objects.values(), this.drawBatching && !this.rendered);
     if (this.drawBatching && !this.rendered) this.transparentInstances.setObjects(this.objects.values());
@@ -1292,15 +1289,6 @@ export class BlenderRuntimeView {
     };
   }
 
-  prepareDepthDraw(camera: THREE.Camera, material: THREE.MeshDepthMaterial): void | (() => void) {
-    if (!this.drawBatching || this.rendered || !this.depthInstances.supports(material)) return;
-    const resumeColor = this.transparentInstances.suspendDraw();
-    const restore = () => { try { this.depthInstances.finish(); } finally { resumeColor(); } };
-    try { this.depthInstances.prepare(camera, material); }
-    catch (error) { restore(); throw error; }
-    return restore;
-  }
-
   private workbenchFor(id: string | null, side: THREE.Side, used: Set<string>): THREE.Material {
     const display = (id !== null ? this.frame?.materials[id]?.viewport : undefined) ?? DEFAULT_VIEWPORT_DISPLAY;
     const key = `${display.color.join(',')}|${display.roughness}|${display.metallic}|${side}`;
@@ -2106,7 +2094,7 @@ export class BlenderRuntimeView {
   }
 
   drawStatistics() {
-    return {enabled: this.drawBatching, preparation: {...this.drawPreparation}, depth: this.depthInstances.inspect(), materialRanges: this.materialRanges.inspect(), opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect(), motion: this.motionGeometry.inspect()};
+    return {enabled: this.drawBatching, preparation: {...this.drawPreparation}, materialRanges: this.materialRanges.inspect(), opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect(), motion: this.motionGeometry.inspect()};
   }
 
   snapshot() {
@@ -2316,7 +2304,6 @@ export class BlenderRuntimeView {
   }
 
   private clear() {
-    this.depthInstances.clear();
     this.materialRanges.clear();
     this.motionGeometry.clear();
     this.transparentInstances.clear();

package/browser/three/blender-transparent-instances.ts

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import {BlenderOrderedBatches, ORDERED_BATCH_CAPACITY} from './blender-ordered-batches';
+import {BlenderDrawMaterials} from './blender-draw-materials';
 import {presenterChanged} from './blender-presenter-change';
 import {graphDrawAttributes} from './blender-graph-material';
 import {instanceMatrixSupported, instanceObjectShown} from './blender-runtime-instances';
@@ -21,6 +22,7 @@ function groupOrder(mesh: THREE.Object3D): number {
  * This does not turn blended foliage into cutouts or change its opacity. */
 export class BlenderTransparentInstances {
   private objects: THREE.Mesh[] = [];
+  private readonly drawMaterials = new BlenderDrawMaterials();
   private readonly ordered = new BlenderOrderedBatches();
   private readonly mixedDraws = new Map<THREE.BatchedMesh, Draw>();
   private multiDraw = false;
@@ -35,6 +37,8 @@ export class BlenderTransparentInstances {
   private batches = 0;
   private instances = 0;
   private excluded: Record<string, number> = {};
+  private readonly plannedProjection = new THREE.Matrix4();
+  private projectionKnown = false;
   private readonly planState: (number | string)[] = [];
   private readonly planned: Draw[] = [];
   private stateIndex = 0;
@@ -49,6 +53,7 @@ export class BlenderTransparentInstances {
 
   prepare(camera: THREE.Camera, multiDraw = false): void {
     this.finishDraw();
+    this.drawMaterials.begin();
     if (!this.objects.length) return;
     camera.updateMatrixWorld();
     this.projection.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
@@ -61,6 +66,8 @@ export class BlenderTransparentInstances {
       // a camera move, drag, visibility or material change rebuilds it below.
       for (const draw of this.planned) {
         draw.mesh.visible = true;
+        const source = draw.members[0]!.material;
+        draw.mesh.material = this.drawMaterials.get(Array.isArray(source) ? source[0]! : source, draw.mesh);
         for (const member of draw.members) {
           member.layers.disable(0);
           this.hidden.push(member);
@@ -209,6 +216,7 @@ export class BlenderTransparentInstances {
             pool.push(draw);
             this.root.add(mesh);
           }
+          draw.mesh.material = this.drawMaterials.get(first.material!, draw.mesh);
           draw.mesh.visible = true;
           draw.mesh.renderOrder = head.mesh.renderOrder;
           draw.mesh.boundingSphere!.center.copy(head.centre).applyMatrix4(this.inverse);
@@ -243,7 +251,7 @@ export class BlenderTransparentInstances {
     if (this.ordered.pending) queueMicrotask(presenterChanged);
   }
 
-  inspect() { return {batches: this.batches, instances: this.instances, excluded: {...this.excluded}, multiDraw: this.ordered.inspect()}; }
+  inspect() { return {batches: this.batches, instances: this.instances, excluded: {...this.excluded}, multiDraw: this.ordered.inspect(), materials: this.drawMaterials.inspect()}; }
 
   private observe(value: number | string): void {
     if (this.planState[this.stateIndex] !== value) {
@@ -256,6 +264,15 @@ export class BlenderTransparentInstances {
   /** Compare inputs without cloning 10,000 centres, allocating entries or
    * sorting/uploading matrices again on an unchanged frame. No lossy hash. */
   private planChanged(camera: THREE.Camera): boolean {
+    // A moved camera already invalidates culling and ordering. Do not first
+    // compare every object's attributes/matrix only to rebuild the same list.
+    // Invalidate the saved inputs; the first quiet frame records them afresh.
+    if (!this.projectionKnown || !this.plannedProjection.equals(this.projection)) {
+      this.plannedProjection.copy(this.projection);
+      this.projectionKnown = true;
+      this.planState.length = 0;
+      return true;
+    }
     this.stateIndex = 0;
     this.stateChanged = this.planState.length === 0;
     this.observe(camera.layers.mask);
@@ -318,19 +335,6 @@ export class BlenderTransparentInstances {
     this.observe((material as THREE.MeshPhysicalMaterial).transmission ?? 0);
   }
 
-  /** A plain depth override does not need color transparency ordering. Reveal
-   * only this plan's canonical members, retaining exact masks for restoration. */
-  suspendDraw(): () => void {
-    const members = this.hidden.map(mesh => ({mesh, mask: mesh.layers.mask}));
-    const draws = this.planned.map(({mesh}) => ({mesh, visible: mesh.visible}));
-    for (const {mesh} of members) mesh.layers.enable(0);
-    for (const {mesh} of draws) mesh.visible = false;
-    return () => {
-      for (const {mesh, mask} of members) mesh.layers.mask = mask;
-      for (const {mesh, visible} of draws) mesh.visible = visible;
-    };
-  }
-
   finishDraw(): void {
     for (const mesh of this.hidden) mesh.layers.enable(0);
     this.hidden.length = 0;
@@ -346,9 +350,11 @@ export class BlenderTransparentInstances {
     }
     this.pools.clear();
     this.ordered.clear();
+    this.drawMaterials.clear();
     this.mixedDraws.clear();
     this.planned.length = 0;
     this.planState.length = 0;
+    this.projectionKnown = false;
     this.objects = [];
     this.batches = this.instances = 0;
   }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/blender-engine",
   "author": "Volter AI, Inc.",
   "license": "GPL-3.0-or-later",
-  "version": "0.1.81",
+  "version": "0.1.83",
   "publishConfig": {
     "access": "public"
   },

package/browser/three/blender-depth-instances.ts

@@ -1,139 +0,0 @@
-import * as THREE from 'three';
-import {instanceMatrixSupported, instanceObjectShown} from './blender-runtime-instances';
-
-const CAPACITY = 64;
-const MAX_DRAWS = 1024; // At most 4 MiB of instance matrices; no vertex copies.
-
-/** Opaque depth overrides discard authored color materials. Geometry-compatible
- * objects can share a draw here even when their color draws cannot be reordered.
- * Only the current pass changes; selection layers and canonical meshes survive. */
-export class BlenderDepthInstances {
-  private objects: THREE.Mesh[] = [];
-  private readonly pools = new Map<THREE.BufferGeometry, THREE.InstancedMesh[]>();
-  private readonly hidden: {mesh: THREE.Mesh; mask: number}[] = [];
-  private readonly active: THREE.InstancedMesh[] = [];
-  private readonly inverse = new THREE.Matrix4();
-  private readonly matrix = new THREE.Matrix4();
-  private readonly projection = new THREE.Matrix4();
-  private readonly frustum = new THREE.Frustum();
-  private allocated = 0;
-  private statistics = {batches: 0, instances: 0, preparationMs: 0};
-
-  constructor(private readonly root: THREE.Group) {}
-
-  supports(material: THREE.MeshDepthMaterial): boolean {
-    return material.isMeshDepthMaterial && material.visible && !material.transparent &&
-      !material.map && !material.alphaMap && !material.displacementMap &&
-      !material.alphaHash && material.alphaTest === 0 && !material.wireframe &&
-      !material.stencilWrite && material.depthWrite && material.depthTest &&
-      !material.clippingPlanes?.length && !material.polygonOffset &&
-      (material.depthFunc === THREE.LessDepth || material.depthFunc === THREE.LessEqualDepth) &&
-      (material.blending === THREE.NormalBlending || material.blending === THREE.NoBlending) &&
-      material.onBeforeCompile === THREE.Material.prototype.onBeforeCompile &&
-      material.onBeforeRender === THREE.Material.prototype.onBeforeRender;
-  }
-
-  setObjects(objects: Iterable<THREE.Object3D>): void {
-    this.clear();
-    this.objects = [...objects].filter((object): object is THREE.Mesh => (object as THREE.Mesh).isMesh === true);
-  }
-
-  prepare(camera: THREE.Camera, material: THREE.MeshDepthMaterial): void {
-    this.finish();
-    const start = performance.now();
-    this.statistics = {batches: 0, instances: 0, preparationMs: 0};
-    if (!camera.layers.isEnabled(0)) return;
-    this.inverse.copy(this.root.matrixWorld).invert();
-    this.projection.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-    this.frustum.setFromProjectionMatrix(this.projection);
-    const groups = new Map<THREE.BufferGeometry, THREE.Mesh[]>();
-    for (const mesh of this.objects) {
-      // A selected object has a separate mask layer, and the outline pass also
-      // disables its default layer. Never pull it into the occluder draw.
-      if (mesh.layers.mask !== 1 || !instanceObjectShown(mesh) ||
-          (mesh as THREE.SkinnedMesh).isSkinnedMesh ||
-          (mesh as THREE.InstancedMesh).isInstancedMesh ||
-          (mesh as THREE.BatchedMesh).isBatchedMesh || mesh.morphTargetInfluences ||
-          mesh.onBeforeRender !== THREE.Object3D.prototype.onBeforeRender ||
-          mesh.onAfterRender !== THREE.Object3D.prototype.onAfterRender) continue;
-      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
-      if (materials.length !== 1 || !materials[0]?.visible) continue;
-      const geometry = mesh.geometry;
-      const count = geometry.index?.count ?? geometry.getAttribute('position')?.count ?? 0;
-      if (!count || (Array.isArray(mesh.material) && !(geometry.groups.length === 1 &&
-          geometry.groups[0]!.start === 0 && geometry.groups[0]!.count === count &&
-          geometry.groups[0]!.materialIndex === 0))) continue;
-      if (mesh.frustumCulled && !this.frustum.intersectsObject(mesh)) continue;
-      this.matrix.multiplyMatrices(this.inverse, mesh.matrixWorld);
-      if (!instanceMatrixSupported(this.matrix)) continue;
-      const group = groups.get(geometry);
-      if (group) group.push(mesh); else groups.set(geometry, [mesh]);
-    }
-    // Do not retain pools for obsolete LOD/canonical geometry indefinitely.
-    for (const [geometry, pool] of this.pools) if (!groups.has(geometry)) {
-      for (const draw of pool) { draw.removeFromParent(); draw.dispose(); this.allocated--; }
-      this.pools.delete(geometry);
-    }
-    for (const [geometry, members] of groups) {
-      if (members.length < 2) continue;
-      let pool = this.pools.get(geometry);
-      if (!pool) { pool = []; this.pools.set(geometry, pool); }
-      for (let offset = 0; offset < members.length; offset += CAPACITY) {
-        const count = Math.min(CAPACITY, members.length - offset);
-        if (count < 2) continue;
-        const slot = offset / CAPACITY;
-        let draw = pool[slot];
-        if (!draw) {
-          if (this.allocated >= MAX_DRAWS) continue;
-          draw = new THREE.InstancedMesh(geometry, material, CAPACITY);
-          draw.name = 'Blender depth instances';
-          draw.userData['engineInternal'] = true;
-          draw.matrixAutoUpdate = false;
-          draw.frustumCulled = false; // Members were individually culled above.
-          draw.boundingSphere = new THREE.Sphere();
-          draw.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-          draw.raycast = () => {};
-          this.root.add(draw);
-          pool.push(draw);
-          this.allocated++;
-        }
-        draw.material = material;
-        draw.matrixWorld.copy(this.root.matrixWorld);
-        draw.count = count;
-        draw.visible = true;
-        this.active.push(draw);
-        for (let i = 0; i < count; i++) {
-          const mesh = members[offset + i]!;
-          this.matrix.multiplyMatrices(this.inverse, mesh.matrixWorld);
-          draw.setMatrixAt(i, this.matrix);
-          this.hidden.push({mesh, mask: mesh.layers.mask});
-          mesh.layers.disable(0);
-        }
-        draw.instanceMatrix.needsUpdate = true;
-        this.statistics.batches++;
-        this.statistics.instances += count;
-      }
-    }
-    this.statistics.preparationMs = performance.now() - start;
-  }
-
-  finish(): void {
-    for (const {mesh, mask} of this.hidden) mesh.layers.mask = mask;
-    this.hidden.length = 0;
-    for (const draw of this.active) draw.visible = false;
-    this.active.length = 0;
-  }
-
-  clear(): void {
-    this.finish();
-    for (const pool of this.pools.values()) for (const draw of pool) {
-      draw.removeFromParent();
-      draw.dispose(); // Shared geometry and override material belong to callers.
-    }
-    this.pools.clear();
-    this.objects = [];
-    this.allocated = 0;
-  }
-
-  inspect() { return {...this.statistics, allocated: this.allocated}; }
-}