@volter/blender-engine 0.1.81 → 0.1.82

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-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

@@ -318,19 +318,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;

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.82",
   "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}; }
-}