@deepblend/dsh-blender-provider-local 0.2.13 → 0.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepblend/dsh-blender-provider-local",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "type": "module",
   "description": "Local Blender Provider: the BlenderRuntime Service over ctx.subprocess (batch execution).",
   "main": "lib/index.js",
@@ -11,7 +11,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@deepblend/dsh-blender-contracts": "0.2.13"
+    "@deepblend/dsh-blender-contracts": "0.2.15"
   },
   "license": "MIT",
   "repository": {

package/python/bootstrap.py

@@ -227,6 +227,33 @@ def action_compile_scene(request, options):
         "engine": report["engine"],
         "requestedEngine": report["requestedEngine"],
         "profileName": report["profileName"],
+        # THE RIGS THIS SCENE DECLARES, with their bones. A count alone would say an armature exists;
+        # a rig is only useful if the bones are the ones the spec named, so the names travel with it and
+        # a test can read them back rather than trust the count.
+        # WHICH ENTITIES ARE SKINNED, AND TO WHAT. The vertex groups are the evidence that weights
+        # exist at all: an entity bound to an armature with no groups renders as a static object while
+        # the file says it is rigged, and the reading is where that difference becomes visible.
+        "skinned": [
+            {
+                "entityId": entity_id,
+                "armatureId": entry["armatureId"],
+                "vertexGroups": entry["vertexGroups"],
+            }
+            for entity_id, entry in sorted((report.get("skinned") or {}).items())
+        ],
+        "armatures": [
+            {
+                "id": armature_id,
+                "object": report["armatureNames"].get(armature_id),
+                "bones": [
+                    {"name": bone["name"], "parent": bone.get("parent")}
+                    for bone in armature_entry["bones"]
+                ],
+            }
+            for armature_id, armature_entry in (
+                (entry["id"], entry) for entry in (spec.get("armatures") or [])
+            )
+        ],
         "validation": validation,
         "sceneFingerprint": scene_fingerprint(spec, describe_objects()),
     }

package/python/deepblend_scene.py

@@ -1324,6 +1324,96 @@ def assign_view_transform(scene, name):
 # ---------------------------------------------------------------------------
 
 
