@volter/blender-engine 0.1.136 → 0.1.138

package/browser/pull-job.mts

@@ -10,8 +10,23 @@ export class PullJob<T> {
   private expected: string | null = null;
   private resume: (() => void) | null = null;
   private waiter: { resolve: (value: PullResult<T>) => void; reject: (error: unknown) => void } | null = null;
+  /**
+   * How the work ended, when it ended while nobody was waiting on a step. Work normally ends only
+   * while a step waits, but work that races something against a checkpoint (an engine compiling
+   * beside an import) can fail in the gap after a `continue` was handed out. The outcome is kept
+   * for the step that comes next, so the caller is told what actually happened. Before this, the
+   * failure was thrown at nobody and the next step answered "Invalid or replayed load
+   * continuation", which named the protocol instead of the fault (measured 2026-10-08: a Blender
+   * start refused by a content security policy showed only that message, on every retry).
+   */
+  private ended: { readonly value: T } | { readonly error: unknown } | null = null;
   constructor(private readonly work: (checkpoint: (phase: string) => Promise<void>) => Promise<T>) {}
   step(token?: string): Promise<PullResult<T>> {
+    if (this.ended && !this.waiter && token === this.expected) {
+      const ended = this.ended;
+      this.ended = null; this.expected = null; this.resume = null;
+      return 'error' in ended ? Promise.reject(ended.error) : Promise.resolve({ load: 'done', value: ended.value });
+    }
     if (this.finished || this.waiter || (this.started ? token !== this.expected || !this.resume : token !== undefined))
       return Promise.reject(new Error('Invalid or replayed load continuation'));
     const answer = new Promise<PullResult<T>>((resolve, reject) => { this.waiter = { resolve, reject }; });
@@ -24,12 +39,18 @@ export class PullJob<T> {
         waiter.resolve({ load: 'continue', token: this.expected, phase });
       }))).then(value => {
         this.finished = true;
-        const waiter = this.waiter!; this.waiter = null;
-        waiter.resolve({ load: 'done', value });
+        const waiter = this.waiter; this.waiter = null;
+        if (waiter) waiter.resolve({ load: 'done', value });
+        else this.ended = { value };
       }, error => {
         this.finished = true;
-        const waiter = this.waiter!; this.waiter = null;
-        waiter.reject(error);
+        const waiter = this.waiter; this.waiter = null;
+        if (waiter) waiter.reject(error);
+        else {
+          this.ended = { error };
+          // Said now as well: if the owner never asks for the next step, nobody would collect it.
+          console.warn('A Blender load failed between steps; the next step reports it:', error);
+        }
       });
     } else {
       const resume = this.resume!; this.resume = null; this.expected = null; resume();

package/browser/runtime.ts

@@ -273,14 +273,26 @@ export class BlenderRuntime {
       );
     this.#project = project;
     this.#document ??= document ?? 'models/model.blend';
-    this.#started ??= this.#request({
+    this.#started ??= (this.#request({
       op: 'start',
       project,
       ...(document === undefined ? {} : { document }),
-    }) as Promise<RuntimeStart>;
+    }) as Promise<RuntimeStart>).catch((error: unknown) => {
+      this.#startFailed = true;
+      throw error;
+    });
     return this.#started;
   }
 
