@volter/blender-engine 0.1.90 → 0.1.91

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

@@ -207,6 +207,25 @@ function channelsFor(compiled: CompiledGraph, geometry: THREE.BufferGeometry): R
   return channels;
 }
 
+/** Compare the actual named-layer inputs without allocating and serializing
+ * two channel maps on every draw. Missing layers still get their zero buffer,
+ * including when this geometry first shares an already-bound material. */
+function channelsMatch(compiled: CompiledGraph, channels: Record<string, number>, geometry: THREE.BufferGeometry): boolean {
+  const named = geometry.userData['blenderUvChannels'] as Record<string, number> | undefined;
+  const count = geometry.getAttribute('position')?.count ?? 0;
+  let same = Object.keys(channels).length === compiled.uvs.length;
+  for (const name of compiled.uvs) {
+    let channel = name === '' ? 0 : named?.[name];
+    if (channel === undefined) {
+      channel = 9;
+      if (geometry.getAttribute('uv9')?.count !== count)
+        geometry.setAttribute('uv9', new THREE.BufferAttribute(new Float32Array(count * 2), 2));
+    }
+    if (channels[name] !== channel) same = false;
+  }
+  return same;
+}
+
 /** Per draw: a pending program started compiling (see `Pending`), a compiled
  *  one swapped in, a refused one dropped, and the channel of each named layer
  *  on this geometry. `shadowOf` makes the proxy a program compiles through:
@@ -261,9 +280,8 @@ export function bindGraphDraw(material: THREE.MeshPhysicalMaterial, geometry: TH
       `so it is drawn with its constant values. ${first}`);
     return;
   }
-  const channels = channelsFor(binding.compiled, geometry);
-  if (JSON.stringify(channels) !== JSON.stringify(binding.channels)) {
-    binding.channels = channels;
+  if (!channelsMatch(binding.compiled, binding.channels, geometry)) {
+    binding.channels = channelsFor(binding.compiled, geometry);
     material.needsUpdate = true;
   }
 }
@@ -363,23 +381,15 @@ ${compiled.uvs.map(n => `varying vec2 ${uvVarying(n)};`).join('\n')}`;
     '#include <project_vertex>',
     `vBlenderObjectPosition = transformed;
 vBlenderObjectNormal = objectNormal;
-vec4 blenderWorldPosition = vec4(transformed, 1.0);
-#ifdef USE_INSTANCING
-blenderWorldPosition = instanceMatrix * blenderWorldPosition;
-#endif
+mat4 blenderWorldMatrix = modelMatrix;
 #ifdef USE_BATCHING
-blenderWorldPosition = batchingMatrix * blenderWorldPosition;
+blenderWorldMatrix = blenderWorldMatrix * batchingMatrix;
 #endif
-vBlenderWorldPosition = (modelMatrix * blenderWorldPosition).xyz;
-// Three already computed inverse-transpose(modelView) * objectNormal,
-// including the supported instance/batch normal transforms. Multiplying by
-// transpose(view) removes that view transform without another matrix inverse.
-// Our instance planners retain ordinary draws for shear/singular transforms.
-vec3 blenderWorldNormal = transpose(mat3(viewMatrix)) * transformedNormal;
-#ifdef FLIP_SIDED
-blenderWorldNormal = -blenderWorldNormal;
+#ifdef USE_INSTANCING
+blenderWorldMatrix = blenderWorldMatrix * instanceMatrix;
 #endif
-vBlenderWorldNormal = normalize(blenderWorldNormal);
+vBlenderWorldPosition = (blenderWorldMatrix * vec4(transformed, 1.0)).xyz;
+vBlenderWorldNormal = normalize(transpose(inverse(mat3(blenderWorldMatrix))) * objectNormal);
 vBlenderOrco = blenderOrco;
 ${compiled.attributes.map(n => `${attributeVarying(n)} = ${graphAttributeName(n)};`).join('\n')}
 ${compiled.uvs.map(n => `${uvVarying(n)} = ${attribute(channels[n] ?? 0)};`).join('\n')}

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

@@ -109,7 +109,7 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
       blenderWorldExtinction: {value: new THREE.Vector3()}};
     uniforms.set(material, values);
     const held = values;
-    material.customProgramCacheKey = () => `blender-principled-physical-v6${graphProgramKey(material)}`;
+    material.customProgramCacheKey = () => `blender-principled-physical-v5${graphProgramKey(material)}`;
     material.onBeforeRender = (renderer, scene, camera, geometry, object) => {
       bindNamedUvChannels(material, geometry);
       bindGraphDraw(material, geometry, renderer, scene, camera, object, graphShadow);

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

@@ -281,6 +281,7 @@ export class BlenderTransparentInstances {
     for (const n of this.projection.elements) this.observe(n);
     for (const n of this.root.matrixWorld.elements) this.observe(n);
     const observedGeometry = new Set<THREE.BufferGeometry>();
+    const observedMaterials = new Set<THREE.Material>();
     for (const mesh of this.objects) {
       // Check eligibility every frame, including opaque -> transparent
       // transitions, but opaque geometry/attribute versions cannot affect a
@@ -323,17 +324,23 @@ export class BlenderTransparentInstances {
       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);
+      if (materials) for (const material of materials) this.observeMaterial(material, observedMaterials);
+      else this.observeMaterial(mesh.material as THREE.Material, observedMaterials);
     }
     this.stateChanged ||= this.planState.length !== this.stateIndex;
     this.planState.length = this.stateIndex;
     return this.stateChanged;
   }
 
-  private observeMaterial(material: THREE.Material): void {
+  private observeMaterial(material: THREE.Material, observed: Set<THREE.Material>): void {
+    // Every slot still observes its identity. Shared state needs one exact
+    // census per material, rather than thousands of identical hook/value
+    // comparisons for repeated foliage using the same material.
+    this.observe(material.uuid);
+    if (observed.has(material)) return;
+    observed.add(material);
     this.observe(materialDrawHooksSupported(material) ? 1 : 0);
-    this.observe(material.uuid); this.observe(material.version);
+    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);

package/package.json

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