@volter/blender-engine 0.1.68 → 0.1.69

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

@@ -43,6 +43,9 @@ export class BlenderRuntimeInstances {
   private readonly inverse = new THREE.Matrix4();
   private readonly matrix = new THREE.Matrix4();
   private readonly box = new THREE.Box3();
+  private readonly projection = new THREE.Matrix4();
+  private readonly frustum = new THREE.Frustum();
+  private camera: THREE.Camera | null = null;
   private eligible = 0;
   private excluded: Record<string, number> = {};
 
@@ -137,6 +140,10 @@ export class BlenderRuntimeInstances {
         }
         mesh.layers.mask &= ~member.layers;
         if (!instanceObjectShown(mesh)) continue;
+        // Aggregate batch bounds alone admit off-screen members. Retain the
+        // same per-object rejection as ordinary draws before compacting slots.
+        if (this.camera && (!this.camera.layers.isEnabled(0) ||
+            (mesh.frustumCulled && !this.frustum.intersectsObject(mesh)))) continue;
         const offset = count * 16;
         if (this.matrix.elements.some((value, i) => Math.fround(value) !== draw.instanceMatrix.array[offset + i])) {
           draw.setMatrixAt(count, this.matrix);
@@ -154,7 +161,17 @@ export class BlenderRuntimeInstances {
     }
   }
 
+  prepareDraw(camera: THREE.Camera): void {
+    camera.updateMatrixWorld();
+    this.camera = camera;
+    this.projection.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+    this.frustum.setFromProjectionMatrix(this.projection);
+  }
+
+  finishDraw(): void { this.camera = null; }
+
   clear(): void {
+    this.camera = null;
     for (const {draw, members} of this.batches) {
       for (const {mesh, layers} of members) mesh.layers.mask |= layers;
       draw.removeFromParent();

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

@@ -644,6 +644,7 @@ export class BlenderRuntimeView {
   readonly root = new THREE.Group();
   private readonly instances = new BlenderRuntimeInstances(this.root);
   private readonly transparentInstances = new BlenderTransparentInstances(this.root);
+  private drawBatching = true;
   private readonly objects = new Map<string, THREE.Object3D>();
   private readonly meshes = new Map<
     string,
@@ -1227,21 +1228,34 @@ export class BlenderRuntimeView {
 
   private rebuildInstances(): void {
     this.transparentInstances.clear();
-    this.instances.rebuild(this.objects.values(), !this.rendered);
-    if (!this.rendered) this.transparentInstances.setObjects(this.objects.values());
+    this.instances.rebuild(this.objects.values(), this.drawBatching && !this.rendered);
+    if (this.drawBatching && !this.rendered) this.transparentInstances.setObjects(this.objects.values());
+  }
+
+  /** Presentation-only comparison door; never changes Blender or its data. */
+  setDrawBatching(enabled: boolean): void {
+    if (enabled === this.drawBatching) return;
+    this.drawBatching = enabled;
+    this.rebuildInstances();
+    presenterChanged();
   }
 
   /** Before the renderer uploads attributes/builds its queues, for this area's
    * actual camera. Transparent instance runs are camera-order dependent. */
   prepareDraw(camera: THREE.Camera): () => void {
-    this.root.updateMatrixWorld(true);
     try {
+      this.instances.prepareDraw(camera);
+      this.root.updateMatrixWorld(true);
       this.transparentInstances.prepare(camera);
     } catch (error) {
+      this.instances.finishDraw();
       this.transparentInstances.finishDraw();
       throw error;
     }
-    return () => this.transparentInstances.finishDraw();
+    return () => {
+      this.instances.finishDraw();
+      this.transparentInstances.finishDraw();
+    };
   }
 
   private workbenchFor(id: string | null, side: THREE.Side, used: Set<string>): THREE.Material {
@@ -2049,7 +2063,7 @@ export class BlenderRuntimeView {
   }
 
   drawStatistics() {
-    return {opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect()};
+    return {enabled: this.drawBatching, opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect()};
   }
 
   snapshot() {

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

@@ -3,9 +3,15 @@ import {graphDrawAttributes} from './blender-graph-material';
 import {instanceMatrixSupported, instanceObjectShown} from './blender-runtime-instances';
 
 const CAPACITY = 64;
-type Entry = {mesh: THREE.Mesh; material: THREE.Material | null; key: string | null; z: number; centre: THREE.Vector3};
+type Entry = {mesh: THREE.Mesh; material: THREE.Material | null; key: string | null; groupOrder: number; z: number; centre: THREE.Vector3};
 type Draw = {mesh: THREE.InstancedMesh; members: THREE.Mesh[]};
 
+function groupOrder(mesh: THREE.Object3D): number {
+  for (let parent = mesh.parent; parent; parent = parent.parent)
+    if ((parent as THREE.Group).isGroup) return parent.renderOrder;
+  return 0;
+}
+
 /** Preserve Three's transparent object order. An instance run may contain only
  * consecutive, compatible, single-pass surfaces in that order. Incompatible
  * surfaces remain barriers; ties at a run boundary stay ordinary draws because
@@ -23,6 +29,10 @@ export class BlenderTransparentInstances {
   private readonly depth = new THREE.Vector4();
   private batches = 0;
   private instances = 0;
+  private readonly planState: (number | string)[] = [];
+  private readonly planned: Draw[] = [];
+  private stateIndex = 0;
+  private stateChanged = false;
 
   constructor(private readonly root: THREE.Group) {}
 
@@ -32,16 +42,29 @@ export class BlenderTransparentInstances {
   }
 
   prepare(camera: THREE.Camera): void {
-    for (const mesh of this.hidden) mesh.layers.enable(0);
-    this.hidden.length = 0;
+    this.finishDraw();
+    if (!this.objects.length) return;
+    camera.updateMatrixWorld();
+    this.projection.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+    if (!this.planChanged(camera)) {
+      // The draw plan is a disposable presentation, not evaluated scene data.
+      // Reuse only after exact comparison of every input to culling/ordering;
+      // a camera move, drag, visibility or material change rebuilds it below.
+      for (const draw of this.planned) {
+        draw.mesh.visible = true;
+        for (const member of draw.members) {
+          member.layers.disable(0);
+          this.hidden.push(member);
+        }
+      }
+      return;
+    }
+    this.planned.length = 0;
     for (const pool of this.pools.values()) for (const draw of pool) {
       draw.mesh.visible = false;
       draw.members.length = 0;
     }
     this.batches = this.instances = 0;
-    if (!this.objects.length) return;
-    camera.updateMatrixWorld();
-    this.projection.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
     this.frustum.setFromProjectionMatrix(this.projection);
     this.inverse.copy(this.root.matrixWorld).invert();
     const entries: Entry[] = [];
@@ -68,12 +91,14 @@ export class BlenderTransparentInstances {
       let material: THREE.Material | null = null;
       let key: string | null = null;
       const candidate = materials.length === 1 ? materials[0]! : null;
+      const order = groupOrder(mesh);
       if (candidate && candidate.visible && candidate.transparent &&
           !(candidate as THREE.ShaderMaterial).isShaderMaterial &&
           !((candidate as THREE.MeshPhysicalMaterial).transmission > 0) &&
           (candidate.side !== THREE.DoubleSide || candidate.forceSinglePass) &&
           !(mesh as THREE.SkinnedMesh).isSkinnedMesh && !mesh.morphTargetInfluences &&
-          !(mesh as THREE.InstancedMesh).isInstancedMesh && mesh.layers.mask === 1) {
+          !(mesh as THREE.InstancedMesh).isInstancedMesh && mesh.layers.mask === 1 &&
+          order === this.root.renderOrder) {
         const geometry = mesh.geometry;
         // A single material draws the whole geometry. An array does so only
         // when its sole group covers the same range; preserve all other cases.
@@ -93,9 +118,9 @@ export class BlenderTransparentInstances {
           key = groupKey;
         }
       }
-      entries.push({mesh, material, key, z, centre});
+      entries.push({mesh, material, key, groupOrder: order, z, centre});
     }
-    entries.sort((a, b) => a.mesh.renderOrder - b.mesh.renderOrder || b.z - a.z || a.mesh.id - b.mesh.id);
+    entries.sort((a, b) => a.groupOrder - b.groupOrder || a.mesh.renderOrder - b.mesh.renderOrder || b.z - a.z || a.mesh.id - b.mesh.id);
     const used = new Map<string, number>();
     for (let begin = 0; begin < entries.length;) {
       const first = entries[begin]!;
@@ -155,6 +180,7 @@ export class BlenderTransparentInstances {
           }
           draw.mesh.count = length;
           draw.mesh.instanceMatrix.needsUpdate = true;
+          this.planned.push(draw);
           this.batches++;
           this.instances += length;
         }
@@ -165,6 +191,60 @@ export class BlenderTransparentInstances {
 
   inspect() { return {batches: this.batches, instances: this.instances}; }
 
+  private observe(value: number | string): void {
+    if (this.planState[this.stateIndex] !== value) {
+      this.planState[this.stateIndex] = value;
+      this.stateChanged = true;
+    }
+    this.stateIndex++;
+  }
+
+  /** 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 {
+    this.stateIndex = 0;
+    this.stateChanged = this.planState.length === 0;
+    this.observe(camera.layers.mask);
+    for (const n of this.projection.elements) this.observe(n);
+    for (const n of this.root.matrixWorld.elements) this.observe(n);
+    for (const mesh of this.objects) {
+      this.observe(mesh.parent?.id ?? -1);
+      this.observe(instanceObjectShown(mesh) ? 1 : 0);
+      this.observe(mesh.layers.mask);
+      this.observe(mesh.renderOrder);
+      this.observe(groupOrder(mesh));
+      this.observe(mesh.frustumCulled ? 1 : 0);
+      this.observe(mesh.morphTargetInfluences ? 1 : 0);
+      for (const n of mesh.matrixWorld.elements) this.observe(n);
+      const geometry = mesh.geometry;
+      this.observe(geometry.id);
+      this.observe(geometry.drawRange.start);
+      this.observe(geometry.drawRange.count);
+      this.observe(geometry.index?.count ?? geometry.getAttribute('position').count);
+      this.observe(geometry.groups.length);
+      for (const group of geometry.groups) {
+        this.observe(group.start); this.observe(group.count); this.observe(group.materialIndex ?? 0);
+      }
+      const sphere = (mesh as THREE.Mesh & {boundingSphere?: THREE.Sphere | null}).boundingSphere ?? geometry.boundingSphere;
+      this.observe(sphere?.center.x ?? 0); this.observe(sphere?.center.y ?? 0);
+      this.observe(sphere?.center.z ?? 0); this.observe(sphere?.radius ?? -1);
+      const materials = Array.isArray(mesh.material) ? mesh.material : null;
+      this.observe(materials?.length ?? -1);
+      if (materials) for (const material of materials) this.observeMaterial(material);
+      else this.observeMaterial(mesh.material as THREE.Material);
+    }
+    this.stateChanged ||= this.planState.length !== this.stateIndex;
+    this.planState.length = this.stateIndex;
+    return this.stateChanged;
+  }
+
+  private observeMaterial(material: THREE.Material): void {
+    this.observe(material.uuid); this.observe(material.version);
+    this.observe(material.visible ? 1 : 0); this.observe(material.transparent ? 1 : 0);
+    this.observe(material.side); this.observe(material.forceSinglePass ? 1 : 0);
+    this.observe((material as THREE.MeshPhysicalMaterial).transmission ?? 0);
+  }
+
   finishDraw(): void {
     for (const mesh of this.hidden) mesh.layers.enable(0);
     this.hidden.length = 0;
@@ -178,6 +258,8 @@ export class BlenderTransparentInstances {
       mesh.dispose();
     }
     this.pools.clear();
+    this.planned.length = 0;
+    this.planState.length = 0;
     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.68",
+  "version": "0.1.69",
   "publishConfig": {
     "access": "public"
   },