@volter/blender-engine 0.1.77 → 0.1.79

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

@@ -347,8 +347,11 @@ ${compiled.uvs.map(n => `varying vec2 ${uvVarying(n)};`).join('\n')}`;
     `vBlenderObjectPosition = transformed;
 vBlenderObjectNormal = objectNormal;
 mat4 blenderWorldMatrix = modelMatrix;
+#ifdef USE_BATCHING
+blenderWorldMatrix = blenderWorldMatrix * batchingMatrix;
+#endif
 #ifdef USE_INSTANCING
-blenderWorldMatrix = modelMatrix * instanceMatrix;
+blenderWorldMatrix = blenderWorldMatrix * instanceMatrix;
 #endif
 vBlenderWorldPosition = (blenderWorldMatrix * vec4(transformed, 1.0)).xyz;
 vBlenderWorldNormal = normalize(transpose(inverse(mat3(blenderWorldMatrix))) * objectNormal);

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-ordered-batches.ts

@@ -0,0 +1,156 @@
+import * as THREE from 'three';
+
+export const ORDERED_BATCH_CAPACITY = 64;
+const FAMILY_BYTES = 4 * 1024 * 1024;
+const CACHE_BYTES = 32 * 1024 * 1024;
+const MAX_DRAWS = 1024;
+type Shape = {geometry: THREE.BufferGeometry; stamp: string};
+type Family = {material: THREE.Material; shapes: Map<number, Shape>; template: THREE.BatchedMesh | null;
+  ids: Map<number, number>; draws: THREE.BatchedMesh[]; dirty: boolean; bytes: number; refused: boolean};
+
+/** Immutable packed attributes are shared between ordered draw runs. Only the
+ * matrix/indirection textures and command lists belong to an individual run.
+ * All interaction and authored geometry remain on the canonical meshes. */
+export class BlenderOrderedBatches {
+  private readonly families = new Map<string, Family>();
+  private readonly registrations = new Map<string, string | null>();
+  private bytes = 0;
+  private drawCount = 0;
+  private created = 0;
+  pending = false;
+
+  begin(): void { this.created = 0; this.pending = false; this.registrations.clear(); }
+
+  register(geometry: THREE.BufferGeometry, material: THREE.Material, order: number): string | null {
+    const registration = `${geometry.id}:${material.uuid}:${order}`;
+    if (this.registrations.has(registration)) return this.registrations.get(registration)!;
+    this.registrations.set(registration, null);
+    const position = geometry.getAttribute('position');
+    const count = geometry.index?.count ?? position?.count ?? 0;
+    if (!position || geometry.drawRange.start !== 0 || geometry.drawRange.count < count ||
+        Object.keys(geometry.morphAttributes).length) return null;
+    const layout: unknown[] = [!!geometry.index, geometry.userData['blenderUvChannels'] ?? null];
+    const versions: unknown[] = [geometry.index?.id, geometry.index?.version];
+    let bytes = (geometry.index?.count ?? 0) * 4;
+    for (const name of Object.keys(geometry.attributes).sort()) {
+      const attribute = geometry.getAttribute(name);
+      if (!(attribute instanceof THREE.BufferAttribute) ||
+          (attribute as THREE.InstancedBufferAttribute).isInstancedBufferAttribute ||
+          attribute instanceof THREE.Float16BufferAttribute ||
+          attribute.count !== position.count) return null;
+      layout.push([name, attribute.array.constructor.name, attribute.itemSize, attribute.normalized, attribute.gpuType]);
+      versions.push(name, attribute.id, attribute.version);
+      bytes += attribute.array.byteLength;
+    }
+    if (bytes > FAMILY_BYTES) return null;
+    const key = `multi:${material.uuid}:${order}:${JSON.stringify(layout)}`;
+    let family = this.families.get(key);
+    if (!family) {
+      family = {material, shapes: new Map(), template: null, ids: new Map(), draws: [], dirty: true, bytes: 0, refused: false};
+      this.families.set(key, family);
+    }
+    const stamp = JSON.stringify(versions);
+    const held = family.shapes.get(geometry.id);
+    if (!held || held.stamp !== stamp) {
+      family.shapes.set(geometry.id, {geometry, stamp});
+      family.dirty = true;
+    }
+    this.registrations.set(registration, key);
+    return key;
+  }
+
+  pack(): void {
+    for (const family of this.families.values()) {
+      if (!family.dirty) continue;
+      this.release(family);
+      family.dirty = false;
+      let vertices = 0, indices = 0, bytes = 0;
+      for (const {geometry} of family.shapes.values()) {
+        vertices += geometry.getAttribute('position').count;
+        indices += geometry.index?.count ?? 0;
+        for (const attribute of Object.values(geometry.attributes)) bytes += attribute.array.byteLength;
+      }
+      bytes += indices * (vertices > 65535 ? 4 : 2);
+      family.refused = bytes > FAMILY_BYTES || this.bytes + bytes > CACHE_BYTES;
+      if (family.refused) continue;
+      const template = new THREE.BatchedMesh(ORDERED_BATCH_CAPACITY, vertices, indices, family.material);
+      template.sortObjects = false;
+      template.perObjectFrustumCulled = false;
+      template.frustumCulled = false;
+      template.matrixAutoUpdate = false;
+      template.boundingSphere = new THREE.Sphere();
+      template.name = 'Blender ordered multi-draw';
+      template.userData['engineInternal'] = true;
+      for (const {geometry} of family.shapes.values()) family.ids.set(geometry.id, template.addGeometry(geometry));
+      // Named UV selection is a geometry-level material input. The family key
+      // requires identical maps; every per-vertex graph attribute is copied.
+      const first = family.shapes.values().next().value!.geometry;
+      template.geometry.userData['blenderUvChannels'] = first.userData['blenderUvChannels'];
+      for (const name of Object.keys(first.attributes))
+        (template.geometry.getAttribute(name) as THREE.BufferAttribute).gpuType = (first.getAttribute(name) as THREE.BufferAttribute).gpuType;
+      family.template = template;
+      family.bytes = bytes;
+      this.bytes += bytes;
+    }
+  }
+
+  available(key: string): boolean { return !!this.families.get(key)?.template; }
+
+  get(key: string, index: number): THREE.BatchedMesh | null {
+    const family = this.families.get(key)!;
+    const template = family.template;
+    if (!template) return null;
+    let draw = family.draws[index];
+    if (!draw) {
+      if (this.drawCount >= MAX_DRAWS) return null;
+      // copy() uses public Three APIs and briefly copies the packed arrays.
+      // Bound that transient work per frame; ordinary meshes fill every gap.
+      if (this.created >= 4) { this.pending = true; return null; }
+      draw = new THREE.BatchedMesh(1, 0, 0, family.material);
+      draw.dispose();
+      draw.copy(template);
+      for (const name of Object.keys(template.geometry.attributes))
+        draw.geometry.setAttribute(name, template.geometry.getAttribute(name));
+      draw.geometry.setIndex(template.geometry.index);
+      const firstId = family.ids.values().next().value!;
+      for (let i = 0; i < ORDERED_BATCH_CAPACITY; i++) {
+        draw.addInstance(firstId);
+        draw.setVisibleAt(i, false);
+      }
+      family.draws.push(draw);
+      this.created++;
+      this.drawCount++;
+    }
+    return draw;
+  }
+
+  geometryId(key: string, geometry: THREE.BufferGeometry): number { return this.families.get(key)!.ids.get(geometry.id)!; }
+
+  inspect() { return {bytes: this.bytes, draws: this.drawCount, pending: this.pending,
+    refusedFamilies: [...this.families.values()].filter(f => f.refused).length}; }
+
+  private release(family: Family): void {
+    for (const draw of family.draws) {
+      draw.removeFromParent();
+      // BatchedMesh.dispose owns its geometry. Detach shared buffer attributes
+      // first, so retiring one run cannot delete another run's GPU buffers.
+      for (const name of Object.keys(draw.geometry.attributes)) draw.geometry.deleteAttribute(name);
+      draw.geometry.setIndex(null);
+      draw.dispose();
+      this.drawCount--;
+    }
+    family.draws.length = 0;
+    family.template?.dispose();
+    family.template = null;
+    family.ids.clear();
+    this.bytes -= family.bytes;
+    family.bytes = 0;
+  }
+
+  clear(): void {
+    for (const family of this.families.values()) this.release(family);
+    this.families.clear();
+    this.registrations.clear();
+    this.pending = false;
+  }
+}

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,13 +1247,13 @@ 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
    * actual camera. Transparent instance runs are camera-order dependent. */