+  /**
+   * True once THIS session's own start has failed (not a refusal to start, such as a file another
+   * document holds). A start is asked for once and its outcome kept, and the worker that failed may
+   * hold a half-started engine, so such a session never starts: its owner discards it and makes a
+   * new one, with a new worker, for the next attempt.
+   */
+  get startFailed(): boolean { return this.#startFailed; }
+  #startFailed = false;
+
   #ready(): Promise<RuntimeStart> {
     if (this.#project === null)
       return Promise.reject(

package/browser/session.py

@@ -1216,11 +1216,16 @@ def _depsgraph_placements(frame, depsgraph):
             continue
         if not instance.show_self:
             continue
+        # AN UNSUPPORTED PLACEMENT IS LEFT OUT, NAMED ONCE (`warn`): raising here
+        # lost the whole frame, so one odd instance kept the entire scene from
+        # opening. The native exporter skips the same duplis.
         if (instance.instance_object is not None and instance.object.data != instance.instance_object.data and
                 (instance.object.data is None or geometry.get(source.name) != instance.object.data.as_pointer())):
-            raise NotImplementedError("Depsgraph instance geometry differs from its native source: %s" % source.name)
+            warn("Depsgraph instances of %r are not drawn: their geometry differs from the exported source" % source.name)
+            continue
         if row is None or (source.type == "MESH" and row["mesh"] is None):
-            raise NotImplementedError("Depsgraph instance source has no native exported geometry: %s" % source.name)
+            warn("Depsgraph instances of %r are not drawn: the source has no exported geometry" % source.name)
+            continue
         if row["mesh"] is None:
             if source.type not in ("EMPTY", "CAMERA"):
                 warn("Depsgraph instance %r of type %s is not drawn" % (source.name, source.type))
@@ -1228,7 +1233,8 @@ def _depsgraph_placements(frame, depsgraph):
         owner = instance.parent.original if instance.parent is not None else None
         owner_row = by_name.get(owner.name) if owner is not None else None
         if owner is not None and owner_row is None:
-            raise NotImplementedError("Depsgraph instance owner is not exported: %s" % owner.name)
+            warn("Depsgraph instances owned by %r are not drawn: the owner is not exported" % owner.name)
+            continue
         persistent = list(instance.persistent_id)
         particle_index = persistent[0]
         psys = instance.particle_system
@@ -1687,7 +1693,11 @@ class Session:
             for row in frame["objects"]:
                 if not any(m in graphs for m in row["materials"] if m is not None):
                     continue
-                obj = by_name.get(row["name"])
+                # An instance source from a collection outside the scene is exported
+                # too (`instance_sources`) and shares these graphs; its Object Info
+                # and Particle Info inputs come from the file's own objects. Only
+                # those few rows miss the scene's map.
+                obj = by_name.get(row["name"]) or bpy.data.objects.get(row["name"])
                 if obj is not None:
                     row["object_info"] = {
                         "color": [float(v) for v in obj.color],

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

@@ -7,7 +7,7 @@ import {z} from 'zod';
 import {applyGraphShader, bindGraphDraw, bindPaletteGraph, borrowGraphDrawBinding, graphProgramKey, graphUvChannels, setGraphViewport} from './blender-graph-material';
 import type {CompiledGraph} from './blender-node-graph';
 import {bindNamedUvChannels} from './blender-texture-samplers';
-import {copyWorldVisibility,worldVisibilityShader,worldVisibilityUniforms} from './blender-world-visibility';
+import {WORLD_VISIBILITY,copyWorldVisibility,worldVisibilityShader,worldVisibilityUniforms} from './blender-world-visibility';
 
 const scalar = z.number().finite();
 const color = z.tuple([scalar, scalar, scalar]);
@@ -195,7 +195,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-v6${WORLD_VISIBILITY ? '-atlas' : ''}${graphProgramKey(material)}`;
     material.onBeforeRender = (renderer, scene, camera, geometry, object) => {
       bindNamedUvChannels(material, geometry);
       bindGraphDraw(material, geometry, renderer, scene, camera, object, graphShadow);
@@ -213,12 +213,16 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
         .map(i => (i <= 3 ? `#ifndef USE_UV${i}\nattribute vec2 uv${i};\n#endif` : `attribute vec2 uv${i};`))
         .join('\n') + '\n' + shader.vertexShader;
       Object.assign(shader.uniforms, held);
-      worldVisibilityUniforms(material,shader.uniforms);
-      shader.vertexShader='varying vec3 blenderWorldPosition;\n'+shader.vertexShader;
-      shader.vertexShader=shader.vertexShader.replace('#include <worldpos_vertex>',
-        '#include <worldpos_vertex>\n#if defined(USE_ENVMAP) || defined(USE_SHADOWMAP) || defined(USE_TRANSMISSION)\nblenderWorldPosition=worldPosition.xyz;\n#else\nblenderWorldPosition=(modelMatrix*vec4(transformed,1.)).xyz;\n#endif');
-      shader.fragmentShader=shader.fragmentShader.replace('#include <envmap_physical_pars_fragment>',
-        '#include <envmap_physical_pars_fragment>\n'+worldVisibilityShader);
+      // The sky-light atlas exists in the shader only while it is on: its three
+      // samplers would count against every material's sixteen (WORLD_VISIBILITY).
+      if (WORLD_VISIBILITY) {
+        worldVisibilityUniforms(material,shader.uniforms);
+        shader.vertexShader='varying vec3 blenderWorldPosition;\n'+shader.vertexShader;
+        shader.vertexShader=shader.vertexShader.replace('#include <worldpos_vertex>',
+          '#include <worldpos_vertex>\n#if defined(USE_ENVMAP) || defined(USE_SHADOWMAP) || defined(USE_TRANSMISSION)\nblenderWorldPosition=worldPosition.xyz;\n#else\nblenderWorldPosition=(modelMatrix*vec4(transformed,1.)).xyz;\n#endif');
+        shader.fragmentShader=shader.fragmentShader.replace('#include <envmap_physical_pars_fragment>',
+          '#include <envmap_physical_pars_fragment>\n'+worldVisibilityShader);
+      }
       shader.fragmentShader = `uniform float blenderCoatIor;
         uniform vec3 blenderWorldExtinction;
         vec3 blenderInfiniteTransmission() { return vec3(
@@ -263,11 +267,13 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
         .replace('rectAreaLight = rectAreaLights[ i ];',
           'rectAreaLight = rectAreaLights[ i ]; rectAreaLight.color *= exp(-blenderWorldExtinction * length(rectAreaLight.position-geometryPosition));')
         .replace('getAmbientLightIrradiance( ambientLightColor )', 'getAmbientLightIrradiance( ambientLightColor ) * blenderInfiniteTransmission()');
-      const environment = THREE.ShaderChunk.lights_fragment_maps
+      const visible = WORLD_VISIBILITY ? THREE.ShaderChunk.lights_fragment_maps
         .replace('getIBLIrradiance( geometryNormal )',
           'blenderWorldIrradiance( geometryNormal, getIBLIrradiance( geometryNormal ) )')
         .replaceAll(/(getIBL(?:Radiance|AnisotropyRadiance)\([^;]+\))/g,
           '$1 * blenderWorldReflectionVisibility(geometryViewDir,geometryNormal,material.roughness)')
+        : THREE.ShaderChunk.lights_fragment_maps;
+      const environment = visible
         .replaceAll(/(getIBL(?:Irradiance|Radiance|AnisotropyRadiance)\([^;]+\))/g, '$1 * blenderInfiniteTransmission()');
       shader.fragmentShader = shader.fragmentShader.replace('#include <lights_physical_fragment>', physical)
         .replace('#include <lights_fragment_begin>', lighting)

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

@@ -27,7 +27,7 @@ import {
   worldSchema,
 } from './blender-runtime-lighting';
 import { fitModelDirectionalShadow, visibleShadowReceivers } from './blender-runtime-shadows';
-import {BlenderWorldVisibility,bindWorldVisibility} from './blender-world-visibility';
+import {BlenderWorldVisibility,WORLD_VISIBILITY,bindWorldVisibility} from './blender-world-visibility';
 import { volumeMesh, volumeSchema } from './blender-runtime-volume';
 import { applyPhysicalMaterial, applyWorldExtinction, physicalMaterialSchema } from './blender-physical-material';
 import { prepareGraphGeometry, setMaterialGraph } from './blender-graph-material';
@@ -58,16 +58,6 @@ const SAVED_SHADING = {
   MATERIAL: 'preview',
   RENDERED: 'rendered',
 } as const;
-/** SKY-LIGHT OCCLUSION (`blender-world-visibility.ts`) IS OFF IN EVERY VIEW. Its
- *  sixteen 512-square tiles each span the whole scene, so a 360 m level gets
- *  about a metre per texel, and each lookup is one nearest texel answering
- *  yes or no. Faceted surfaces then occlude their own sky at random pixels --
- *  static on every polygon in Rendered and Play -- and narrow specular lobes,
- *  dominated by a few of the sixteen directions, plausibly flash as the camera
- *  moves. It measured right in a closed room a few metres across. Turn it back
- *  on once its lookups are filtered and its resolution follows the scene's size
- *  (docs/BLENDER-RENDERING-PARITY.md lists the rest). */
-const WORLD_VISIBILITY = false;
 const scalar = z.number().finite();
 const point = z.tuple([scalar, scalar, scalar]);
 const edge = z.tuple([z.number().int().nonnegative(), z.number().int().nonnegative()]);

package/browser/three/blender-world-visibility.ts

@@ -4,6 +4,20 @@
  * directional quadrature, not indirect light transport. */
 import * as THREE from 'three';
 
+/** SKY-LIGHT OCCLUSION IS OFF IN EVERY VIEW, and compiled out of every material. Its
+ *  sixteen 512-square tiles each span the whole scene, so a 360 m level gets
+ *  about a metre per texel, and each lookup is one nearest texel answering
+ *  yes or no. Faceted surfaces then occlude their own sky at random pixels --
+ *  static on every polygon in Rendered and Play -- and narrow specular lobes,
+ *  dominated by a few of the sixteen directions, plausibly flash as the camera
+ *  moves. It measured right in a closed room a few metres across. Turn it back
+ *  on once its lookups are filtered and its resolution follows the scene's size
+ *  (docs/BLENDER-RENDERING-PARITY.md lists the rest). Off, the view neither
+ *  syncs nor draws the atlas (`blender-runtime-view.ts`), and physical
+ *  materials declare none of its samplers (`blender-physical-material.ts`):
+ *  three of them counted against a material's sixteen even while unused. */
+export const WORLD_VISIBILITY = false;
+
 const SAMPLE_COUNT=16, TILES=4, TILE_SIZE=512;
 type Segment={mesh:THREE.Mesh; geometry:THREE.BufferGeometry; position:THREE.BufferAttribute|THREE.InterleavedBufferAttribute;
  index:THREE.BufferAttribute|null; positionVersion:number; indexVersion:number; start:number; count:number;

package/package.json

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