@volter/blender-engine 0.1.78 → 0.1.80

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

@@ -0,0 +1,100 @@
+import * as THREE from 'three';
+
+const CACHE_BYTES = 8 * 1024 * 1024;
+type Copy = {geometry: THREE.BufferGeometry; signature: string; bytes: number; before: number; after: number};
+
+/** Three sorts opaque groups by material id before drawing. Consolidate the
+ * ranges that are already consecutive in that render order, preserving index
+ * order inside each material. No transparency, vertices or authored slots change. */
+export class BlenderMaterialRanges {
+  private objects: THREE.Mesh[] = [];
+  private readonly copies = new Map<string, Copy>();
+  private readonly swapped: {mesh: THREE.Mesh; geometry: THREE.BufferGeometry}[] = [];
+  private bytes = 0;
+  private savedDraws = 0;
+
+  setObjects(objects: Iterable<THREE.Object3D>): void {
+    this.clear();
+    this.objects = [...objects].filter((o): o is THREE.Mesh => (o as THREE.Mesh).isMesh === true);
+  }
+
+  prepare(): void {
+    this.savedDraws = 0;
+    for (const mesh of this.objects) {
+      const source = mesh.geometry;
+      const materials = mesh.material;
+      if (mesh.layers.mask === 0 || !Array.isArray(materials) || source.groups.length < 8 || !source.index ||
+          (mesh as THREE.SkinnedMesh).isSkinnedMesh || (mesh as THREE.InstancedMesh).isInstancedMesh ||
+          mesh.morphTargetInfluences || Object.keys(source.morphAttributes).length ||
+          source.drawRange.start !== 0 || source.drawRange.count < source.index.count ||
+          materials.some(m => m.transparent || (m as THREE.MeshPhysicalMaterial).transmission > 0 ||
+            (m as THREE.ShaderMaterial).isShaderMaterial)) continue;
+      const signature = JSON.stringify([source.id, source.index.id, source.index.version,
+        materials.map(m => m.uuid), source.groups,
+        Object.entries(source.attributes).map(([name, a]) => [name, (a as THREE.BufferAttribute).id])]);
+      let copy = this.copies.get(signature);
+      if (!copy) {
+        // Partial/overlapping/out-of-order ranges have independent semantics;
+        // retain them verbatim instead of inferring missing triangles.
+        let end = 0, valid = true;
+        const grouped = new Map<string, {slot: number; groups: THREE.BufferGeometry['groups']}>();
+        for (const group of source.groups) {
+          const slot = group.materialIndex ?? 0;
+          const material = materials[slot];
+          if (!material || group.start !== end || group.count <= 0 || group.count % 3 !== 0) { valid = false; break; }
+          end += group.count;
+          const entry = grouped.get(material.uuid);
+          if (entry) entry.groups.push(group);
+          else grouped.set(material.uuid, {slot, groups: [group]});
+        }
+        if (!valid || end !== source.index.count || grouped.size >= source.groups.length) continue;
+        const bytes = source.index.array.byteLength;
+        if (this.bytes + bytes > CACHE_BYTES) continue;
+        const geometry = new THREE.BufferGeometry();
+        for (const [name, attribute] of Object.entries(source.attributes)) geometry.setAttribute(name, attribute);
+        const index = source.index.clone();
+        let offset = 0;
+        for (const entry of grouped.values()) {
+          const start = offset;
+          for (const group of entry.groups) {
+            index.array.set(source.index.array.subarray(group.start, group.start + group.count), offset);
+            offset += group.count;
+          }
+          geometry.addGroup(start, offset - start, entry.slot);
+        }
+        geometry.setIndex(index);
+        geometry.boundingBox = source.boundingBox?.clone() ?? null;
+        geometry.boundingSphere = source.boundingSphere?.clone() ?? null;
+        geometry.userData = {...source.userData};
+        copy = {geometry, signature, bytes, before: source.groups.length, after: grouped.size};
+        this.copies.set(signature, copy);
+        this.bytes += bytes;
+      }
+      this.swapped.push({mesh, geometry: source});
+      mesh.geometry = copy.geometry;
+      this.savedDraws += copy.before - copy.after;
+    }
+  }
+
+  finish(): void {
+    for (const {mesh, geometry} of this.swapped) mesh.geometry = geometry;
+    this.swapped.length = 0;
+  }
+
+  inspect() { return {copies: this.copies.size, bytes: this.bytes, savedRanges: this.savedDraws}; }
+
+  private release(copy: Copy): void {
+    // Only the reordered index is owned; vertex attributes stay canonical.
+    for (const name of Object.keys(copy.geometry.attributes)) copy.geometry.deleteAttribute(name);
+    copy.geometry.dispose();
+    this.bytes -= copy.bytes;
+  }
+
+  clear(): void {
+    this.finish();
+    for (const copy of this.copies.values()) this.release(copy);
+    this.copies.clear();
+    this.objects = [];
+    this.savedDraws = 0;
+  }
+}

