@volter/blender-engine 0.1.7 → 0.1.9

package/browser/blender-emscripten-engine.mts

@@ -133,9 +133,37 @@ function moduleFiles(module: BlenderModule): BlenderFiles {
   };
 }
 
+/**
+ * BLENDER'S ARTIFACTS ARE FETCHED ONCE PER BUILD. The wasm (86 MB decoded), the
+ * `.data` package (53 MB) and the Essentials payload are immutable for a build,
+ * and the page keeps them in Cache Storage under the digest the artifact door
+ * reports, so a later open reads them at the browser's own speed instead of
+ * from the editor's server. Measured in the browser substrate, where that
+ * server runs in the tab: the three took 7.2 s per open (4.2 s for the wasm
+ * alone), about half of it decoding their brotli. A file the door gives no
+ * digest for is fetched as it always was.
+ */
+const ARTIFACT_CACHE = 'volter-blender-artifacts';
+
+async function cachedArtifact(file: string, digest: string | undefined): Promise<Response> {
+  const url = artifactUrl(file);
+  if (!digest || typeof caches === 'undefined') return fetch(url);
+  const key = `${url}?sha256=${digest}`;
+  const cache = await caches.open(ARTIFACT_CACHE);
+  const hit = await cache.match(key);
+  if (hit) return hit;
+  const response = await fetch(url);
+  if (!response.ok) return response;
+  // One build's bytes per file: an older build's are dropped as this one lands.
+  for (const old of await cache.keys()) if (old.url.startsWith(`${url}?sha256=`) && old.url !== key) await cache.delete(old);
+  const kept = new Response(await response.blob(), { headers: { 'content-type': response.headers.get('content-type') ?? 'application/octet-stream' } });
+  await cache.put(key, kept.clone());
+  return kept;
+}
+
 export async function startEmscriptenBlenderEngine(
   options: BlenderEngineOptions,
-  _status: BlenderArtifactStatus,
+  status: BlenderArtifactStatus,
 ): Promise<BlenderEngine> {
   if (!self.crossOriginIsolated)
     throw new Error(
@@ -144,7 +172,17 @@ export async function startEmscriptenBlenderEngine(
         'every response). This worker reports crossOriginIsolated=false.',
     );
   const glueUrl = artifactUrl('blender_browser.js');
-  const factory = await loadFactory(glueUrl);
+  const digests = status.digests ?? {};
+  // The `.data` package is handed to the glue whole (`getPreloadedPackage`),
+  // so it is read before the module starts; the wasm streams in beside it.
+  const [factory, preloaded] = await Promise.all([
+    loadFactory(glueUrl),
+    cachedArtifact('blender_browser.data', digests['blender_browser.data']).then(async (response) => {
+      if (!response.ok) throw new Error(`blender_browser.data: HTTP ${response.status}`);
+      return response.arrayBuffer();
+    }),
+  ]);
+  let bootError: unknown = null;
   const started = performance.now();
   let readyLine: string | null = null;
   // BLENDER'S OWN STREAMS ARE PAGE OUTPUT, NOT EDITOR-CONSOLE CONDITIONS.
@@ -164,6 +202,16 @@ export async function startEmscriptenBlenderEngine(
   const module = await factory({
     arguments: ['--background', '--factory-startup', '--python', SESSION_SCRIPT],
     locateFile: (file: string) => artifactUrl(file),
+    getPreloadedPackage: () => preloaded,
+    instantiateWasm: (imports: WebAssembly.Imports, receive: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void) => {
+      void (async () => {
+        const response = await cachedArtifact('blender_browser.wasm', digests['blender_browser.wasm']);
+        if (!response.ok) throw new Error(`blender_browser.wasm: HTTP ${response.status}`);
+        const { instance, module: compiled } = await WebAssembly.instantiateStreaming(response, imports);
+        receive(instance, compiled);
+      })().catch((error: unknown) => { bootError = error; });
+      return {};
+    },
     // The pthreads load the SAME patched glue this worker just evaluated.
     mainScriptUrlOrBlob: glueUrl,
     print: (text: string) => say('log', text),
@@ -209,7 +257,10 @@ export async function startEmscriptenBlenderEngine(
   });
   // `main()` runs on a pthread (`-sPROXY_TO_PTHREAD`), so the factory resolves
   // long before the session exists. The ready line is what says it does.
-  while (readyLine === null) await sleep(5);
+  while (readyLine === null) {
+    if (bootError) throw bootError instanceof Error ? bootError : new Error(String(bootError));
+    await sleep(5);
+  }
   const bootMs = performance.now() - started;
   const banner = JSON.parse(readyLine) as { blender: string; engines: string[] };
 
@@ -268,7 +319,7 @@ export async function startEmscriptenBlenderEngine(
 
   const files = moduleFiles(module);
   FS.chmod('/bw/datafiles', 0o755);
-  await mountEssentials(files);
+  await mountEssentials(files, digests['essentials.bin']);
   const { request } = openSessionChannel(files, options);
 
   return {
@@ -293,9 +344,9 @@ export async function startEmscriptenBlenderEngine(
 /** Assets are data, not a second engine. Ship them separately so a data update
  * does not relink the 86 MB Wasm binary. Both payload and per-file bounds are
  * checked before anything enters Blender's filesystem. */
-async function mountEssentials(files: BlenderFiles): Promise<void> {
+async function mountEssentials(files: BlenderFiles, digest: string | undefined): Promise<void> {
   const [indexResponse, payloadResponse] = await Promise.all([
-    fetch(artifactUrl('essentials.json')), fetch(artifactUrl('essentials.bin')),
+    fetch(artifactUrl('essentials.json')), cachedArtifact('essentials.bin', digest),
   ]);
   if (!indexResponse.ok || !payloadResponse.ok)
     throw new Error(`Blender Essentials assets are missing (${indexResponse.status}/${payloadResponse.status})`);

package/browser/blender-engine.mts

@@ -179,6 +179,8 @@ export interface BlenderArtifactStatus {
   encoded: Record<string, 'br'>;
   /** Why it is unavailable, named. Empty when it is available. */
   missing: string[];
+  /** Emscripten: each file's SHA-256 as it decodes, the key a page keeps it under. */
+  digests?: Record<string, string>;
   /** WALI only: the `sha256-` SRI of `blender.wasm`, which the program loader
    *  requires for any non-blob URL. */
   integrity?: string;

package/browser/runtime.ts

@@ -434,10 +434,10 @@ export class BlenderRuntime {
     if (this.#terminated) return Promise.resolve();
     if (this.#stopping) return this.#stopping;
     this.#stopping = (async () => {
-      if (this.#started) {
-        await this.#started;
-        await this.#request({ op: 'flush-document' }, true);
-      }
+      // A start that failed opened no document, so there is nothing to flush: its stale
+      // rejection must not refuse every later close.
+      const started = this.#started ? await this.#started.then(() => true, () => false) : false;
+      if (started) await this.#request({ op: 'flush-document' }, true);
       this.terminate();
     })().catch(error => {
       this.#stopping = null;
@@ -470,7 +470,7 @@ export class BlenderRuntime {
    * A `present` is not counted separately — the worker only presents from
    * inside a call this meter is already holding open, and the page-side cost of
    * displaying the frame is main-thread time, which is the long-task observer's
-   * subject (`packages/editor/src/blender-tab-metrics.ts`).
+   * subject (the host's `worker-call-metrics.ts`).
    */
   metrics(now: number = performance.now()): BlenderCallMetrics {
     let oldest: number | null = null;

package/browser/session.py

@@ -523,6 +523,10 @@ def draw_camera(obj):
         "shift_x": float(camera.shift_x),
         "shift_y": float(camera.shift_y),
         "matrix": [[float(v) for v in row] for row in obj.matrix_world],
+        # What the 3D View's camera view darkens outside the frame (`drawviewborder`).
+        "passepartout": float(camera.passepartout_alpha) if camera.show_passepartout else 0.0,
+        # The size the overlay draws the camera at (`Camera.display_size`, `cam->drawsize`).
+        "display_size": float(camera.display_size),
     }
 
 
@@ -732,6 +736,107 @@ def _refusal(node):
     return None
 
 
+
+def _empty_display(obj):
+    """An empty's display (`overlay_empty.hh`): its type and size, and for an image empty the
+    picture, where it sits on the object (`empty_image_offset`), how it meets depth, which side
+    shows, in which projections, its opacity when it blends, the object colour the picture is
+    multiplied by (`ucolor`) and whether the image stores premultiplied alpha."""
+    display = {"display": obj.empty_display_type, "size": float(obj.empty_display_size)}
+    if obj.empty_display_type == "IMAGE":
+        display["image"] = {
+            "name": obj.data.name if obj.data is not None else None,
+            "offset": [float(v) for v in obj.empty_image_offset],
+            "depth": obj.empty_image_depth,
+            "side": obj.empty_image_side,
+            "perspective": bool(obj.show_empty_image_perspective),
+            "orthographic": bool(obj.show_empty_image_orthographic),
+            "axis_aligned": bool(obj.show_empty_image_only_axis_aligned),
+            "opacity": float(obj.color[3]) if obj.use_empty_image_alpha else None,
+            "tint": [float(v) for v in obj.color[:3]],
+            "premultiplied": obj.data is not None and obj.data.alpha_mode == "PREMUL",
+        }
+    return display
+
+
+def _saved_view():
+    """The 3D View the file saved, which is where Blender opens it: the `Modeling` workspace's
+    (this editor's Model workspace is Blender's Modeling), else the first 3D View any screen
+    holds. `RegionView3D`'s pivot, rotation (view to world, `(w, x, y, z)`), distance and
+    projection (`PERSP`, `ORTHO`, or `CAMERA` for a view through the scene camera), and the
+    `View3D`'s lens."""
+    workspace = bpy.data.workspaces.get("Modeling")
+    screens = list(workspace.screens) if workspace is not None else []
+    screens.extend(bpy.data.screens)
+    for screen in screens:
+        for area in screen.areas:
+            if area.type != "VIEW_3D":
+                continue
+            space = area.spaces[0]
+            region = space.region_3d
+            return {
+                "lens": float(space.lens),
+                "location": [float(v) for v in region.view_location],
+                "rotation": [float(v) for v in region.view_rotation],
+                "distance": float(region.view_distance),
+                "perspective": region.view_perspective,
+            }
+    return None
+
+
+def _subject_line(scene, view_layer):
+    """The 3D Viewport's second overlay line, as `draw_selected_name` (`view3d_draw.cc`) writes it,
+    less the two parts that follow the playhead: the tab draws `(frame)` and the marker on it
+    from the frame it is showing, which during playback is not `frame_current` (written once, on
+    pause). Here: in Object Mode (or with nothing active) the active collection and a bar, then
+    the active object; outside Object Mode its data's name; the active edit or pose bone, or the
+    active shape key (` (Soloed)` when pinned). The scene's markers go with it, in list order,
+    for `BKE_scene_find_marker_name`. Blender tints the line on a keyframe; that colour is not
+    carried, and the ` (Viewer)` suffix belongs to a viewer path this tab does not show."""
+    parts = []
+    ob = view_layer.objects.active
+    if ob is None or ob.mode == "OBJECT":
+        # `BKE_collection_ui_name_get`: the master collection reads "Scene Collection", which is
+        # also what its RNA name returns.
+        parts.append(" " + view_layer.active_layer_collection.collection.name)
+        if ob is not None:
+            parts.append(" |")
+    if ob is not None:
+        parts.append(" " + ob.name)
+        if ob.mode != "OBJECT" and ob.data is not None:
+            parts.append(" | " + ob.data.name)
+        if ob.type == "ARMATURE":
+            arm = ob.data
+            if ob.mode == "EDIT":
+                if arm.edit_bones.active is not None:
+                    parts.append(" : " + arm.edit_bones.active.name)
+            elif ob.mode == "POSE" and arm.bones.active is not None and _bone_shown(arm.bones.active):
+                parts.append(" : " + arm.bones.active.name)
+        elif ob.type in ("MESH", "LATTICE", "CURVE"):
+            if ob.type == "MESH" and ob.mode == "WEIGHT_PAINT":
+                rig = ob.find_armature()
+                if rig is not None and rig.mode == "POSE":
+                    bone = rig.data.bones.active
+                    if bone is not None and _bone_shown(bone):
+                        parts.append(" : " + bone.name)
+            key = ob.active_shape_key if getattr(ob.data, "shape_keys", None) is not None else None
+            if key is not None:
+                parts.append(" : " + key.name)
+                if ob.show_only_shape_key:
+                    parts.append(" (Soloed)")
+    return {
+        "frame": int(scene.frame_current),
+        "body": "".join(parts),
+        "markers": [[int(m.frame), m.name] for m in scene.timeline_markers],
+    }
+
+
+def _bone_shown(bone):
+    """`ANIM_bonecoll_is_visible_actbone`: a bone in no collection, or in a visible one."""
+    collections = getattr(bone, "collections", None)
+    return not collections or any(c.is_visible for c in collections)
+
+
 class _GraphRefusal(Exception):
     pass
 
@@ -1231,9 +1336,13 @@ class Session:
         """
         scene = bpy.context.scene
         graphs = material_graphs(scene)
+        # An IMAGE EMPTY's picture travels with the graphs' images: the overlay draws it
+        # (`overlay_empty.hh` `image_sync`).
+        empty_images = {obj.data.name for obj in scene.objects
+                        if obj.type == "EMPTY" and obj.empty_display_type == "IMAGE" and obj.data is not None}
         options = {"session": self.session, "evaluate": True, "known": self._known,
                    "graph_materials": sorted(graphs),
-                   "graph_images": sorted({i for g in graphs.values() for i in g["images"]}),
+                   "graph_images": sorted({i for g in graphs.values() for i in g["images"]} | empty_images),
                    "graph_generated": sorted(n for n, g in graphs.items() if g["generated"])}
         # THE ARENA IS WRITTEN BEFORE THE ASK, and on a skew whose channel is
         # an ordered stream of filesystem patches that is the whole
@@ -1288,14 +1397,55 @@ class Session:
                 default_color = getattr(getattr(data, "color_attributes", None), "default_color_name", "")
                 if default_color:
                     row["default_color"] = default_color
+        # THE VIEWPORT DISPLAY of each material -- what Blender's Solid shading colours a surface
+        # by (`View3DShading.color_type` MATERIAL reads `Material.diffuse_color`, `roughness`,
+        # `metallic`; `workbench_world_light_lib.glsl`), not its node graph.
+        for entry in frame["materials"].values():
+            material = bpy.data.materials.get(entry.get("name", ""))
+            if material is not None:
+                entry["viewport"] = {
+                    "color": [float(v) for v in material.diffuse_color],
+                    "roughness": float(material.roughness),
+                    "metallic": float(material.metallic),
+                }
         frame["world"] = draw_world(scene)
         frame["cameras"] = {
             obj.name: draw_camera(obj) for obj in scene.objects if obj.type == "CAMERA"
         }
         frame["volumes"] = {}
+        # THE CAMERA A CAMERA VIEW LOOKS THROUGH (`view3d.view_camera`: the scene's, else a
+        # camera that is active, else the view layer's first) and the frame it draws, the
+        # render's shape with its pixel aspect.
+        render = scene.render
+        frame["camera_view"] = {
+            "scene_camera": scene.camera.name if scene.camera is not None else None,
+            "view_layer_cameras": [o.name for o in bpy.context.view_layer.objects if o.type == "CAMERA"],
+            "aspect": (render.resolution_x * render.pixel_aspect_x) / max(render.resolution_y * render.pixel_aspect_y, 1e-6),
+        }
+        # THE 3D CURSOR, `Scene.cursor`: where Blender's own "to 3D Cursor"
+        # operators place and snap, drawn by the tab as Blender's overlay does
+        # (`overlay_cursor.hh`). Its MATRIX, because the overlay's axis lines
+        # turn with the cursor's rotation in whichever `rotation_mode` it has.
+        frame["cursor"] = [[float(v) for v in row] for row in scene.cursor.matrix]
         # THE OVERLAYS, after the door's frame stands: `_weights` reads the
         # mesh's own revision out of it (see there), so it cannot run before.
         view_layer = bpy.context.view_layer
+        # THE VIEWPORT'S SUBJECT LINE and the units its grid step is named in: Blender composes
+        # both from the scene, so they come from here (`_subject_line`).
+        frame["subject"] = _subject_line(scene, view_layer)
+        # A LIGHT'S DISTANCES, for the overlay's direction line (`overlay_light.hh`: from
+        # `clipsta` to `att_dist` down the light's -Z, for a spot or an area light).
+        frame["light_distances"] = {
+            light.name: [float(light.shadow_buffer_clip_start), float(light.cutoff_distance)]
+            for light in bpy.data.lights
+        }
+        # WHAT THE OVERLAY DRAWS FOR AN EMPTY (`overlay_empty.hh`): its display type and size.
+        frame["empties"] = {obj.name: _empty_display(obj) for obj in scene.objects if obj.type == "EMPTY"}
+        frame["view"] = _saved_view()
+        frame["units"] = {
+            "system": scene.unit_settings.system,
+            "scale_length": float(scene.unit_settings.scale_length),
+        }
         frame["armatures"] = _armatures(view_layer)
         frame["weights"] = _weights(scene, view_layer, frame, self._known)
         warnings = list(frame.get("warnings", ()))
@@ -1343,16 +1493,15 @@ class Session:
             # its value also depends on native undo initialization/checkpoints.
             "dirty": bool(bpy.data.is_dirty),
         }
-        # A PRESENT IS WHAT LEAVES THE DOCUMENT STALE, and the predicate is the
-        # present itself rather than what the frame shipped. `columns`/`images`
-        # above count BYTES THAT CROSSED, which is a different question: a MOVE
-        # ships zero columns (the comment above says so) and a DELETION ships
-        # nothing at all, yet both are changes a document that loses them is
-        # wrong. The cost this predicate could waste is bounded by the tab's
-        # one-save-per-idle-second debounce, and `save_document` still asks
-        # Blender whether anything actually changed before it writes.
-        if self.document is not None:
-            self.save_due = True
+        # A PRESENT DOES NOT MAKE THE DOCUMENT STALE; a request that can change
+        # the model does (`mark_changed`, from `dispatch`). The predicate was the
+        # present itself, and a present also runs with no change behind it --
+        # opening the document, rebinding its view. MEASURED 2026-09-24 on
+        # `arena`: opening a Model document and doing nothing rewrote its
+        # `.blend` with 556 bytes changed, so a file a person only looked at read
+        # as modified. `columns`/`images` above stay the wrong question for the
+        # same reason as before: a MOVE ships zero columns and a DELETION ships
+        # nothing, and both come from a request `mark_changed` sees.
         for key, mesh in frame["meshes"].items():
             self._known["mesh:" + key] = mesh["revision"]
         for name, image in frame["images"].items():
@@ -1540,6 +1689,12 @@ class Session:
                 "objects": len(bpy.data.objects),
                 "size": os.path.getsize(self.document)}
 
+    def mark_changed(self):
+        """A request that can change the model ran: the next present carries
+        `saveDue`, and the tab saves after an idle second."""
+        if self.document is not None:
+            self.save_due = True
+
     def save_document(self):
         """Write the document -- Blender's own format, by Blender's own operator.
 
@@ -1625,11 +1780,11 @@ class Session:
         #
         # It was briefly used to skip a redundant write, and it froze the
         # document after its first save -- a reopened session could model all
-        # day and never write again. The predicate is `_present`'s instead: a
-        # present is what leaves the document stale. Coarser (a read-only
-        # script rewrites the file once), bounded by the tab's idle-second
-        # debounce, and it cannot miss a change. The reading still rides in the
-        # answer, as an instrument.
+        # day and never write again. The predicate is `mark_changed`'s instead:
+        # a request that can change the model ran. Coarser than a diff (a
+        # read-only script rewrites the file once), bounded by the tab's
+        # idle-second debounce, and it cannot miss a change. The reading still
+        # rides in the answer, as an instrument.
         dirty = bool(bpy.data.is_dirty)
         existed = os.path.exists(self.document)
         directory = os.path.dirname(self.document)
@@ -4620,7 +4775,32 @@ def outliner_set(path, column, value):
         % (column, target.bl_rna.identifier, path))
 
 
+# REQUESTS THAT CAN REMOVE OBJECTS, watched: a removal is reported with its cause, because an
+# object that disappears without a named act is the loss this session must never hide. A scene
+# was once found emptied and saved over its file by a burst of three edits at boot, with nothing
+# recording which requests they were.
+_WATCHED_OPS = ("execute", "rna-set", "outliner-set", "history-step")
+
+
 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}
+    try:
+        return _dispatch_request(request)
+    finally:
+        removed = before - {o.name for o in bpy.data.objects}
+        if removed:
+            cause = {k: request[k] for k in ("label", "property", "column", "direction", "token", "path")
+                     if k in request}
+            if op == "execute":
+                cause["code"] = str(request.get("code", ""))[:160]
+            _say("@@VGAI-WARN %s removed objects %s (%s); %d remain" % (
+                op, sorted(removed), json.dumps(cause), len(bpy.data.objects)))
+
+
+def _dispatch_request(request):
     op = request.get("op")
     if op == "history-begin":
         HISTORY.begin()
@@ -4640,6 +4820,7 @@ def dispatch(request):
     if op == "history-step":
         if request["direction"] not in ("undo", "redo"):
             raise ValueError("Unknown history direction")
+        SESSION.mark_changed()
         return HISTORY.move(request["token"], request["direction"])
     mutation = op in ("execute", "rna-set", "outliner-set") and request.get("history", True)
     if not mutation:
@@ -4675,6 +4856,7 @@ def _dispatch(request):
         # Arbitrary Python can partially mutate before throwing. Once execution
         # starts it needs a checkpoint; capability refusals above do not.
         HISTORY.changed()
+        SESSION.mark_changed()
         answer = execute(request["code"])
         # Every mutation is presented, the rule: the Model
         # document is what the agent is looking at.
@@ -4723,6 +4905,7 @@ def _dispatch(request):
     if op == "outliner":
         return rna_outliner(request.get("selected"))
     if op == "outliner-set":
+        SESSION.mark_changed()
         answer = outliner_set(request["path"], request["column"], request["value"])
         # A COLUMN IS A WRITE, and a write presents -- the same rule `rna-set`
         # follows: hiding an object in the Outliner must change what the
@@ -4743,6 +4926,7 @@ def _dispatch(request):
                  "showing the state before it: " + repr(thrown))
         return answer
     if op == "rna-set":
+        SESSION.mark_changed()
         answer = rna_set(request["path"], request["property"], request["value"],
                          request.get("index"))
         # A WRITE IS PRESENTED, exactly as `execute` presents: the Model

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

@@ -143,6 +143,11 @@ export function graphProgramKey(material: THREE.MeshPhysicalMaterial): string {
   return `${binding.compiled.key}|${JSON.stringify(binding.channels)}`;
 }
 
+/** The UV channels the material's graph reads on the current draw. */
+export function graphUvChannels(material: THREE.MeshPhysicalMaterial): number[] {
+  return Object.values(bindings.get(material)?.channels ?? {});
+}
+
 /** The channel each named UV layer is in on `geometry` (a layer the mesh
  *  lacks reads zeros from channel 9, Blender's missing attribute). */
 function channelsFor(compiled: CompiledGraph, geometry: THREE.BufferGeometry): Record<string, number> {
@@ -305,7 +310,6 @@ export function applyGraphShader(material: THREE.MeshPhysicalMaterial, shader: T
   const {compiled, channels} = binding;
   Object.assign(shader.uniforms, binding.uniforms, {blenderViewport: {value: viewport}});
   const attribute = (channel: number) => (channel === 0 ? 'uv' : `uv${channel}`);
-  const guards = [1, 2, 3].map(i => `#ifndef USE_UV${i}\nattribute vec2 uv${i};\n#endif`).join('\n');
   const varyings = `varying vec3 vBlenderObjectPosition;
 varying vec3 vBlenderObjectNormal;
 varying vec3 vBlenderWorldPosition;
@@ -314,7 +318,7 @@ varying vec3 vBlenderOrco;
 ${compiled.attributes.map(n => `varying vec4 ${attributeVarying(n)};`).join('\n')}
 ${compiled.uvs.map(n => `varying vec2 ${uvVarying(n)};`).join('\n')}`;
   const attributes = compiled.attributes.map(n => `attribute vec4 ${graphAttributeName(n)};`).join('\n');
-  shader.vertexShader = `${guards}\nattribute vec3 blenderOrco;\n${attributes}\n${varyings}\n${shader.vertexShader}`.replace(
+  shader.vertexShader = `attribute vec3 blenderOrco;\n${attributes}\n${varyings}\n${shader.vertexShader}`.replace(
     '#include <project_vertex>',
     `vBlenderObjectPosition = transformed;
 vBlenderObjectNormal = objectNormal;

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

@@ -823,15 +823,24 @@ class Compiler {
           if (extension === 'CLIP')
             body.push(`if (any(lessThan(${co}.xy, vec2(0.0))) || any(greaterThan(${co}.xy, vec2(1.0)))) { ${color} = vec4(0.0); ${alpha} = 0.0; }`);
         }
-        // node_shader_gpu_tex_image's Color output, for three's straight-alpha
-        // upload: cleared for ignored/packed/data alpha; premultiplied (and
-        // cleared) when Alpha is used; straight otherwise.
+        // node_shader_gpu_tex_image's Color output over the file's own texels (straight, or
+        // premultiplied for a PREMUL image, as Blender's GPU texture holds them): alpha cleared for
+        // ignored, packed or data alpha; otherwise straight when Alpha is used, so a factor does
+        // not multiply it in twice, and premultiplied when it is not. Measured in Blender 5.2's
+        // EEVEE: a straight red texel at alpha 0.5 emits 0.502 with Alpha unused, 1.0 with it used.
+        // A PREMUL sRGB image differs: the sampler decodes the premultiplied bytes, `decode(r·a)`,
+        // where Blender's texture holds `linear(r)·a`, so its partly transparent texels read darker.
         const mode = prop<string>(node, 'image_alpha_mode');
         const alphaUsed = this.uses(key, 1);
-        if (mode === 'NONE' || mode === 'CHANNEL_PACKED' || prop<boolean>(node, 'image_is_data') || !alphaUsed)
-          body.push(`${outs([0])}.a = 1.0;`);
+        const c = outs([0]);
+        if (mode === 'NONE' || mode === 'CHANNEL_PACKED' || prop<boolean>(node, 'image_is_data'))
+          body.push(`${c}.a = 1.0;`);
+        else if (mode === 'PREMUL')
+          body.push(alphaUsed
+            ? `if (${c}.a != 0.0 && ${c}.a != 1.0) ${c}.rgb /= ${c}.a;`
+            : `${c}.a = 1.0;`);
         else
-          body.push(`${outs([0])} = vec4(${outs([0])}.rgb * ${outs([0])}.a, 1.0);`);
+          body.push(alphaUsed ? `${c}.a = 1.0;` : `${c}.rgb *= ${c}.a;`);
         break;
       }
     }

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

@@ -4,7 +4,7 @@
  * that MeshPhysicalMaterial does not expose as properties. */
 import * as THREE from 'three';
 import {z} from 'zod';
-import {applyGraphShader, bindGraphDraw, graphProgramKey, setGraphViewport} from './blender-graph-material';
+import {applyGraphShader, bindGraphDraw, graphProgramKey, graphUvChannels, setGraphViewport} from './blender-graph-material';
 import {bindNamedUvChannels} from './blender-texture-samplers';
 
 const scalar = z.number().finite();
@@ -85,9 +85,16 @@ export function applyPhysicalMaterial(material: THREE.MeshPhysicalMaterial, inpu
       setGraphViewport(renderer);
     };
     material.onBeforeCompile = shader => {
-      // Three declares channels 0..3. Blender has eight named UV maps in
-      // addition to the default channel; only the used attributes survive GLSL.
-      shader.vertexShader = [4, 5, 6, 7, 8, 9].map(i => `attribute vec2 uv${i};`).join('\n') + '\n' + shader.vertexShader;
+      // Three declares channels 1..3 only for its own maps, and none past 3.
+      // Blender has eight named UV maps beside the default channel (9 is the
+      // missing layer's zeros). Declare only the channels this draw reads: a
+      // driver may count every declared attribute against its sixteen, and
+      // six idle ones leave a graph with a few attributes no room.
+      const read = new Set([material.map, material.roughnessMap, material.normalMap]
+        .flatMap(texture => (texture ? [texture.channel] : [])).concat(graphUvChannels(material)));
+      shader.vertexShader = [...read].filter(i => i > 0).sort((a, b) => a - b)
+        .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);
       shader.fragmentShader = `uniform float blenderCoatIor;
         uniform vec3 blenderWorldExtinction;