-  prepareDraw(camera: THREE.Camera, options?: {interactive: boolean; height: number}): () => void {
+  prepareDraw(camera: THREE.Camera, options?: {interactive: boolean; height: number; multiDraw?: boolean}): () => void {
     try {
       const start = performance.now();
       this.instances.prepareDraw(camera);
@@ -1264,18 +1267,22 @@ export class BlenderRuntimeView {
       // their sorting barriers and compatible geometry grouping.
       if (motion) this.instances.sync();
       const motionDone = performance.now();
-      this.transparentInstances.prepare(camera);
+      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

@@ -1,10 +1,12 @@
 import * as THREE from 'three';
+import {BlenderOrderedBatches, ORDERED_BATCH_CAPACITY} from './blender-ordered-batches';
+import {presenterChanged} from './blender-presenter-change';
 import {graphDrawAttributes} from './blender-graph-material';
 import {instanceMatrixSupported, instanceObjectShown} from './blender-runtime-instances';
 
-const CAPACITY = 64;
-type Entry = {mesh: THREE.Mesh; material: THREE.Material | null; key: string | null; groupOrder: number; z: number; centre: THREE.Vector3};
-type Draw = {mesh: THREE.InstancedMesh; members: THREE.Mesh[]};
+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};
+type Draw = {mesh: THREE.InstancedMesh | THREE.BatchedMesh; members: THREE.Mesh[]};
 
 function groupOrder(mesh: THREE.Object3D): number {
   for (let parent = mesh.parent; parent; parent = parent.parent)
@@ -19,6 +21,9 @@ 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 ordered = new BlenderOrderedBatches();
+  private readonly mixedDraws = new Map<THREE.BatchedMesh, Draw>();
+  private multiDraw = false;
   private readonly pools = new Map<string, Draw[]>();
   private readonly hidden: THREE.Mesh[] = [];
   private readonly inverse = new THREE.Matrix4();
@@ -42,12 +47,15 @@ export class BlenderTransparentInstances {
     this.objects = [...objects].filter((object): object is THREE.Mesh => (object as THREE.Mesh).isMesh === true);
   }
 
-  prepare(camera: THREE.Camera): void {
+  prepare(camera: THREE.Camera, multiDraw = false): void {
     this.finishDraw();
     if (!this.objects.length) return;
     camera.updateMatrixWorld();
     this.projection.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-    if (!this.planChanged(camera)) {
+    const capabilityChanged = this.multiDraw !== multiDraw;
+    this.multiDraw = multiDraw;
+    const inputsChanged = this.planChanged(camera);
+    if (!inputsChanged && !capabilityChanged && !this.ordered.pending) {
       // The draw plan is a disposable presentation, not evaluated scene data.
       // Reuse only after exact comparison of every input to culling/ordering;
       // a camera move, drag, visibility or material change rebuilds it below.
@@ -61,6 +69,8 @@ export class BlenderTransparentInstances {
       return;
     }
     this.planned.length = 0;
+    for (const draw of this.mixedDraws.values()) draw.members.length = 0;
+    this.ordered.begin();
     for (const pool of this.pools.values()) for (const draw of pool) {
       draw.mesh.visible = false;
       draw.members.length = 0;
@@ -128,8 +138,14 @@ export class BlenderTransparentInstances {
           : 'geometryLayersOrTransform';
         this.excluded[reason] = (this.excluded[reason] ?? 0) + 1;
       }
-      entries.push({mesh, material, key, groupOrder: order, z, centre});
+      const batchKey = multiDraw && key && material ? this.ordered.register(mesh.geometry, material, mesh.renderOrder) : null;
+      entries.push({mesh, material, key, batchKey, groupOrder: order, z, centre});
     }
+    this.ordered.pack();
+    // A family may exceed the bounded cache. Retain its original instancing
+    // key rather than merging incompatible geometries on the fallback path.
+    for (const entry of entries) if (entry.batchKey && this.ordered.available(entry.batchKey)) entry.key = entry.batchKey;
+    for (const [mesh] of this.mixedDraws) if (!mesh.parent) this.mixedDraws.delete(mesh);
     entries.sort((a, b) => a.groupOrder - b.groupOrder || a.mesh.renderOrder - b.mesh.renderOrder || b.z - a.z || a.mesh.id - b.mesh.id);
     const used = new Map<string, number>();
     for (let begin = 0; begin < entries.length;) {
@@ -153,9 +169,26 @@ export class BlenderTransparentInstances {
           const head = entries[offset]!;
           const index = used.get(first.key) ?? 0;
           used.set(first.key, index + 1);
+          const mixed = first.key.startsWith('multi:');
+          let draw: Draw | undefined;
+          if (mixed) {
+            const mesh = this.ordered.get(first.key, index);
+            if (!mesh) continue;
+            draw = this.mixedDraws.get(mesh);
+            if (!draw) {
+              draw = {mesh, members: []};
+              this.mixedDraws.set(mesh, draw);
+              const held = draw;
+              mesh.raycast = (raycaster, hits) => {
+                if (mesh.visible) for (const member of held.members)
+                  if (instanceObjectShown(member)) member.raycast(raycaster, hits);
+              };
+              this.root.add(mesh);
+            }
+          }
           let pool = this.pools.get(first.key);
           if (!pool) { pool = []; this.pools.set(first.key, pool); }
-          let draw = pool[index];
+          if (!mixed) draw = pool[index];
           if (!draw) {
             const mesh = new THREE.InstancedMesh(first.mesh.geometry, first.material!, CAPACITY);
             mesh.name = 'Blender ordered transparency';
@@ -184,12 +217,20 @@ export class BlenderTransparentInstances {
             const member = entries[offset + i]!.mesh;
             this.matrix.multiplyMatrices(this.inverse, member.matrixWorld);
             draw.mesh.setMatrixAt(i, this.matrix);
+            if (draw.mesh instanceof THREE.BatchedMesh) {
+              draw.mesh.setGeometryIdAt(i, this.ordered.geometryId(first.key, member.geometry));
+              draw.mesh.setVisibleAt(i, true);
+            }
             draw.members.push(member);
             member.layers.disable(0);
             this.hidden.push(member);
           }
-          draw.mesh.count = length;
-          draw.mesh.instanceMatrix.needsUpdate = true;
+          if (draw.mesh instanceof THREE.BatchedMesh) {
+            for (let i = length; i < CAPACITY; i++) draw.mesh.setVisibleAt(i, false);
+          } else {
+            draw.mesh.count = length;
+            draw.mesh.instanceMatrix.needsUpdate = true;
+          }
           this.planned.push(draw);
           this.batches++;
           this.instances += length;
@@ -197,9 +238,12 @@ export class BlenderTransparentInstances {
       }
       begin = end;
     }
+    // A quiet viewport must also finish bounded pool construction. Notify only
+    // after this draw's temporary layer/geometry swaps have been restored.
+    if (this.ordered.pending) queueMicrotask(presenterChanged);
   }
 
-  inspect() { return {batches: this.batches, instances: this.instances, excluded: {...this.excluded}}; }
+  inspect() { return {batches: this.batches, instances: this.instances, excluded: {...this.excluded}, multiDraw: this.ordered.inspect()}; }
 
   private observe(value: number | string): void {
     if (this.planState[this.stateIndex] !== value) {
@@ -217,6 +261,7 @@ export class BlenderTransparentInstances {
     this.observe(camera.layers.mask);
     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>();
     for (const mesh of this.objects) {
       this.observe(mesh.parent?.id ?? -1);
       this.observe(instanceObjectShown(mesh) ? 1 : 0);
@@ -228,6 +273,19 @@ export class BlenderTransparentInstances {
       for (const n of mesh.matrixWorld.elements) this.observe(n);
       const geometry = mesh.geometry;
       this.observe(geometry.id);
+      if (!observedGeometry.has(geometry)) {
+        observedGeometry.add(geometry);
+        this.observe(geometry.index?.id ?? -1);
+        this.observe(geometry.index?.version ?? -1);
+        this.observe(JSON.stringify(geometry.userData['blenderUvChannels'] ?? null));
+        for (const name of Object.keys(geometry.attributes).sort()) {
+          const attribute = geometry.getAttribute(name);
+          this.observe(name);
+          if (attribute instanceof THREE.BufferAttribute) {
+            this.observe(attribute.id); this.observe(attribute.version);
+          }
+        }
+      }
       this.observe(geometry.drawRange.start);
       this.observe(geometry.drawRange.count);
       this.observe(geometry.index?.count ?? geometry.getAttribute('position').count);
@@ -259,6 +317,7 @@ export class BlenderTransparentInstances {
     for (const mesh of this.hidden) mesh.layers.enable(0);
     this.hidden.length = 0;
     for (const pool of this.pools.values()) for (const {mesh} of pool) mesh.visible = false;
+    for (const {mesh} of this.mixedDraws.values()) mesh.visible = false;
   }
 
   clear(): void {
@@ -268,6 +327,8 @@ export class BlenderTransparentInstances {
       mesh.dispose();
     }
     this.pools.clear();
+    this.ordered.clear();
+    this.mixedDraws.clear();
     this.planned.length = 0;
     this.planState.length = 0;
     this.objects = [];

package/package.json

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