@volter/blender-engine 0.1.82 → 0.1.84

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

@@ -120,6 +120,11 @@ export class BlenderOrderedBatches {
       draw = new THREE.BatchedMesh(1, 0, 0, family.material);
       draw.dispose();
       draw.copy(template);
+      // Three r180's program invalidation reads colorTexture, whereas its
+      // program parameters read _colorsTexture. These owned draws never use
+      // per-instance colors: expose that same null state to both checks so
+      // every draw does not rebuild the already-correct program parameters.
+      Object.defineProperty(draw, 'colorTexture', {value: null});
       for (const name of Object.keys(template.geometry.attributes))
         draw.geometry.setAttribute(name, template.geometry.getAttribute(name));
       draw.geometry.setIndex(template.geometry.index);

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-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);
@@ -333,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.82",
+  "version": "0.1.84",
   "publishConfig": {
     "access": "public"
   },