@volter/blender-engine 0.1.5 → 0.1.7

package/browser/session.py

@@ -283,8 +283,8 @@ def _surface_backgrounds(node):
     return branches[0], branches[1]
 
 
-def _describe_background(background, camera_ray):
-    """The Background's Color as the presenter's world expression (its grammar
+def _describe_world_socket(root_socket, camera_ray):
+    """A World input as the presenter's expression (its grammar
     is `blender-runtime-lighting.ts`'s `worldExpression`); anything outside it
     is refused BY NAME through NotImplementedError."""
     visiting = set()
@@ -402,8 +402,12 @@ def _describe_background(background, camera_ray):
         finally:
             visiting.remove(key)
 
-    color = value(background.inputs["Color"])
-    strength = value(background.inputs["Strength"])
+    return value(root_socket)
+
+
+def _describe_background(background, camera_ray):
+    color = _describe_world_socket(background.inputs["Color"], camera_ray)
+    strength = _describe_world_socket(background.inputs["Strength"], camera_ray)
     # The field evaluator already implements an unclamped color mix. Mixing
     # black with radiance at factor strength is exact multiplication, including
     # spatially varying strength, with no second shader implementation.
@@ -415,20 +419,65 @@ def _describe_background(background, camera_ray):
             "strength": float(strength), "shader": color}
 
 
+def _describe_world_volume(socket, weight=1.0, visiting=None):
+    """Volume closures and their authored inputs, not a guessed fog color.
+    Mix/Add preserve individual scatter lobes rather than averaging anisotropy."""
+    links = list(socket.links)
+    if not links:
+        return []
+    node = links[0].from_node
+    visiting = set() if visiting is None else visiting
+    key = node.as_pointer()
+    if key in visiting:
+        raise NotImplementedError("World volume contains a cycle")
+    visiting.add(key)
+    try:
+        kind = node.bl_idname
+        if kind == "NodeReroute":
+            return _describe_world_volume(node.inputs[0], weight, visiting)
+        if kind == "ShaderNodeAddShader":
+            return sum((_describe_world_volume(s, weight, visiting) for s in node.inputs), [])
+        if kind == "ShaderNodeMixShader":
+            factor = _describe_world_socket(node.inputs[0], False)
+            factor = {"kind": "math", "operation": "MULTIPLY", "clamp": True, "inputs": [factor, 1.0]}
+            first = {"kind": "math", "operation": "SUBTRACT", "clamp": False, "inputs": [1.0, factor]}
+            return sum((_describe_world_volume(node.inputs[i + 1],
+                {"kind": "math", "operation": "MULTIPLY", "clamp": False, "inputs": [weight, f]}, visiting)
+                for i, f in enumerate((first, factor))), [])
+        kinds = {"ShaderNodeVolumeAbsorption": "absorption", "ShaderNodeVolumeScatter": "scatter",
+                 "ShaderNodeVolumePrincipled": "principled", "ShaderNodeEmission": "emission"}
+        if kind not in kinds:
+            raise NotImplementedError("World volume shader %s" % kind)
+        def read(name, default):
+            value = node.inputs.get(name)
+            return _describe_world_socket(value, False) if value is not None else default
+        return [{"kind": kinds[kind], "weight": weight,
+                 "phase": getattr(node, "phase", "HENYEY_GREENSTEIN"), "alpha": read("Alpha", 0.0),
+                 "color": read("Color", [1.0, 1.0, 1.0]), "density": read("Density", 0.0),
+                 "anisotropy": read("Anisotropy", 0.0), "absorption_color": read("Absorption Color", [0.0, 0.0, 0.0]),
+                 "emission_color": read("Emission Color", [1.0, 1.0, 1.0]),
+                 "emission_strength": read("Strength" if kinds[kind] == "emission" else "Emission Strength", 0.0),
+                 "blackbody_intensity": read("Blackbody Intensity", 0.0), "temperature": read("Temperature", 1000.0),
+                 "blackbody_tint": read("Blackbody Tint", [1.0, 1.0, 1.0])}]
+    finally:
+        visiting.remove(key)
+
+
 def _describe_world(world):
     outputs = [n for n in world.node_tree.nodes if n.bl_idname == "ShaderNodeOutputWorld" and n.is_active_output]
     if len(outputs) != 1:
         raise NotImplementedError("World rendering needs one active World Output")
     surface = list(outputs[0].inputs["Surface"].links)
-    if len(surface) != 1:
-        raise NotImplementedError("World Surface must connect to Background")
-    if outputs[0].inputs["Volume"].links:
-        raise NotImplementedError("World volume rendering is not implemented")
+    volume = _describe_world_volume(outputs[0].inputs["Volume"])
+    if not surface:
+        return {"color": [0.0, 0.0, 0.0], "strength": 0.0, "volume": volume}
     background, lighting = _surface_backgrounds(surface[0].from_node)
     described = _describe_background(background, camera_ray=True)
     lighting_data = _describe_background(lighting or background, camera_ray=False)
     if lighting_data != described:
         described["lighting"] = lighting_data
+    if volume:
+        described["volume"] = volume
     # Only a wholly constant background can drop the expression: linked
     # Strength may carry spatial radiance even when Color itself is constant.
     if not any(background.inputs[name].is_linked for name in ("Color", "Strength")):
@@ -477,6 +526,475 @@ def draw_camera(obj):
     }
 
 
+# ------------------------------------------------------- the material graphs
+
+# THE MATERIAL GRAPH, for a surface whose inputs are more than constants.
+#
+# The export door reduces each material to what a three.js standard material
+# holds -- a constant or one image per input. A LINKED input of a Principled
+# BSDF or an Emission is instead shipped as the node graph that drives it, and
+# the presenter compiles that graph with Blender's own node GLSL
+# (`three/blender-node-graph.ts`, `three/blender-node-glsl.generated.ts`). The
+# door is told which materials those are (`graph_materials`), so it stays quiet
+# about reducing them, which images their graphs sample (`graph_images`), so it
+# ships those pictures with the same revisions as every other, and which read
+# Generated coordinates (`graph_generated`), so a deformed mesh wearing one
+# ships Blender's orco -- or the door names why it cannot.
+#
+# The graph is flattened here: reroutes and muted nodes are followed the way
+# Blender's own node tree evaluation follows them, and group nodes are inlined
+# (their nodes keyed by the group path), so the presenter sees one acyclic
+# list of Blender nodes. What reaches the presenter is Blender's own data:
+# every input socket in declaration order with its GPU type and value, every
+# output socket's GPU type, and the node's own RNA properties.
+
+# The node types the presenter compiles. A graph reaching any other type is
+# not shipped; the door's reduction stands and a warning names the node.
+
+# EVERY LINK INTO A SOCKET, from one pass over its tree. `NodeSocket.links`
+# is Python in Blender (`_bpy_types.py`): each read walks ALL of the tree's
+# links, and the graph pass reads it per socket per present -- measured on a
+# 28-material scene, 875 reads and 9 of the pass's 15 profiled seconds. The
+# map is built once per tree per present (`material_graphs` clears it).
+_TREE_LINKS = {}
+
+
+def _links_into(socket):
+    """The valid, unmuted links into `socket` (Blender's own `links`, filtered)."""
+    tree = socket.id_data
+    held = _TREE_LINKS.get(tree.as_pointer())
+    if held is None:
+        held = {}
+        for link in tree.links:
+            if link.is_valid and not link.is_muted:
+                held.setdefault(link.to_socket.as_pointer(), []).append(link)
+        _TREE_LINKS[tree.as_pointer()] = held
+    return held.get(socket.as_pointer(), [])
+
+
+_GRAPH_NODES = frozenset((
+    "ShaderNodeTexCoord", "ShaderNodeUVMap", "ShaderNodeValue", "ShaderNodeRGB",
+    "ShaderNodeTexImage", "ShaderNodeMapping", "ShaderNodeMath", "ShaderNodeVectorMath",
+    "ShaderNodeMix", "ShaderNodeMixRGB", "ShaderNodeValToRGB", "ShaderNodeInvert",
+    "ShaderNodeSeparateXYZ", "ShaderNodeCombineXYZ", "ShaderNodeTexNoise",
+    "ShaderNodeTexVoronoi", "ShaderNodeTexChecker", "ShaderNodeTexWhiteNoise",
+    "ShaderNodeTexWave", "ShaderNodeTexGradient", "ShaderNodeTexMagic", "ShaderNodeTexBrick",
+    "ShaderNodeMapRange", "ShaderNodeClamp", "ShaderNodeHueSaturation", "ShaderNodeBrightContrast",
+    "ShaderNodeGamma", "ShaderNodeRGBToBW", "ShaderNodeSeparateColor", "ShaderNodeCombineColor",
+    "ShaderNodeVectorRotate", "ShaderNodeFresnel", "ShaderNodeLayerWeight", "ShaderNodeBump",
+    "ShaderNodeNormalMap", "ShaderNodeNewGeometry", "ShaderNodeVertexColor", "ShaderNodeAttribute",
+    "ShaderNodeRGBCurve", "ShaderNodeVectorCurve", "ShaderNodeFloatCurve",
+))
+# The surfaces whose inputs map onto the presenter's standard material, and
+# the inputs of each the presenter reads from a graph.
+_GRAPH_SURFACES = {
+    "ShaderNodeBsdfPrincipled": ("Base Color", "Metallic", "Roughness", "Alpha",
+                                 "Emission Color", "Emission Strength", "Normal"),
+    "ShaderNodeEmission": ("Color", "Strength"),
+}
+# Procedural textures whose unlinked Vector is Generated coordinates.
+_GENERATED_BY_DEFAULT = frozenset((
+    "ShaderNodeTexNoise", "ShaderNodeTexVoronoi", "ShaderNodeTexChecker", "ShaderNodeTexWave",
+    "ShaderNodeTexGradient", "ShaderNodeTexMagic", "ShaderNodeTexBrick",
+))
+# RNA properties every node has, which describe the node's place in the editor
+# rather than what it computes.
+_NODE_BASE_PROPERTIES = frozenset(p.identifier for p in bpy.types.ShaderNode.bl_rna.properties)
+
+
+def _gpu_type(socket):
+    """Blender's `node_gpu_stack_from_data`: the GLSL type a socket is passed
+    as, or None for a socket GPU codegen leaves out of the call."""
+    kind = socket.type
+    if kind in ("VALUE", "INT", "BOOLEAN"):
+        return "float"
+    if kind == "VECTOR":
+        return "vec%d" % len(socket.default_value) if hasattr(socket, "default_value") else "vec3"
+    if kind in ("RGBA", "ROTATION"):
+        return "vec4"
+    if kind == "SHADER":
+        return "closure"
+    return None
+
+
+def _socket_value(socket, gpu):
+    """An unlinked socket's value in its GPU type (`nodestack_get_vec`)."""
+    if not hasattr(socket, "default_value"):
+        return 0.0 if gpu == "float" else [0.0] * int(gpu[3:])
+    value = socket.default_value
+    if gpu == "float":
+        return float(value)
+    values = [float(v) for v in value]
+    if socket.type == "ROTATION":
+        # A rotation socket's value is an Euler; codegen carries it as a vec4.
+        values = values + [0.0]
+    return values
+
+
+def _curve_mapping(mapping):
+    """What `gpu_shader_curve_*` hands the GPU, read through Blender itself:
+    `BKE_curvemapping_table_RGBA`'s 257 samples per curve, each curve's table
+    range (`mintable`/`maxtable`: the clip rectangle widened to the points,
+    `curvemap_make_table`) and its extrapolation slopes in that normalized
+    range (`BKE_curvemapping_compute_slopes`; horizontal without Extrapolated).
+    The samples and slopes come from `CurveMapping.evaluate`, the same
+    evaluation the table holds -- never a transcribed Bezier."""
+    curves = list(mapping.curves)
+    table = [[0.0, 0.0, 0.0, 0.0] for _ in range(_RAMP_SAMPLES)]
+    minimums, dividers, starts, ends = [0.0] * 4, [1e8] * 4, [0.0] * 4, [0.0] * 4
+    extrapolate = mapping.extend == "EXTRAPOLATED"
+    for index, curve in enumerate(curves[:4]):
+        points = [p.location for p in curve.points]
+        if len(points) >= 2:
+            low = min([mapping.clip_min_x] + [p[0] for p in points])
+            high = max([mapping.clip_max_x] + [p[0] for p in points])
+        else:
+            low = high = 0.0
+        span = high - low
+        minimums[index] = low
+        dividers[index] = 1.0 / max(1e-8, span)
+        for i in range(_RAMP_SAMPLES):
+            table[i][index] = float(mapping.evaluate(curve, low + span * i / (_RAMP_SAMPLES - 1)))
+        if extrapolate and span > 0:
+            step = span * 1e-3
+            starts[index] = (mapping.evaluate(curve, low) - mapping.evaluate(curve, low - step)) / step * span
+            ends[index] = (mapping.evaluate(curve, high + step) - mapping.evaluate(curve, high)) / step * span
+    return {"table": table, "minimums": minimums, "dividers": dividers, "starts": starts, "ends": ends}
+
+
+def _node_properties(node):
+    """The node's own RNA properties: enums, flags and numbers, plus the two
+    data-block values a compiled node reads (its colour ramp, its image)."""
+    props = {}
+    for prop in node.bl_rna.properties:
+        name = prop.identifier
+        if name in _NODE_BASE_PROPERTIES:
+            continue
+        if prop.type in ("ENUM", "BOOLEAN", "INT", "FLOAT", "STRING") and not getattr(prop, "is_array", False):
+            value = getattr(node, name)
+            props[name] = sorted(value) if isinstance(value, set) else value
+            if prop.type == "ENUM" and not prop.is_enum_flag:
+                # The enum's DNA value, which is what the GPU binding passes as
+                # a constant (`GPU_constant(&tex->wave_type)`): read from RNA,
+                # never transcribed.
+                try:
+                    props[name + "#value"] = prop.enum_items[value].value
+                except (KeyError, TypeError):
+                    pass  # a dynamic enum has no static item table
+    if node.bl_idname == "ShaderNodeValToRGB":
+        ramp = node.color_ramp
+        props["color_ramp"] = {
+            "interpolation": ramp.interpolation,
+            "color_mode": ramp.color_mode,
+            "elements": [[float(e.position)] + [float(c) for c in e.color] for e in ramp.elements],
+            # The table Blender's GPU path samples (BKE_colorband_evaluate_table_rgba),
+            # read through Blender's own evaluator.
+            "table": [[float(c) for c in ramp.evaluate(i / 256)] for i in range(_RAMP_SAMPLES)],
+        }
+    if node.bl_idname in ("ShaderNodeRGBCurve", "ShaderNodeVectorCurve", "ShaderNodeFloatCurve"):
+        props["curve_mapping"] = _curve_mapping(node.mapping)
+    if node.bl_idname == "ShaderNodeTexImage":
+        image = node.image
+        props["image"] = image.name if image is not None else None
+        if image is not None:
+            # What decides the Color output's alpha handling
+            # (`node_shader_gpu_tex_image`): the image's alpha mode, and
+            # whether its colour space is data.
+            props["image_alpha_mode"] = image.alpha_mode
+            props["image_is_data"] = bool(image.colorspace_settings.is_data)
+            # UDIM: a flat projection samples every tile (the door ships them).
+            props["image_tiled"] = image.source == "TILED"
+    if node.bl_idname in ("ShaderNodeValue", "ShaderNodeRGB"):
+        # These nodes' value is their OUTPUT socket's (`set_value`/`set_rgba`
+        # of a uniform in Blender's GPU path).
+        props["value"] = _socket_value(node.outputs[0], _gpu_type(node.outputs[0]))
+    return props
+
+
+def _refusal(node):
+    """What of a supported node type the presenter does not compile yet, or None."""
+    kind = node.bl_idname
+    if kind == "ShaderNodeTexImage":
+        image = node.image
+        if node.projection == "BOX" and node.extension == "CLIP":
+            return "%s clips a Box projection, which is not compiled" % node.name
+        if image is not None and image.source not in ("FILE", "GENERATED", "TILED"):
+            return "%s's image is a %s source" % (node.name, image.source)
+    if kind == "ShaderNodeNewGeometry" and node.outputs["Parametric"].is_linked:
+        # EEVEE's parametric is the triangle's barycentrics, which the
+        # presenter's meshes do not carry.
+        return "%s's Parametric output is not compiled" % node.name
+    if kind == "ShaderNodeAttribute" and node.attribute_type != "GEOMETRY":
+        return "%s reads an %s attribute; only Geometry attributes are compiled" % (
+            node.name, node.attribute_type.replace("_", " ").title())
+    if kind == "ShaderNodeTexCoord" and node.object is not None:
+        return "%s reads object coordinates of %s" % (node.name, node.object.name)
+    return None
+
+
+class _GraphRefusal(Exception):
+    pass
+
+
+class _MaterialGraph:
+    """One material's graph, flattened. `nodes` is keyed by group path."""
+
+    def __init__(self, material):
+        self.material = material
+        self.nodes = {}
+        self.images = set()
+        self._building = set()
+        # Whether the graph reads Generated coordinates: Texture Coordinate's
+        # first output, or a procedural texture's unlinked Vector, which
+        # Blender defaults to Generated (`node_shader_gpu_default_tex_coord`).
+        self.generated = False
+
+    # A socket is addressed inside a STACK of group nodes; the empty stack is
+    # the material's own tree.
+
+    def source(self, stack, socket):
+        """An input socket's value: `{"value": v}` or `{"link": [node, output]}`."""
+        gpu = _gpu_type(socket)
+        links = _links_into(socket)
+        if not links:
+            return {"value": _socket_value(socket, gpu)}
+        return self.output(stack, links[0].from_node, links[0].from_socket, gpu)
+
+    def output(self, stack, node, socket, wanted):
+        kind = node.bl_idname
+        if kind == "NodeReroute":
+            return self.source(stack, node.inputs[0])
+        if node.mute:
+            for link in node.internal_links:
+                if link.to_socket == socket:
+                    return self.source(stack, link.from_socket)
+            return {"value": 0.0 if wanted == "float" else [0.0] * int(wanted[3:])}
+        if kind == "ShaderNodeGroup":
+            tree = node.node_tree
+            if tree is None:
+                raise _GraphRefusal("group %s has no node tree" % node.name)
+            outputs = [n for n in tree.nodes if n.bl_idname == "NodeGroupOutput"]
+            active = next((n for n in outputs if n.is_active_output), outputs[0] if outputs else None)
+            if active is None:
+                raise _GraphRefusal("group %s has no Group Output" % tree.name)
+            inner = next(s for s in active.inputs if s.identifier == socket.identifier)
+            return self.source(stack + [node], inner)
+        if kind == "NodeGroupInput":
+            if not stack:
+                raise _GraphRefusal("a Group Input outside a group")
+            outer = stack[-1]
+            outer_socket = next(s for s in outer.inputs if s.identifier == socket.identifier)
+            return self.source(stack[:-1], outer_socket)
+        if kind not in _GRAPH_NODES:
+            raise _GraphRefusal("%s (%s) is not compiled by the presenter" % (node.name, kind))
+        refusal = _refusal(node)
+        if refusal is not None:
+            raise _GraphRefusal(refusal)
+        key = "/".join([group.name for group in stack] + [node.name])
+        if key not in self.nodes:
+            if key in self._building:
+                raise _GraphRefusal("%s is part of a cycle" % node.name)
+            self._building.add(key)
+            self.nodes[key] = self._describe(stack, node)
+            self._building.discard(key)
+        index = next(i for i, s in enumerate(node.outputs) if s == socket)
+        # Generated coordinates, and the Geometry node's Tangent (node_tangent
+        # of the orco).
+        if (kind == "ShaderNodeTexCoord" and index == 0) or (
+                kind == "ShaderNodeNewGeometry" and socket.name == "Tangent"):
+            self.generated = True
+        return {"link": [key, index]}
+
+    def _describe(self, stack, node):
+        if node.bl_idname in _GENERATED_BY_DEFAULT and not bool(_links_into(node.inputs[0])):
+            self.generated = True
+        props = _node_properties(node)
+        if props.get("image"):
+            self.images.add(props["image"])
+        return {
+            "type": node.bl_idname,
+            "props": props,
+            "inputs": [
+                dict(self.source(stack, s), id=s.identifier, gpu=_gpu_type(s), enabled=s.enabled)
+                for s in node.inputs if _gpu_type(s) not in (None, "closure")
+            ],
+            "outputs": [{"id": s.identifier, "gpu": _gpu_type(s)} for s in node.outputs],
+        }
+
+
+def _surface_node(tree):
+    """The shader node Surface reaches, through reroutes and groups, or None."""
+    outputs = [n for n in tree.nodes
+               if n.bl_idname == "ShaderNodeOutputMaterial" and n.target in ("ALL", "EEVEE")]
+    output = next((n for n in outputs if n.is_active_output), outputs[0] if outputs else None)
+    if output is None:
+        return None, None
+    return _follow(output.inputs["Surface"], [])
+
+
+def _follow(socket, stack):
+    """The node an input socket's link comes from, through reroutes and groups,
+    as `(stack, node)`, or `(None, None)` when nothing is linked."""
+    while True:
+        links = _links_into(socket)
+        if not links:
+            return None, None
+        node, out = links[0].from_node, links[0].from_socket
+        if node.bl_idname == "NodeReroute":
+            socket = node.inputs[0]
+        elif node.bl_idname == "ShaderNodeGroup" and node.node_tree is not None:
+            inner = [n for n in node.node_tree.nodes if n.bl_idname == "NodeGroupOutput"]
+            if not inner:
+                return None, None
+            stack = stack + [node]
+            socket = next(s for s in inner[0].inputs if s.identifier == out.identifier)
+        elif node.bl_idname == "NodeGroupInput" and stack:
+            socket = next(s for s in stack[-1].inputs if s.identifier == out.identifier)
+            stack = stack[:-1]
+        else:
+            return stack, node
+
+
+def _light_path_side(socket, stack):
+    """A Mix Shader factor that separates the camera's surface (a Light Path's
+    Is Camera Ray: 1, Is Shadow Ray: 0 on a camera ray), or a constant 0 or 1,
+    as the input index the camera sees; None for any other factor. The door
+    collapses exactly these (`bpy_web_export.cc`)."""
+    links = _links_into(socket)
+    if not links:
+        value = socket.default_value
+        return 1 if value == 0.0 else 2 if value == 1.0 else None
+    link = links[0]
+    if link.from_node.bl_idname == "ShaderNodeLightPath":
+        return {"Is Shadow Ray": 1, "Is Camera Ray": 2}.get(link.from_socket.name)
+    return None
+
+
+def _collapse(stack, node):
+    """Follow the Mix Shaders the camera sees one side of (`_light_path_side`)."""
+    while node is not None and node.bl_idname == "ShaderNodeMixShader" and not node.mute:
+        side = _light_path_side(node.inputs[0], stack)
+        if side is None:
+            break
+        stack, node = _follow(node.inputs[side], stack)
+    return stack, node
+
+
+def _closure(graph, stack, node, lit):
+    """A shader mix as the tree the presenter composes: `{"mix": [factor, a,
+    b]}`, `{"add": [a, b]}`, and its leaves `{"principled": true}`,
+    `{"emission": [color, strength]}`, `{"transparent": gray}` and `{"none":
+    true}` (an empty shader socket). The one Principled BSDF is appended to
+    `lit`; the door reduces its constants, and it reaches it only through
+    mixes and reroutes, never a group."""
+    stack, node = _collapse(stack, node)
+    if node is None:
+        return {"none": True}
+    if stack:
+        raise _GraphRefusal("its shader mix passes through group %s" % stack[-1].name)
+    if node.mute:
+        raise _GraphRefusal("%s is muted" % node.name)
+    kind = node.bl_idname
+    if kind in ("ShaderNodeMixShader", "ShaderNodeAddShader"):
+        sides = [_closure(graph, *_follow(node.inputs[i], stack), lit)
+                 for i in ((1, 2) if kind == "ShaderNodeMixShader" else (0, 1))]
+        if kind == "ShaderNodeAddShader":
+            return {"add": sides}
+        return {"mix": [graph.source(stack, node.inputs[0])] + sides}
+    if kind == "ShaderNodeBsdfPrincipled":
+        if lit and lit[0] != node:
+            raise _GraphRefusal("it mixes two Principled BSDFs (%s and %s)" % (lit[0].name, node.name))
+        lit[:] = [node]
+        return {"principled": True}
+    if kind == "ShaderNodeEmission":
+        return {"emission": [graph.source(stack, node.inputs["Color"]),
+                             graph.source(stack, node.inputs["Strength"])]}
+    if kind == "ShaderNodeBsdfTransparent":
+        color = node.inputs["Color"]
+        if color.is_linked:
+            raise _GraphRefusal("%s's Color is linked; a tinted transparency is not compiled" % node.name)
+        r, g, b = color.default_value[:3]
+        if not (r == g == b):
+            raise _GraphRefusal("%s is tinted; only a gray transparency is compiled" % node.name)
+        return {"transparent": float(r)}
+    raise _GraphRefusal("%s (%s) is not a shader the presenter composes" % (node.name, kind))
+
+
+def material_graph(material):
+    """The graph the presenter compiles for this material, or None when the
+    door's reduction describes it fully (or the surface is not one the graph
+    covers). A graph outside `_GRAPH_NODES` is a warning naming the node."""
+    if not material.use_nodes or material.node_tree is None:
+        return None
+    stack, surface = _collapse(*_surface_node(material.node_tree))
+    if surface is not None and surface.bl_idname in ("ShaderNodeMixShader", "ShaderNodeAddShader"):
+        return _mixed_graph(material, stack, surface)
+    if surface is None or surface.bl_idname not in _GRAPH_SURFACES:
+        return None
+    sockets = [surface.inputs[name] for name in _GRAPH_SURFACES[surface.bl_idname]]
+    if not any(_links_into(s) for s in sockets):
+        return None
+    # The door is quiet about a material whose graph ships, so a linked input
+    # the graph does not carry is named here.
+    for other in surface.inputs:
+        linked = bool(_links_into(other))
+        if not linked or other in sockets:
+            continue
+        warn("%s: %s is linked; only its constant is drawn" % (material.name, other.name))
+    graph = _MaterialGraph(material)
+    try:
+        inputs = {s.name: graph.source(stack, s) for s in sockets}
+    except _GraphRefusal as refusal:
+        warn("%s: its graph is drawn as constants; %s" % (material.name, refusal))
+        return None
+    return {
+        "surface": surface.bl_idname,
+        "inputs": inputs,
+        "nodes": graph.nodes,
+        "images": sorted(graph.images),
+        "generated": graph.generated,
+    }
+
+
+def _mixed_graph(material, stack, surface):
+    """A surface that mixes or adds shaders: the closure tree, and the one
+    Principled BSDF's graph-driven inputs (`_closure`)."""
+    graph = _MaterialGraph(material)
+    lit = []
+    try:
+        closure = _closure(graph, stack, surface, lit)
+        inputs = {}
+        if lit:
+            sockets = [lit[0].inputs[name] for name in _GRAPH_SURFACES["ShaderNodeBsdfPrincipled"]]
+            for other in lit[0].inputs:
+                if other not in sockets and _links_into(other):
+                    warn("%s: %s is linked; only its constant is drawn" % (material.name, other.name))
+            inputs = {s.name: graph.source([], s) for s in sockets}
+    except _GraphRefusal as refusal:
+        warn("%s: its shader mix is not drawn; %s" % (material.name, refusal))
+        return None
+    return {
+        "surface": "ShaderNodeBsdfPrincipled" if lit else "closure",
+        "inputs": inputs,
+        "closure": closure,
+        "nodes": graph.nodes,
+        "images": sorted(graph.images),
+        "generated": graph.generated,
+    }
+
+
+def material_graphs(scene):
+    """Every graph the scene's materials need, by material name."""
+    _TREE_LINKS.clear()
+    graphs = {}
+    for obj in scene.objects:
+        for slot in getattr(obj, "material_slots", ()):
+            material = slot.material
+            if material is not None and material.name not in graphs:
+                graphs[material.name] = material_graph(material)
+    return {name: graph for name, graph in graphs.items() if graph is not None}
+
+
 # ------------------------------------------------------------- the overlays
 #
 # INSPECTION OVERLAYS, READ OFF THE ENGINE (ARCHITECTURE-CORE §Blender north
@@ -711,7 +1229,12 @@ class Session:
         bones and the active vertex group's weights (`_armatures`,
         `_weights`). All per-scene, none of them geometry.
         """
-        options = {"session": self.session, "evaluate": True, "known": self._known}
+        scene = bpy.context.scene
+        graphs = material_graphs(scene)
+        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_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
         # correctness argument: whatever carries `ask/<id>.done` out of this
@@ -735,7 +1258,36 @@ class Session:
         # nine of 17-workshop-interior's 63 calls died on that refusal.
         self.revision += 1
         frame["revision"] = self.revision
-        scene = bpy.context.scene
+        # THE GRAPHS JOIN THE DOOR'S MATERIALS, each image a graph samples
+        # named at the revision the door holds it at (`graph_images`, which is
+        # the session's to read and not part of the presenter's frame).
+        revisions = frame.pop("graph_images", {})
+        for name, graph in graphs.items():
+            if name not in frame["materials"]:
+                continue
+            for node in graph["nodes"].values():
+                image = node["props"].get("image")
+                if image is not None:
+                    node["props"]["image"] = {"name": image, "revision": int(revisions.get(image, 0))}
+            del graph["images"]
+            del graph["generated"]
+            frame["materials"][name]["graph"] = graph
+        # A MANUAL TEXTURE SPACE, which Generated coordinates map through; the
+        # automatic one is the evaluated bounds the presenter already holds.
+        if graphs:
+            depsgraph = bpy.context.evaluated_depsgraph_get()
+            for row in frame["objects"]:
+                if not any(m in graphs for m in row["materials"] if m is not None):
+                    continue
+                obj = scene.objects.get(row["name"])
+                data = obj.evaluated_get(depsgraph).data if obj is not None else None
+                if getattr(data, "use_auto_texspace", True) is False:
+                    row["texspace"] = [[float(v) for v in data.texspace_location],
+                                       [float(v) for v in data.texspace_size]]
+                # The layer a Color Attribute node with no name reads.
+                default_color = getattr(getattr(data, "color_attributes", None), "default_color_name", "")
+                if default_color:
+                    row["default_color"] = default_color
         frame["world"] = draw_world(scene)
         frame["cameras"] = {
             obj.name: draw_camera(obj) for obj in scene.objects if obj.type == "CAMERA"
@@ -870,7 +1422,7 @@ class Session:
         """
         carried = frame.get("images") or {}
         for material in (frame.get("materials") or {}).values():
-            for slot in ("texture", "roughness_texture"):
+            for slot in ("texture", "roughness_texture", "normal_texture"):
                 reference = material.get(slot)
                 if not isinstance(reference, dict):
                     continue

package/browser/three/blender-frame-columns.ts

@@ -79,6 +79,12 @@ export const ATTRIBUTE_LAYOUT: Record<AttributeType, { size: number }> = {
 export interface MeshColumns {
   /** 3 * nv */
   co: Float64Array;
+  /** Blender-evaluated normals, 3 per corner, independent of UV splits. */
+  cornerNormal?: Float32Array | undefined;
+  /** 3 * nv, a deformed mesh's Generated coordinates in Blender's stored
+   *  -1..1 range (the door's `deformed_orco`); absent when the drawn
+   *  positions are the undeformed ones. */
+  orco?: Float32Array | undefined;
   /** nf + 1 */
   faceStart: Uint32Array;
   /** faceStart[nf] entries: vertex index per loop */