@volter/blender-engine 0.1.83 → 0.1.85

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

@@ -28,6 +28,16 @@ const uniforms = new WeakMap<THREE.MeshPhysicalMaterial, {
   blenderMapClip: {value: boolean}; blenderRoughnessClip: {value: boolean}; blenderNormalClip: {value: boolean};
   blenderWorldExtinction: {value: THREE.Vector3};
 }>();
+const drawHooks = new WeakMap<THREE.Material, Pick<THREE.Material, 'onBeforeRender' | 'onBeforeCompile' | 'customProgramCacheKey'>>();
+
+/** Internal draws can preserve the engine's known hooks or Three's defaults.
+ * A later custom hook may depend on the original object/material identity. */
+export function materialDrawHooksSupported(material: THREE.Material): boolean {
+  const hooks = drawHooks.get(material) ?? THREE.Material.prototype;
+  return material.onBeforeRender === hooks.onBeforeRender &&
+    material.onBeforeCompile === hooks.onBeforeCompile &&
+    material.customProgramCacheKey === hooks.customProgramCacheKey;
+}
 
 export function applyWorldExtinction(material: THREE.MeshPhysicalMaterial, extinction: THREE.Vector3): void {
   if (!uniforms.has(material)) applyPhysicalMaterial(material);
@@ -59,7 +69,7 @@ function graphShadow(material: THREE.MeshPhysicalMaterial): THREE.MeshPhysicalMa
 /** 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;
+  if (!(source instanceof THREE.MeshPhysicalMaterial) || !uniforms.has(source) || !materialDrawHooksSupported(source)) return null;
   const copy = target ?? graphShadow(source);
   if (!borrowGraphDrawBinding(source, copy)) {
     if (!target) copy.dispose();
@@ -180,6 +190,8 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
       // surface inputs it carries (`blender-graph-material.ts`).
       applyGraphShader(material, shader);
     };
+    drawHooks.set(material, {onBeforeRender: material.onBeforeRender,
+      onBeforeCompile: material.onBeforeCompile, customProgramCacheKey: material.customProgramCacheKey});
     material.needsUpdate = true;
   }
   values.blenderCoatIor.value = Math.max(1, data.coat_ior);

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

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { graphDrawAttributes } from './blender-graph-material';
+import { materialDrawHooksSupported } from './blender-physical-material';
 
 // Small spatial batches retain frustum rejection without duplicating geometry.
 const BATCH_SIZE = 64;
@@ -12,6 +13,11 @@ function sameMaterials(a: THREE.Material | THREE.Material[], b: THREE.Material |
     : a === b;
 }
 
+export function instanceObjectHooksSupported(object: THREE.Object3D): boolean {
+  return object.onBeforeRender === THREE.Object3D.prototype.onBeforeRender &&
+    object.onAfterRender === THREE.Object3D.prototype.onAfterRender;
+}
+
 export function instanceObjectShown(object: THREE.Object3D): boolean {
   for (let node: THREE.Object3D | null = object; node; node = node.parent)
     if (!node.visible) return false;
@@ -60,12 +66,13 @@ export class BlenderRuntimeInstances {
     for (const object of objects) {
       const mesh = object as THREE.Mesh;
       if (!mesh.isMesh) continue;
+      if (!instanceObjectHooksSupported(mesh)) { exclude('customHooks'); continue; }
       if ((mesh as THREE.SkinnedMesh).isSkinnedMesh ||
           (mesh as THREE.InstancedMesh).isInstancedMesh || mesh.morphTargetInfluences ||
           mesh.layers.mask !== 1) { exclude('deformationOrLayers'); continue; }
       const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
       if (materials.some(m => m.transparent || (m as THREE.MeshPhysicalMaterial).transmission > 0 ||
-          (m as THREE.ShaderMaterial).isShaderMaterial)) { exclude('material'); continue; }
+          (m as THREE.ShaderMaterial).isShaderMaterial || !materialDrawHooksSupported(m))) { exclude('material'); continue; }
       // Four slots for instanceMatrix, at most twelve for each actual program.
       // Count active inputs, NOT every stored authored layer: retaining unused
       // UVs/colours must not disable batching. No channel is deleted to fit.
@@ -125,6 +132,8 @@ export class BlenderRuntimeInstances {
     if (!this.batches.length) return;
     this.inverse.copy(this.root.matrixWorld).invert();
     for (const {draw, members} of this.batches) {
+      const materials = Array.isArray(draw.material) ? draw.material : [draw.material];
+      const supportedHooks = materials.every(materialDrawHooksSupported);
       let count = 0;
       let changed = false;
       for (const member of members) {
@@ -133,6 +142,7 @@ export class BlenderRuntimeInstances {
         // A drag can introduce negative scale/shear, or a skin can replace a
         // mesh between frames. Fall back immediately without touching its data.
         const compatible = mesh.parent !== null && mesh.geometry === draw.geometry &&
+          supportedHooks && instanceObjectHooksSupported(mesh) &&
           sameMaterials(mesh.material, draw.material) && instanceMatrixSupported(this.matrix);
         if (!compatible) {
           mesh.layers.mask |= member.layers;

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

@@ -3,7 +3,8 @@ import {BlenderOrderedBatches, ORDERED_BATCH_CAPACITY} from './blender-ordered-b
 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';
+import {materialDrawHooksSupported} from './blender-physical-material';
+import {instanceMatrixSupported, instanceObjectShown, instanceObjectHooksSupported} from './blender-runtime-instances';
 
 const CAPACITY = ORDERED_BATCH_CAPACITY;
 type Entry = {mesh: THREE.Mesh; material: THREE.Material | null; key: string | null; batchKey: string | null; groupOrder: number; z: number; centre: THREE.Vector3};
@@ -112,6 +113,7 @@ export class BlenderTransparentInstances {
       const candidate = materials.length === 1 ? materials[0]! : null;
       const order = groupOrder(mesh);
       if (candidate && candidate.visible && candidate.transparent &&
+          materialDrawHooksSupported(candidate) && instanceObjectHooksSupported(mesh) &&
           !(candidate as THREE.ShaderMaterial).isShaderMaterial &&
           !((candidate as THREE.MeshPhysicalMaterial).transmission > 0) &&
           (candidate.side !== THREE.DoubleSide || candidate.forceSinglePass) &&
@@ -291,6 +293,7 @@ export class BlenderTransparentInstances {
       this.observe(mesh.renderOrder);
       this.observe(groupOrder(mesh));
       this.observe(mesh.frustumCulled ? 1 : 0);
+      this.observe(instanceObjectHooksSupported(mesh) ? 1 : 0);
       this.observe(mesh.morphTargetInfluences ? 1 : 0);
       for (const n of mesh.matrixWorld.elements) this.observe(n);
       const geometry = mesh.geometry;
@@ -329,6 +332,7 @@ export class BlenderTransparentInstances {
   }
 
   private observeMaterial(material: THREE.Material): void {
+    this.observe(materialDrawHooksSupported(material) ? 1 : 0);
     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);

package/package.json

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