+ARMATURE_PREFIX = "db_arm__"
+
+
+def build_armature(entry, guard):
+    """Create one armature and its bones, and return the object.
+
+    WHY BONES ARE RESOLVED IN A SECOND PASS: the schema lets a bone name its parent without requiring
+    the parent to be declared first, because a rig's declaration should read like the skeleton rather
+    than like its storage order. So every bone is created as a root, and the parents are applied
+    afterwards — with an unknown parent reported rather than silently ignored, since a bone that
+    quietly has no parent is a rig that deforms differently from what the file says.
+    """
+    armature_id = entry["id"]
+    data = bpy.data.armatures.new("%s%s" % (ARMATURE_PREFIX, armature_id))
+    obj = bpy.data.objects.new("%s%s" % (ARMATURE_PREFIX, armature_id), data)
+    bpy.context.scene.collection.objects.link(obj)
+    obj["deepblend_id"] = armature_id
+    obj["deepblend_kind"] = "armature"
+
+    transform = entry.get("transform") or {}
+    apply_transform(obj, transform)
+
+    # Edit mode is the only place `edit_bones` exists, and Blender's own context management is what
+    # makes it available — a manual mode switch without this leaves the object in a state the rest of
+    # the compile does not expect.
+    bpy.context.view_layer.objects.active = obj
+    bpy.ops.object.mode_set(mode="EDIT")
+    try:
+        created = {}
+        for bone in entry["bones"]:
+            edit_bone = data.edit_bones.new(bone["name"])
+            edit_bone.head = tuple(float(value) for value in bone["head"])
+            edit_bone.tail = tuple(float(value) for value in bone["tail"])
+            created[bone["name"]] = edit_bone
+        for bone in entry["bones"]:
+            parent = bone.get("parent")
+            if parent is None:
+                continue
+            if parent not in created:
+                raise ActionError(
+                    "SCENE_SPEC_INVALID",
+                    'bone "%s" of armature "%s" names parent "%s", which the same armature does not declare'
+                    % (bone["name"], armature_id, parent),
+                )
+            created[bone["name"]].parent = created[parent]
+    finally:
+        bpy.ops.object.mode_set(mode="OBJECT")
+
+    return obj
+
+
+def skin_entity(obj, armature_obj, armature_id, guard):
+    """Bind a mesh to an armature with Blender's own automatic weights.
+
+    WHY AUTOMATIC WEIGHTS RATHER THAN A WEIGHT TABLE. A per-vertex weight table in the SceneSpec would
+    be a second, hand-written copy of something Blender already computes from the geometry — and the
+    copy would be the one that goes stale, because nothing regenerates it when a generator's parameters
+    change. What the spec states is the RELATIONSHIP ("this entity is skinned to that armature"); the
+    weights are Blender's answer to it.
+
+    Bone heat can fail on a degenerate mesh (Blender reports "failed to find solution for one or more
+    bones"), and that is a WARNING rather than a refusal: the binding still exists and the bones that
+    did solve still deform, so the honest outcome is a scene that mostly works with the failure named.
+    """
+    for target in bpy.context.selected_objects:
+        target.select_set(False)
+    obj.select_set(True)
+    bpy.context.view_layer.objects.active = armature_obj
+    try:
+        bpy.ops.object.parent_set(type="ARMATURE_AUTO")
+    except Exception as exc:
+        guard.warnings.append({
+            "code": "SKIN_WEIGHTS_FAILED",
+            "message": 'entity "%s" could not be skinned to armature "%s": %s'
+            % (obj.get("deepblend_id"), armature_id, error_text(exc)),
+        })
+        return False
+    finally:
+        obj.select_set(False)
+
+    if len(obj.vertex_groups) == 0:
+        guard.warnings.append({
+            "code": "SKIN_WEIGHTS_EMPTY",
+            "message": 'entity "%s" is bound to armature "%s" but Blender produced no vertex groups, so '
+                       "it will not deform" % (obj.get("deepblend_id"), armature_id),
+        })
+        return False
+    return True
+
+
 def build_scene(spec, options, guard):
     """Compile a SceneSpec into a live Blender scene.
 
@@ -1372,6 +1462,13 @@ def build_scene(spec, options, guard):
 
     assets = {asset["id"]: asset for asset in spec.get("assets") or []}
 
+    # ARMATURES BEFORE ENTITIES: an entity that is skinned to one has to find it already there. Nothing
+    # binds yet — that is the next slice — but the order is the one that will not have to change.
+    report_progress("build_armatures", 30)
+    armature_objects = {}
+    for entry in spec.get("armatures") or []:
+        armature_objects[entry["id"]] = build_armature(entry, guard)
+
     report_progress("build_entities", 35)
     entity_objects = {}
     entity_positions = {}
@@ -1492,6 +1589,25 @@ def build_scene(spec, options, guard):
     bpy.context.view_layer.update()
 
     report_progress("compile_done", 90)
+    # SKINNING LAST: it needs both the mesh and the rig, and doing it before either exists would mean
+    # ordering the compile around a step that is about the RELATIONSHIP between them.
+    report_progress("skin_entities", 60)
+    skinned_entities = {}
+    for entity in spec.get("entities") or []:
+        armature_id = entity.get("armatureId")
+        if armature_id is None:
+            continue
+        obj = entity_objects.get(entity["id"])
+        armature_obj = armature_objects.get(armature_id)
+        if obj is None or armature_obj is None:
+            raise ActionError(
+                "SCENE_SPEC_INVALID",
+                'entity "%s" is skinned to armature "%s", which the same SceneSpec does not declare'
+                % (entity["id"], armature_id),
+            )
+        skin_entity(obj, armature_obj, armature_id, guard)
+        skinned_entities[entity["id"]] = entity
+
     return {
         "objects": describe_objects(),
         "actions": actions,
@@ -1501,6 +1617,17 @@ def build_scene(spec, options, guard):
         "requestedEngine": requested_engine,
         "profileName": profile_name,
         "entityObjectNames": {key: value.name for key, value in entity_objects.items()},
+        "armatureNames": {key: value.name for key, value in armature_objects.items()},
+        "skinned": {
+            key: {
+                "armatureId": entry["armatureId"],
+                # THE GROUPS COME FROM THE OBJECT, not from the spec entry: what the file asked for is
+                # the relationship, and what Blender produced is the weights. Reading the latter back is
+                # the whole point — an entity bound with no groups renders as a static object.
+                "vertexGroups": sorted(group.name for group in entity_objects[key].vertex_groups),
+            }
+            for key, entry in skinned_entities.items()
+        },
         "cameraNames": {key: value.name for key, value in cameras.items()},
     }