package/browser/three/blender-motion-geometry.ts

@@ -38,6 +38,9 @@ export class BlenderMotionGeometry {
   private readonly projection = new THREE.Matrix4();
   private readonly frustum = new THREE.Frustum();
   private readonly centre = new THREE.Vector3();
+  private readonly boxCentre = new THREE.Vector3();
+  private readonly halfExtent = new THREE.Vector3();
+  private readonly viewWorld = new THREE.Matrix4();
   private drawnMeshes = 0;
   private fullTriangles = 0;
   private motionTriangles = 0;
@@ -304,13 +307,19 @@ export class BlenderMotionGeometry {
     this.frustum.setFromProjectionMatrix(this.projection);
     let tooClose = 0;
     for (const [source, entry] of this.cache) {
+      // The copy carries the ORIGINAL bounds derived during its yielding
+      // build. Do not scan vertices or use the smaller simplified bounds.
+      const bounds = entry.geometry.boundingBox!;
+      bounds.getSize(this.halfExtent).multiplyScalar(0.5);
       for (const mesh of this.groups.get(source) ?? []) {
         if (!instanceObjectShown(mesh) || (mesh.frustumCulled && !this.frustum.intersectsObject(mesh))) continue;
         // Bound the largest singular value by the maximum absolute row sum
         // of AᵀA. Unlike Frobenius this is tight for orthogonal TRS columns,
         // while still bounding shear. A uniform rotation must not inflate
         // both error and radius by sqrt(3) and veto nearby placements.
-        const e = mesh.matrixWorld.elements;
+        // Bound in view space, also accounting for an explicitly scaled camera.
+        this.viewWorld.multiplyMatrices(camera.matrixWorldInverse, mesh.matrixWorld);
+        const e = this.viewWorld.elements;
         const x2 = e[0]! ** 2 + e[1]! ** 2 + e[2]! ** 2;
         const y2 = e[4]! ** 2 + e[5]! ** 2 + e[6]! ** 2;
         const z2 = e[8]! ** 2 + e[9]! ** 2 + e[10]! ** 2;
@@ -319,9 +328,20 @@ export class BlenderMotionGeometry {
         const yz = Math.abs(e[4]! * e[8]! + e[5]! * e[9]! + e[6]! * e[10]!);
         const scale = Math.sqrt(Math.max(x2 + xy + xz, y2 + xy + yz, z2 + xz + yz));
         const sphere = source.boundingSphere!;
-        this.centre.copy(sphere.center).applyMatrix4(mesh.matrixWorld).applyMatrix4(camera.matrixWorldInverse);
-        const depth = (camera as THREE.PerspectiveCamera).isPerspectiveCamera
-          ? -this.centre.z - sphere.radius * scale : 1;
+        this.centre.copy(sphere.center).applyMatrix4(this.viewWorld);
+        let depth = 1;
+        if ((camera as THREE.PerspectiveCamera).isPerspectiveCamera) {
+          const sphereDepth = -this.centre.z - sphere.radius * scale;
+          bounds.getCenter(this.boxCentre).applyMatrix4(this.viewWorld);
+          const v = this.viewWorld.elements;
+          const radiusZ = Math.abs(v[2]!) * this.halfExtent.x +
+            Math.abs(v[6]!) * this.halfExtent.y + Math.abs(v[10]!) * this.halfExtent.z;
+          // Both enclosures contain every original vertex. Their nearest
+          // depths are lower bounds, so the larger remains a lower bound.
+          // A tall shape's height need not inflate its radius toward a level
+          // camera. This tightens the bound without relaxing the pixel gate.
+          depth = Math.max(sphereDepth, -this.boxCentre.z - radiusZ);
+        }
         const pixels = entry.error * scale * Math.abs(camera.projectionMatrix.elements[5]!) * height / (2 * depth);
         if (!(depth > 0) || pixels > 1) { tooClose++; continue; }
         // Decide per placement: one near-camera blade must not veto thousands

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

@@ -44,6 +44,7 @@ import {
 import { DEFAULT_VIEWPORT_DISPLAY, workbenchMaterial } from './blender-workbench-material';
 import { BlenderRuntimeInstances } from './blender-runtime-instances';
 import { BlenderTransparentInstances } from './blender-transparent-instances';
+import { BlenderMaterialRanges } from './blender-material-ranges';
 import { BlenderMotionGeometry } from './blender-motion-geometry';
 
 /** A saved `View3DShading.type` as the stage's draw mode: Material Preview is `preview`. */
@@ -644,6 +645,7 @@ export interface PhotographRecord {
 export class BlenderRuntimeView {
   readonly root = new THREE.Group();
   private readonly instances = new BlenderRuntimeInstances(this.root);
+  private readonly materialRanges = new BlenderMaterialRanges();
   private readonly transparentInstances = new BlenderTransparentInstances(this.root);
   private readonly motionGeometry = new BlenderMotionGeometry(presenterChanged);
   private drawBatching = true;
@@ -1233,6 +1235,7 @@ export class BlenderRuntimeView {
     this.instances.rebuild(this.objects.values(), this.drawBatching && !this.rendered);
     if (this.drawBatching && !this.rendered) this.transparentInstances.setObjects(this.objects.values());
     this.motionGeometry.setObjects(this.objects.values());
+    this.materialRanges.setObjects(this.drawBatching && !this.rendered ? this.objects.values() : []);
   }
 
   /** Presentation-only comparison door; never changes Blender or its data. */
@@ -1244,8 +1247,8 @@ export class BlenderRuntimeView {
   }
 
   private drawPreparation: {
-    last: {opaqueMs: number; motionMs: number; transparentMs: number} | null;
-    navigation: {opaqueMs: number; motionMs: number; transparentMs: number} | null;
+    last: {opaqueMs: number; motionMs: number; rangesMs: number; transparentMs: number} | null;
+    navigation: {opaqueMs: number; motionMs: number; rangesMs: number; transparentMs: number} | null;
   } = {last: null, navigation: null};
 
   /** Before the renderer uploads attributes/builds its queues, for this area's
@@ -1264,18 +1267,22 @@ export class BlenderRuntimeView {
       // their sorting barriers and compatible geometry grouping.
       if (motion) this.instances.sync();
       const motionDone = performance.now();
+      this.materialRanges.prepare();
+      const rangesDone = performance.now();
       this.transparentInstances.prepare(camera, options?.multiDraw === true);
       const timing = {opaqueMs: opaqueDone - start, motionMs: motionDone - opaqueDone,
-        transparentMs: performance.now() - motionDone};
+        rangesMs: rangesDone - motionDone, transparentMs: performance.now() - rangesDone};
       this.drawPreparation.last = timing;
       if (motion) this.drawPreparation.navigation = timing;
     } catch (error) {
+      this.materialRanges.finish();
       this.motionGeometry.finish();
       this.instances.finishDraw();
       this.transparentInstances.finishDraw();
       throw error;
     }
     return () => {
+      this.materialRanges.finish();
       this.motionGeometry.finish();
       this.instances.finishDraw();
       this.transparentInstances.finishDraw();
@@ -2087,7 +2094,7 @@ export class BlenderRuntimeView {
   }
 
   drawStatistics() {
-    return {enabled: this.drawBatching, preparation: {...this.drawPreparation}, 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() {
@@ -2297,6 +2304,7 @@ export class BlenderRuntimeView {
   }
 
   private clear() {
+    this.materialRanges.clear();
     this.motionGeometry.clear();
     this.transparentInstances.clear();
     this.instances.clear();

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

@@ -263,6 +263,11 @@ export class BlenderTransparentInstances {
     for (const n of this.root.matrixWorld.elements) this.observe(n);
     const observedGeometry = new Set<THREE.BufferGeometry>();
     for (const mesh of this.objects) {
+      // Check eligibility every frame, including opaque -> transparent
+      // transitions, but opaque geometry/attribute versions cannot affect a
+      // transparent draw plan. Large solid-only scenes need no such census.
+      const currentMaterials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+      if (!currentMaterials.some(material => material.visible && material.transparent)) continue;
       this.observe(mesh.parent?.id ?? -1);
       this.observe(instanceObjectShown(mesh) ? 1 : 0);
       this.observe(mesh.layers.mask);

package/package.json

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