@volter/blender-engine 0.1.75 → 0.1.77

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

@@ -29,7 +29,7 @@ export class BlenderMotionGeometry {
   private nextIdentity = 0;
   private bytes = 0;
   private unavailable: string | null = null;
-  private reductions: {vertices: number; fullTriangles: number; reducedTriangles: number; error: number; accepted: boolean}[] = [];
+  private reductions: {vertices: number; fullTriangles: number; reducedTriangles: number; error: number; accepted: boolean; bytes?: number}[] = [];
   private timer: ReturnType<typeof setTimeout> | null = null;
   private readonly cameraWorld = new THREE.Matrix4();
   private readonly cameraProjection = new THREE.Matrix4();
@@ -124,8 +124,40 @@ export class BlenderMotionGeometry {
       const multi = Array.isArray(meshes[0]!.material);
       if (meshes.some(mesh => Array.isArray(mesh.material) !== multi)) return;
       const ranges: Range[] = multi ? geometry.groups : [{start: 0, count: geometry.index!.count}];
-      const appearance = Object.entries(geometry.attributes).filter(([name]) => name === 'normal' || /^uv\d*$/.test(name));
+      const chunks = ranges.flatMap(range => {
+        const chunks: Range[] = [];
+        for (let start = range.start; start < range.start + range.count; start += CHUNK_INDICES)
+          chunks.push({start, count: Math.min(CHUNK_INDICES, range.start + range.count - start), materialIndex: range.materialIndex});
+        return chunks;
+      });
+      // Lock only the boundaries introduced by partitioning. LockBorder would
+      // also pin every vertex on a real leaf's silhouette, defeating LOD even
+      // when its edge could simplify within the allowed appearance error.
+      // Blender's source-point map joins UV/normal splits at the same point.
+      const sourcePoints = geometry.getAttribute('blenderVertex') as THREE.BufferAttribute | undefined;
+      const partition = new Uint32Array(position.count);
+      const boundary = new Uint8Array(position.count);
+      const pointIndex = (vertex: number) => sourcePoints ? sourcePoints.getX(vertex) : vertex;
+      for (let chunk = 0; chunk < chunks.length; chunk++) {
+        const range = chunks[chunk]!;
+        for (let first = range.start; first < range.start + range.count; first += COPY_ITEMS) {
+          await yieldCopy();
+          for (let i = first; i < Math.min(first + COPY_ITEMS, range.start + range.count); i++) {
+            const point = pointIndex(geometry.index!.getX(i));
+            if (!Number.isInteger(point) || point < 0 || point >= partition.length) return;
+            if (!partition[point]) partition[point] = chunk + 1;
+            else if (partition[point] !== chunk + 1) boundary[point] = 1;
+          }
+        }
+      }
+      const appearance = Object.entries(geometry.attributes).filter(([name]) => name !== 'position' && name !== 'blenderVertex');
       const stride = appearance.reduce((n, [, a]) => n + a.itemSize, 0);
+      if (stride > 32) return; // meshoptimizer's attribute component limit
+      const protectedComponents: number[] = [];
+      let component = 0;
+      for (const [name, attribute] of appearance) {
+        for (let c = 0; c < attribute.itemSize; c++, component++) if (name !== 'normal') protectedComponents.push(component);
+      }
       const weights = appearance.flatMap(([name, a]) => Array(a.itemSize).fill(name === 'normal' ? 0.5 : 1));
       // Reuse bounds when present, otherwise derive the error scale in
       // yielding slices. Never scan a large mesh in one UI-thread call.
@@ -157,12 +189,14 @@ export class BlenderMotionGeometry {
             if (local === undefined) { local = originals.length; originals.push(original); remap.set(original, local); }
             indices[i - start] = local;
           }
+          const locks = new Uint8Array(originals.length);
           const positions = new Float32Array(originals.length * 3);
           const values = new Float32Array(originals.length * stride);
           for (let first = 0; first < originals.length; first += COPY_ITEMS) {
             await yieldCopy();
             for (let i = first; i < Math.min(first + COPY_ITEMS, originals.length); i++) {
               const original = originals[i]!;
+              locks[i] = boundary[pointIndex(original)]!;
               for (let c = 0; c < 3; c++) positions[i * 3 + c] = position.getComponent(original, c);
               let offset = 0;
               for (const [, attribute] of appearance) {
@@ -175,8 +209,8 @@ export class BlenderMotionGeometry {
           const id = ++this.nextId;
           const response = await new Promise<MotionMeshResponse>(resolve => {
             this.pending = {id, resolve};
-            const request: MotionMeshRequest = {id, positions, indices, attributes: values, stride, weights, absoluteError};
-            this.worker!.postMessage(request, [positions.buffer, indices.buffer, values.buffer]);
+            const request: MotionMeshRequest = {id, positions, indices, attributes: values, stride, weights, absoluteError, protectedComponents, locks};
+            this.worker!.postMessage(request, [positions.buffer, indices.buffer, values.buffer, locks.buffer]);
           });
           current();
           if (response.refusal) throw new Error(response.refusal);
@@ -190,7 +224,7 @@ export class BlenderMotionGeometry {
         }
         if (multi) outputGroups.push({start: groupStart, count: count - groupStart, materialIndex: range.materialIndex});
       }
-      const reduction = {vertices: position.count, fullTriangles: geometry.index!.count / 3,
+      const reduction: (typeof this.reductions)[number] = {vertices: position.count, fullTriangles: geometry.index!.count / 3,
         reducedTriangles: count / 3, error, accepted: false};
       if (this.reductions.length < 32) this.reductions.push(reduction);
       if (!count || count >= geometry.index!.count * 0.75) return;
@@ -214,6 +248,7 @@ export class BlenderMotionGeometry {
       }
       const bytes = indices.byteLength + Object.values(geometry.attributes).reduce((n, a) =>
         n + originals.length * a.itemSize * a.array.BYTES_PER_ELEMENT, 0);
+      reduction.bytes = bytes;
       if (this.bytes + bytes > CACHE_BYTES) return;
       const copy = new THREE.BufferGeometry();
       copy.setIndex(new THREE.BufferAttribute(indices, 1));
@@ -271,10 +306,18 @@ export class BlenderMotionGeometry {
     for (const [source, entry] of this.cache) {
       for (const mesh of this.groups.get(source) ?? []) {
         if (!instanceObjectShown(mesh) || (mesh.frustumCulled && !this.frustum.intersectsObject(mesh))) continue;
-        // Frobenius norm bounds the linear transform even under shear; the
-        // longest axis alone can understate the projected simplifier error.
+        // 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;
-        const scale = Math.hypot(e[0]!, e[1]!, e[2]!, e[4]!, e[5]!, e[6]!, e[8]!, e[9]!, e[10]!);
+        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;
+        const xy = Math.abs(e[0]! * e[4]! + e[1]! * e[5]! + e[2]! * e[6]!);
+        const xz = Math.abs(e[0]! * e[8]! + e[1]! * e[9]! + e[2]! * e[10]!);
+        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

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

@@ -8,21 +8,33 @@ export interface MotionMeshRequest {
   stride: number;
   weights: number[];
   absoluteError: number;
+  protectedComponents: number[];
+  locks: Uint8Array;
 }
 export interface MotionMeshResponse {id: number; indices?: Uint32Array; error?: number; refusal?: string}
 
 // One copied mesh at a time. The worker never owns or detaches a resident
 // Blender column, and never writes positions or attributes back to the model.
 self.onmessage = async (event: MessageEvent<MotionMeshRequest>) => {
-  const {id, positions, indices, attributes, stride, weights, absoluteError} = event.data;
+  const {id, positions, indices, attributes, stride, weights, absoluteError, protectedComponents, locks} = event.data;
   try {
     await MeshoptSimplifier.ready;
-    const target = Math.max(384, Math.floor(indices.length * 0.08 / 3) * 3);
+    // Permit collapses across normal splits, while explicitly protecting UV
+    // and other shader-attribute discontinuities. This follows meshoptimizer
+    // 1.2's attribute-aware permissive recipe; no position/attribute is edited.
+    const positionsRemap = MeshoptSimplifier.generatePositionRemap(positions, 3);
+    for (let i = 0; i < positionsRemap.length; i++) {
+      const other = positionsRemap[i]!;
+      if (other !== i && protectedComponents.some(c => attributes[i * stride + c] !== attributes[other * stride + c])) {
+        locks[i]! |= 2; locks[other]! |= 2; // meshopt_SimplifyVertex_Protect
+      }
+    }
+    const target = Math.min(indices.length, Math.max(384, Math.floor(indices.length * 0.08 / 3) * 3));
     const [reduced, error] = MeshoptSimplifier.simplifyWithAttributes(
-      indices, positions, 3, attributes, stride, weights, null, target, absoluteError,
-      // Preserve open boundaries and attribute seams. If that prevents a
-      // useful reduction, keep the original; never sample/drop triangles.
-      ['LockBorder', 'ErrorAbsolute'],
+      indices, positions, 3, attributes, stride, weights, locks, target, absoluteError,
+      // Explicit locks preserve material/chunk borders. The appearance error
+      // includes normals; unsuccessful reductions retain complete originals.
+      ['ErrorAbsolute', 'Permissive'],
     );
     const response: MotionMeshResponse = {
       id, indices: reduced, error,

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

@@ -1243,12 +1243,19 @@ export class BlenderRuntimeView {
     presenterChanged();
   }
 
+  private drawPreparation: {
+    last: {opaqueMs: number; motionMs: number; transparentMs: number} | null;
+    navigation: {opaqueMs: number; motionMs: number; transparentMs: number} | null;
+  } = {last: null, navigation: null};
+
   /** 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, options?: {interactive: boolean; height: number}): () => void {
     try {
+      const start = performance.now();
       this.instances.prepareDraw(camera);
       this.root.updateMatrixWorld(true);
+      const opaqueDone = performance.now();
       const motion = this.motionGeometry.prepare(camera, !this.rendered && (this.mode ?? this.frame?.mode) === 'OBJECT' &&
         options?.interactive === true, options?.height ?? 0);
       // A changed navigation geometry is an ordinary-draw fallback for an
@@ -1256,7 +1263,12 @@ export class BlenderRuntimeView {
       // runs are planned AFTER per-placement geometry selection, preserving
       // their sorting barriers and compatible geometry grouping.
       if (motion) this.instances.sync();
+      const motionDone = performance.now();
       this.transparentInstances.prepare(camera);
+      const timing = {opaqueMs: opaqueDone - start, motionMs: motionDone - opaqueDone,
+        transparentMs: performance.now() - motionDone};
+      this.drawPreparation.last = timing;
+      if (motion) this.drawPreparation.navigation = timing;
     } catch (error) {
       this.motionGeometry.finish();
       this.instances.finishDraw();
@@ -2075,7 +2087,7 @@ export class BlenderRuntimeView {
   }
 
   drawStatistics() {
-    return {enabled: this.drawBatching, opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect(), motion: this.motionGeometry.inspect()};
+    return {enabled: this.drawBatching, preparation: {...this.drawPreparation}, opaque: this.instances.inspect(), transparent: this.transparentInstances.inspect(), motion: this.motionGeometry.inspect()};
   }
 
   snapshot() {

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

@@ -29,6 +29,7 @@ export class BlenderTransparentInstances {
   private readonly depth = new THREE.Vector4();
   private batches = 0;
   private instances = 0;
+  private excluded: Record<string, number> = {};
   private readonly planState: (number | string)[] = [];
   private readonly planned: Draw[] = [];
   private stateIndex = 0;
@@ -65,6 +66,7 @@ export class BlenderTransparentInstances {
       draw.members.length = 0;
     }
     this.batches = this.instances = 0;
+    this.excluded = {};
     this.frustum.setFromProjectionMatrix(this.projection);
     this.inverse.copy(this.root.matrixWorld).invert();
     const entries: Entry[] = [];
@@ -118,6 +120,14 @@ export class BlenderTransparentInstances {
           key = groupKey;
         }
       }
+      if (key === null) {
+        const reason = !candidate ? 'multipleMaterials'
+          : (candidate as THREE.ShaderMaterial).isShaderMaterial ? 'customShader'
+          : (candidate as THREE.MeshPhysicalMaterial).transmission > 0 ? 'transmission'
+          : candidate.side === THREE.DoubleSide && !candidate.forceSinglePass ? 'twoPass'
+          : 'geometryLayersOrTransform';
+        this.excluded[reason] = (this.excluded[reason] ?? 0) + 1;
+      }
       entries.push({mesh, material, key, groupOrder: order, z, centre});
     }
     entries.sort((a, b) => a.groupOrder - b.groupOrder || a.mesh.renderOrder - b.mesh.renderOrder || b.z - a.z || a.mesh.id - b.mesh.id);
@@ -189,7 +199,7 @@ export class BlenderTransparentInstances {
     }
   }
 
-  inspect() { return {batches: this.batches, instances: this.instances}; }
+  inspect() { return {batches: this.batches, instances: this.instances, excluded: {...this.excluded}}; }
 
   private observe(value: number | string): void {
     if (this.planState[this.stateIndex] !== value) {

package/package.json

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