@volter/blender-engine 0.1.125 → 0.1.127

package/browser/session.py

@@ -1405,10 +1405,10 @@ class Session:
         if hasattr(_blender_web, "memory_reset_peak"):
             _blender_web.memory_reset_peak()
         if hasattr(_blender_web, "export_frame_chunked"):
-            exported = _blender_web.export_frame_chunked(json.dumps(options),
+            exported = _blender_web.export_frame_chunked(json.dumps(options, ensure_ascii=False),
                 lambda: _asked({"checkpoint": "native-export"}))
         else:
-            exported = _blender_web.export_frame(json.dumps(options))
+            exported = _blender_web.export_frame(json.dumps(options, ensure_ascii=False))
         _mark("export:door")
         frame = json.loads(exported)
         del exported
@@ -1627,7 +1627,9 @@ class Session:
                 if kind == "image" and self._send_encoded_image(key, frame["images"][key]):
                     continue
                 options["key"] = key
-                piece = json.loads(door(json.dumps(options)))
+                # The native door reads UTF-8 keys. Preserve Unicode datablock
+                # names rather than turning them into JSON \u escape sequences.
+                piece = json.loads(door(json.dumps(options, ensure_ascii=False)))
                 if piece.get("error"):
                     raise RuntimeError("Blender export door: %s" % piece["error"])
                 frame["warnings"].extend(piece.get("warnings", []))
@@ -5060,11 +5062,14 @@ def dispatch(request):
     op = request.get("op")
     if op not in _WATCHED_OPS:
         return _dispatch_request(request)
-    before = {o.name for o in bpy.data.objects}
+    # ID.session_uid survives renames, reallocations and file reloads.
+    # Names alone falsely reported an ordinary rename as a deleted object.
+    before = {o.session_uid: o.name for o in bpy.data.objects}
     try:
         return _dispatch_request(request)
     finally:
-        removed = before - {o.name for o in bpy.data.objects}
+        remaining = {o.session_uid for o in bpy.data.objects}
+        removed = [name for uid, name in before.items() if uid not in remaining]
         if removed:
             cause = {k: request[k] for k in ("label", "property", "column", "direction", "token", "path")
                      if k in request}

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

@@ -159,6 +159,16 @@ export function syncPhysicalDrawMaterial(source: THREE.Material, target?: THREE.
   return copy;
 }
 
+/** A copy of a presented material that ONE object can wear and a script can recolour (Model
+ *  Play's `tint`/`setOpacity`): the same hooks, physical values, maps and private uniforms,
+ *  drawn from the material's constants -- `color`, `opacity`, `map`, `emissive` -- with no
+ *  node graph, since a graph's Base Color and Alpha replace those constants in the shader.
+ *  Null for a material that is not one of the presenter's. The caller owns and disposes it. */
+export function ownedSurfaceMaterial(source: THREE.Material): THREE.MeshPhysicalMaterial | null {
+  if (!(source instanceof THREE.MeshPhysicalMaterial) || !uniforms.has(source) || !materialDrawHooksSupported(source)) return null;
+  return graphShadow(source);
+}
+
 export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, input?: Physical,
   clips: {map?: boolean; roughness?: boolean; normal?: boolean} = {}): void {
   const data = input ?? defaults;

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

@@ -705,8 +705,8 @@ export class BlenderRuntimeView {
   /** The camera the VIEWPORT is held in render lighting through (Blender's Rendered shading),
    *  or null when the viewport shows modeling lighting. See {@link holdRendered}. */
   private heldRendered: (() => THREE.Camera) | null = null;
-  /** Material Preview can use scene lighting while retaining viewport visibility. */
-  private heldVisibility: 'viewport' | 'render' = 'render';
+  /** Editing retains viewport visibility in every shading mode; Play selects render visibility. */
+  private heldVisibility: 'viewport' | 'render' = 'viewport';
   /** What the World was last composed for ({@link worldKeyFor}), or null when it is cleared:
    *  composing rebuilds its textures, so it happens only when the key changes. */
   private worldApplied: string | null = null;
@@ -1175,13 +1175,14 @@ export class BlenderRuntimeView {
   /**
    * BLENDER'S RENDERED SHADING: the viewport held in the lighting a render photographs with
    * ({@link setRendered}) — the scene's own lights, its World behind and around the model,
-   * `hide_render` visibility and shadows — seen through `drawCamera()`, the camera the stage
+   * viewport visibility and shadows — seen through `drawCamera()`, the camera the stage
    * draws with (orthographic in an orthographic view). `null` returns the viewport to modeling.
-   * Material Preview passes viewport visibility independently of its lighting choices.
+   * Render visibility is explicitly selected for a detached Play view; editing
+   * keeps viewport visibility independently of its shading and lighting choices.
    * A render taken meanwhile ends back in this state rather than in modeling.
    */
   private heldSceneLighting: { world: boolean; lights: boolean } | undefined;
-  holdRendered(drawCamera: (() => THREE.Camera) | null, sceneLighting?: { world: boolean; lights: boolean }, visibility: 'viewport' | 'render' = 'render'): void {
+  holdRendered(drawCamera: (() => THREE.Camera) | null, sceneLighting?: { world: boolean; lights: boolean }, visibility: 'viewport' | 'render' = 'viewport'): void {
     if (drawCamera === this.heldRendered && sceneLighting?.world === this.heldSceneLighting?.world && sceneLighting?.lights === this.heldSceneLighting?.lights && visibility === this.heldVisibility) return;
     this.heldRendered = drawCamera;
     this.heldSceneLighting = sceneLighting;
@@ -1193,7 +1194,8 @@ export class BlenderRuntimeView {
   /** Prepare a rendered viewport before revealing its first frame, using the
    * same lighting/image/World readiness as a photograph. Call after the stage
    * has attached the root to its scene. */
-  async prepareRendered(camera: THREE.Camera): Promise<void> {
+  async prepareRendered(camera: THREE.Camera, visibility: 'viewport' | 'render' = 'viewport'): Promise<void> {
+    this.heldVisibility = visibility;
     await this.applyRendered(true, camera);
   }
 
@@ -1276,7 +1278,9 @@ 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() : []);
+    // Opaque material ranges also preserve Rendered's materials and shadows.
+    // The range planner itself excludes transparency and custom shaders.
+    this.materialRanges.setObjects(this.drawBatching ? this.objects.values() : []);
   }
 
   /** Presentation-only comparison door; never changes Blender or its data. */

package/browser/three/blender-texture-samplers.ts

@@ -3,6 +3,16 @@ import {presenterChanged} from './blender-presenter-change';
 
 export type TextureExtension = 'REPEAT' | 'EXTEND' | 'MIRROR' | 'CLIP';
 
+/** Texture.copy requests an upload even when an encoded image has not yet
+ * decoded. Keep the sampler object (and its shared Source) stable, but defer
+ * that request until the owner actually supplies image data. Graph sampler
+ * filter changes go through this same setter while decoding is pending. */
+class PendingImageSampler extends THREE.Texture {
+  override set needsUpdate(value: boolean) {
+    if (value && this.image) super.needsUpdate = value;
+  }
+}
+
 /** A shared material may draw meshes whose named layers have different
  * channel positions. Resolve at Three's per-draw hook, before program choice. */
 export function bindNamedUvChannels(material: THREE.MeshPhysicalMaterial, geometry: THREE.BufferGeometry): void {
@@ -40,13 +50,17 @@ export class BlenderTextureSamplers {
     let binding = this.bindings.get(key);
     if (!binding || binding.source !== source) {
       this.delete(key);
-      binding = {source, texture: source.clone(), version: -1, disposed: false};
+      // Ready raster/DataTextures keep their own subtype's clone behavior.
+      // Only an empty encoded-image Texture with an owner decode promise
+      // needs the gate; an unexplained missing image keeps its diagnostics.
+      const texture = !source.image && ready ? new PendingImageSampler().copy(source) : source.clone();
+      binding = {source, texture, version: -1, disposed: false};
       this.bindings.set(key, binding);
       const held = binding;
       // The owner awaits and reports decode failures. Avoid an unhandled
       // rejection here, and never upload a clone removed during the decode.
       if (ready) void ready.then(() => {
-        if (!held.disposed) {
+        if (!held.disposed && source.image) {
           held.texture.needsUpdate = true;
           held.version = source.version;
           presenterChanged();

package/browser/worker.ts

@@ -541,10 +541,15 @@ async function stageProjectFiles(files_: BlenderFiles, project: string): Promise
       say(`${file.path}: HTTP ${answer.status}`);
       continue;
     }
+    // The index can precede an append or rewrite. Stream the response's own size,
+    // not an earlier index entry's size; keep the old stamp so the next sync rechecks.
+    const declaredSize = Number(answer.headers.get('content-length'));
+    const responseSize = answer.headers.has('content-length') && Number.isSafeInteger(declaredSize) && declaredSize >= 0
+      ? declaredSize : file.size;
     const dir = path.slice(0, path.lastIndexOf('/'));
     if (dir) await files_.mkdirTree(dir);
     if (files_.writeFileStream && answer.body) {
-      await files_.writeFileStream(path, loadCheckpoint ? checkpointStream(answer.body, () => loadCheckpoint!("file-import")) : answer.body, file.size);
+      await files_.writeFileStream(path, loadCheckpoint ? checkpointStream(answer.body, () => loadCheckpoint!("file-import")) : answer.body, responseSize);
     } else {
       await files_.writeFile(path, new Uint8Array(await answer.arrayBuffer()));
     }

package/package.json

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