| |
| """Graft a mesh and its skin from a donor FBX into one that was exported without geometry. |
| |
| fbx_graft_mesh.py --selftest <fbx>... byte-identical round trip |
| fbx_graft_mesh.py --inspect <fbx>... what geometry/skin a file holds |
| fbx_graft_mesh.py --donor <donor> [--bind X] <target> graft, in place |
| |
| `--bind` decides whose bind pose — whose rest pose, as an importer will show it — |
| the repaired clip ends up with. `donor` (the default) adopts the donor's, which is |
| what keeps a species' clips sharing one rest pose; `self` keeps the target's own, |
| re-posing the grafted mesh to match; a path takes a third file's. |
| |
| `KingCobra-Walk.fbx` is the one clip in this dataset with no geometry: the export |
| dropped `Geometry::Mesh` and `Model::Mesh` while keeping the skeleton, the |
| animation curves, the materials and the embedded textures. Its two `Deformer::Skin` |
| objects survived as orphans, and they index a 1110-vertex mesh that exists in no |
| file — every other KingCobra clip carries the same 2220-vertex mesh instead. The |
| orphan skin is therefore unrecoverable, and the fix is to bring in a sibling's |
| complete geometry-plus-skin package. |
| |
| That is sound because the two rigs are the same skeleton: identical bone names, |
| identical parenting, and identical `PreRotation` on all 19 bones. The donor's |
| bind *posture* differs, but a skin cluster stores |
| `Transform = MeshGlobal_bind · inverse(TransformLink)`, which resolves a vertex |
| into the bone's own local frame and so cancels the posture it was bound in. The |
| deformation is then reconstructed from whatever world matrix the target's own |
| animation gives each bone, frame by frame. |
| |
| What moves: `Geometry::Mesh`, `Model::Mesh`, `Deformer::Skin`, its `Cluster`s and |
| `Pose::BindPose`. What is deleted: the target's orphan skins and clusters. Every |
| copied object gets a fresh uid, and connections that point at the donor's bones, |
| materials or textures are re-pointed at the target's own by name — nothing about |
| the target's skeleton, curves or embedded pixels is touched. |
| |
| Correctness gate: with no edits the serializer must reproduce its input byte for |
| byte (`--selftest`), the same gate `fbx_embed_texture.py` uses. |
| |
| Writes through a temporary file and renames it into place. Clips here are |
| hardlinks of files in `Truebone_Z-OO/`, and writing to such a path writes through |
| to the original; `os.replace` swaps the name and leaves the source alone. |
| """ |
| import collections, math, os, struct, sys, zlib |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| from fbx_embed_texture import parse, serialize, Node, ELEM, SCALAR |
|
|
|
|
| |
|
|
| def sval(pr): |
| t, pay = pr |
| if t in "SR": return pay |
| return {"L": "<q", "I": "<i", "D": "<d", "F": "<f", "Y": "<h"}.get(t) and \ |
| struct.unpack({"L": "<q", "I": "<i", "D": "<d", "F": "<f", "Y": "<h"}[t], pay)[0] |
|
|
| def uid_prop(uid): |
| return ("L", struct.pack("<q", uid)) |
|
|
| def clean(name): |
| return name.decode("utf-8", "replace").split("\x00")[0] |
|
|
|
|
| |
|
|
| def top(tree, name): |
| for n in tree["top"]: |
| if n.name == name: return n |
| return None |
|
|
| def objects(tree): |
| """uid -> (class, name, subtype, node)""" |
| o = top(tree, b"Objects"); out = {} |
| if not o: return out |
| for ch in o.children: |
| if len(ch.props) >= 3: |
| out[sval(ch.props[0])] = (ch.name, sval(ch.props[1]), sval(ch.props[2]), ch) |
| return out |
|
|
| def connections(tree): |
| c = top(tree, b"Connections") |
| return [] if not c else [tuple(sval(x) for x in ch.props) for ch in c.children] |
|
|
| def copy_node(n): |
| c = Node(n.name) |
| c.props = list(n.props) |
| c.nullrec = n.nullrec |
| c.children = [copy_node(x) for x in n.children] |
| return c |
|
|
|
|
| |
|
|
| def inspect(path): |
| t = parse(path); o = objects(t) |
| verts = polys = 0 |
| for uid, (cls, nm, sub, node) in o.items(): |
| if cls == b"Geometry": |
| for ch in node.children: |
| if ch.name == b"Vertices": |
| length = struct.unpack("<I", ch.props[0][1][:4])[0]; verts = length // 3 |
| if ch.name == b"PolygonVertexIndex": |
| polys = struct.unpack("<I", ch.props[0][1][:4])[0] |
| census = collections.Counter((clean(cls), clean(sub)) for cls, _, sub, _ in |
| ((c, n, s, x) for c, n, s, x in o.values())) |
| return {"verts": verts, "poly_indices": polys, |
| "geometry": census[("Geometry", "Mesh")], |
| "model_mesh": census[("Model", "Mesh")], |
| "limbs": census[("Model", "LimbNode")], |
| "skins": census[("Deformer", "Skin")], |
| "clusters": census[("Deformer", "Cluster")], |
| "bindpose": census[("Pose", "BindPose")]} |
|
|
|
|
| |
|
|
| FMT = {"d": ("d", 8), "f": ("f", 4), "i": ("i", 4), "l": ("q", 8), "b": ("b", 1)} |
|
|
| def rd_array(pr): |
| t, pay = pr |
| n, enc, clen = struct.unpack("<III", pay[:12]) |
| body = pay[12:] |
| if enc: body = zlib.decompress(body) |
| f, sz = FMT[t] |
| return list(struct.unpack("<%d%s" % (n, f), body[:n * sz])), enc |
|
|
| def wr_array(t, vals, enc=1): |
| """An array property: `(length, encoding, byte count)` then the payload. |
| |
| The third header field must carry the payload's byte count even when the data |
| is stored uncompressed — readers take it as the number of bytes to consume, |
| not as a compressed-only field. Writing 0 there produces a file that this |
| module still round-trips happily and that Blender refuses to open. |
| """ |
| f, sz = FMT[t] |
| raw = struct.pack("<%d%s" % (len(vals), f), *vals) |
| if enc: |
| raw = zlib.compress(raw) |
| return (t, struct.pack("<III", len(vals), 1 if enc else 0, len(raw)) + raw) |
|
|
|
|
| |
|
|
| def _mat(vals): |
| """FBX stores a 4x4 as 16 doubles with the translation last — row-vector layout.""" |
| return [vals[i * 4:i * 4 + 4] for i in range(4)] |
|
|
| def _mul(a, b): |
| return [[sum(a[i][k] * b[k][j] for k in range(4)) for j in range(4)] for i in range(4)] |
|
|
| def _inv(m): |
| """Gauss-Jordan; these are affine but may carry scale, so invert generally.""" |
| n = 4 |
| a = [row[:] + [1.0 if i == j else 0.0 for j in range(n)] for i, row in enumerate(m)] |
| for c in range(n): |
| p = max(range(c, n), key=lambda r: abs(a[r][c])) |
| if abs(a[p][c]) < 1e-14: raise ValueError("singular matrix") |
| a[c], a[p] = a[p], a[c] |
| d = a[c][c] |
| a[c] = [x / d for x in a[c]] |
| for r in range(n): |
| if r == c: continue |
| f = a[r][c] |
| if f: a[r] = [x - f * y for x, y in zip(a[r], a[c])] |
| return [row[n:] for row in a] |
|
|
| def _flat(m): |
| return [x for row in m for x in row] |
|
|
|
|
| def bind_pose_of(path): |
| """`{bone name: TransformLink}` — where each bone stood when the mesh was bound.""" |
| t = parse(path); o = objects(t) |
| kids = collections.defaultdict(list) |
| for con in connections(t): |
| if con[0] == b"OO": kids[con[2]].append(con[1]) |
| out = {} |
| for u, (c, n, s, node) in o.items(): |
| if c != b"Deformer" or s != b"Cluster": continue |
| bone = next((clean(o[k][1]) for k in kids[u] |
| if k in o and o[k][0] == b"Model"), None) |
| g = {ch.name: ch for ch in node.children} |
| if bone and b"TransformLink" in g and bone not in out: |
| out[bone] = _mat(rd_array(g[b"TransformLink"].props[0])[0]) |
| return out |
|
|
|
|
| def rebind(tt, tl_target, log): |
| """Re-pose the grafted mesh into the target's own bind pose. |
| |
| The mesh arrives bound in the donor's posture, and an importer that reads the |
| bind matrices will show the donor's rest pose rather than this clip's. The two |
| are different postures of the same skeleton, so the mesh can be moved between |
| them by the skin itself: evaluate it at the target's bind pose and rebind there. |
| |
| A cluster stores `Transform = MeshGlobal_bind · inverse(TransformLink)`, so with |
| `K_i = Transform_i · TransformLink_target_i · inverse(MeshGlobal)` every vertex |
| becomes `v' = Σ w_i · v · K_i` and the cluster matrices follow. Weights here sum |
| to exactly 1 per vertex, so the blend is affine and needs no normalising. |
| """ |
| to = objects(tt) |
| geo = [node for u, (c, n, s, node) in to.items() if c == b"Geometry"] |
| if not geo: return False |
| geo = geo[0] |
| clusters = [] |
| kids = collections.defaultdict(list) |
| for con in connections(tt): |
| if con[0] == b"OO": kids[con[2]].append(con[1]) |
| for u, (c, n, s, node) in to.items(): |
| if c != b"Deformer" or s != b"Cluster": continue |
| bone = next((clean(to[k][1]) for k in kids[u] |
| if k in to and to[k][0] == b"Model"), None) |
| g = {ch.name: ch for ch in node.children} |
| if bone is None or b"TransformLink" not in g: continue |
| clusters.append((bone, node, g)) |
|
|
| missing = [b for b, _, _ in clusters if b not in tl_target] |
| if missing: |
| log.append("目标自身缺 %d 根骨骼的绑定矩阵，保留供体绑定姿势" % len(missing)) |
| return False |
|
|
| |
| b0, _, g0 = clusters[0] |
| mesh_global = _mul(_mat(rd_array(g0[b"Transform"].props[0])[0]), |
| _mat(rd_array(g0[b"TransformLink"].props[0])[0])) |
| inv_mg = _inv(mesh_global) |
|
|
| K = {} |
| for bone, node, g in clusters: |
| tf = _mat(rd_array(g[b"Transform"].props[0])[0]) |
| K[bone] = _mul(_mul(tf, tl_target[bone]), inv_mg) |
|
|
| verts, venc = rd_array(next(ch for ch in geo.children |
| if ch.name == b"Vertices").props[0]) |
| nv = len(verts) // 3 |
| acc = [[0.0, 0.0, 0.0] for _ in range(nv)] |
| nacc = [[0.0, 0.0, 0.0] for _ in range(nv)] |
|
|
| nrm_node = None |
| for ch in geo.children: |
| if ch.name != b"LayerElementNormal": continue |
| mapping = next((clean(cc.props[0][1]) for cc in ch.children |
| if cc.name == b"MappingInformationType"), "") |
| if mapping == "ByVertice": |
| nrm_node = next((cc for cc in ch.children if cc.name == b"Normals"), None) |
| normals = rd_array(nrm_node.props[0])[0] if nrm_node else None |
|
|
| for bone, node, g in clusters: |
| idx = rd_array(g[b"Indexes"].props[0])[0] |
| wts = rd_array(g[b"Weights"].props[0])[0] |
| k = K[bone] |
| |
| it = _inv([row[:3] + [0.0] for row in k[:3]] + [[0.0, 0.0, 0.0, 1.0]]) |
| nk = [[it[j][i] for j in range(3)] for i in range(3)] |
| for i, w in zip(idx, wts): |
| x, y, z = verts[3 * i], verts[3 * i + 1], verts[3 * i + 2] |
| for j in range(3): |
| acc[i][j] += w * (x * k[0][j] + y * k[1][j] + z * k[2][j] + k[3][j]) |
| if normals: |
| a, b_, c_ = normals[3 * i], normals[3 * i + 1], normals[3 * i + 2] |
| for j in range(3): |
| nacc[i][j] += w * (a * nk[0][j] + b_ * nk[1][j] + c_ * nk[2][j]) |
|
|
| moved = max(math.dist((verts[3*i], verts[3*i+1], verts[3*i+2]), acc[i]) |
| for i in range(nv)) |
| for ch in geo.children: |
| if ch.name == b"Vertices": |
| ch.props[0] = wr_array("d", [c for v in acc for c in v], venc) |
| if normals: |
| out = [] |
| for v in nacc: |
| L = math.sqrt(sum(c * c for c in v)) or 1.0 |
| out += [c / L for c in v] |
| nrm_node.props[0] = wr_array("d", out, rd_array(nrm_node.props[0])[1]) |
|
|
| for bone, node, g in clusters: |
| tl = tl_target[bone] |
| g[b"TransformLink"].props[0] = wr_array("d", _flat(tl), 0) |
| g[b"Transform"].props[0] = wr_array("d", _flat(_mul(mesh_global, _inv(tl))), 0) |
|
|
| log.append("重绑定到本片自身的绑定姿势：%d 根骨骼，顶点最大位移 %.4f" % (len(clusters), moved)) |
| return True |
|
|
|
|
| |
|
|
| MOVE = {(b"Geometry", b"Mesh"), (b"Model", b"Mesh"), |
| (b"Deformer", b"Skin"), (b"Deformer", b"Cluster"), (b"Pose", b"BindPose")} |
|
|
| def graft(donor_path, target_path, dry=False, bind="donor"): |
| dt, tt = parse(donor_path), parse(target_path) |
| do, to = objects(dt), objects(tt) |
| tobj, tcon = top(tt, b"Objects"), top(tt, b"Connections") |
| log = [] |
|
|
| |
| |
| |
| |
| had_pose = any(c == b"Pose" for c, _, _, _ in to.values()) |
| tkids = collections.defaultdict(list) |
| for con in connections(tt): |
| if con[0] == b"OO": tkids[con[2]].append(con[1]) |
| tl_target = {} |
| for u, (c, n, s, node) in to.items(): |
| if c != b"Deformer" or s != b"Cluster": continue |
| bone = next((clean(to[k][1]) for k in tkids[u] |
| if k in to and to[k][0] == b"Model"), None) |
| g = {ch.name: ch for ch in node.children} |
| if bone and b"TransformLink" in g and bone not in tl_target: |
| tl_target[bone] = _mat(rd_array(g[b"TransformLink"].props[0])[0]) |
| if bind == "donor": |
| tl_target = {} |
| elif bind != "self": |
| tl_target = bind_pose_of(bind) |
| if tl_target: |
| log.append("目标绑定姿势来源 %s：%d 根骨骼" % |
| ("本片自身" if bind == "self" else os.path.basename(bind), len(tl_target))) |
| else: |
| log.append("采用供体的绑定姿势（与供体所属的物种基准一致）") |
|
|
| orphan = {u for u, (c, n, s, _) in to.items() |
| if c == b"Deformer" and s in (b"Skin", b"Cluster")} |
| if orphan: |
| tobj.children = [ch for ch in tobj.children |
| if not (len(ch.props) >= 3 and sval(ch.props[0]) in orphan)] |
| tcon.children = [ch for ch in tcon.children |
| if not ({sval(ch.props[1]), sval(ch.props[2])} & orphan)] |
| log.append("删除孤儿 %d 个 Deformer 及其连接" % len(orphan)) |
|
|
| |
| by_name = collections.defaultdict(dict) |
| for u, (c, n, s, _) in to.items(): |
| by_name[c][clean(n)] = u |
|
|
| |
| nxt = max(list(to) + list(do)) + 1000 |
| remap, moved = {}, [] |
| for u, (c, n, s, node) in sorted(do.items()): |
| if (c, s) in MOVE: |
| remap[u] = nxt; nxt += 1 |
| moved.append((u, c, n, s, node)) |
| for u, c, n, s, node in moved: |
| cp = copy_node(node) |
| cp.props[0] = uid_prop(remap[u]) |
| tobj.children.append(cp) |
| log.append("移入 %d 个对象: %s" % (len(moved), ", ".join( |
| "%s::%s" % (clean(c), clean(s)) for _, c, _, s, _ in moved[:3]) + " …")) |
|
|
| |
| dropped_pose = 0 |
| for u, c, n, s, node in moved: |
| if (c, s) != (b"Pose", b"BindPose"): continue |
| cp = [x for x in tobj.children if sval(x.props[0]) == remap[u]][0] |
| keep = [] |
| for pn in cp.children: |
| if pn.name != b"PoseNode": keep.append(pn); continue |
| ref = next((ch for ch in pn.children if ch.name == b"Node"), None) |
| new = ref and translate(sval(ref.props[0]), do, remap, by_name) |
| if new is None: dropped_pose += 1; continue |
| ref.props[0] = uid_prop(new); keep.append(pn) |
| cp.children = keep |
| for ch in cp.children: |
| if ch.name == b"Properties70": continue |
| if ch.name == b"NbPoseNodes": |
| ch.props[0] = ("I", struct.pack("<i", sum( |
| 1 for x in cp.children if x.name == b"PoseNode"))) |
|
|
| |
| added = skipped = 0 |
| for con in connections(dt): |
| kind, cu, pu = con[0], con[1], con[2] |
| if not ({cu, pu} & set(remap)): continue |
| a = translate(cu, do, remap, by_name) |
| b = translate(pu, do, remap, by_name) |
| if a is None or b is None: skipped += 1; continue |
| n = Node(b"C") |
| n.props = [("S", kind), uid_prop(a), uid_prop(b)] |
| if len(con) > 3: n.props.append(("S", con[3])) |
| tcon.children.append(n); added += 1 |
| log.append("接入 %d 条连接（%d 条无对应端点已跳过，弃用 PoseNode %d 个）" |
| % (added, skipped, dropped_pose)) |
|
|
| |
| if tl_target: |
| rebind(tt, tl_target, log) |
| if not had_pose and tl_target: |
| |
| |
| gone = {u for u, (c, n, s, _) in objects(tt).items() if c == b"Pose"} |
| if gone: |
| tobj.children = [ch for ch in tobj.children |
| if not (len(ch.props) >= 3 and sval(ch.props[0]) in gone)] |
| tcon.children = [ch for ch in tcon.children |
| if not ({sval(ch.props[1]), sval(ch.props[2])} & gone)] |
| log.append("丢弃供体 BindPose %d 个（本片原本没有，且它记的是供体姿势）" % len(gone)) |
|
|
| |
| n_add, n_lay = collapse_layered(tt) |
| if n_lay: |
| log.append("压平 %d 个 LayeredTexture，改为 %d 条 Texture→Material 直连" % (n_lay, n_add)) |
|
|
| |
| defs = top(tt, b"Definitions") |
| if defs: |
| want = collections.Counter() |
| for u, (c, n, s, _) in objects(tt).items(): want[c] += 1 |
| for ch in defs.children: |
| if ch.name != b"ObjectType": continue |
| k = sval(ch.props[0]) |
| if k in want: |
| for cc in ch.children: |
| if cc.name == b"Count": |
| cc.props[0] = ("I", struct.pack("<i", want[k])) |
| for ch in defs.children: |
| if ch.name == b"Count": |
| ch.props[0] = ("I", struct.pack("<i", sum(want.values()))) |
|
|
| if dry: return log, None |
| data = serialize(tt) |
| tmp = target_path + ".tmp" |
| with open(tmp, "wb") as fh: fh.write(data) |
| os.replace(tmp, target_path) |
| return log, len(data) |
|
|
|
|
| def collapse_layered(tt): |
| """Rewire `Texture -> Material` directly, dropping the `LayeredTexture` level. |
| |
| This clip routes its textures `Video -> Texture -> LayeredTexture -> Material`. |
| That is legal FBX, but importers that only look for a texture connected straight |
| to a material property see an untextured mesh — the pixels load and go unused. |
| It is the only file in the dataset wired this way; the other 1,096 connect |
| `Texture -> Material` directly, which is what this reproduces. |
| """ |
| to, tcon, tobj = objects(tt), top(tt, b"Connections"), top(tt, b"Objects") |
| layered = {u for u, (c, n, s, _) in to.items() if c == b"LayeredTexture"} |
| if not layered: return 0, 0 |
| feed = {} |
| for con in connections(tt): |
| if con[0] == b"OO" and con[2] in layered and to.get(con[1], (b"",))[0] == b"Texture": |
| feed[con[2]] = con[1] |
| kept, added = [], 0 |
| for ch in tcon.children: |
| p = [sval(x) for x in ch.props] |
| if not ({p[1], p[2]} & layered): |
| kept.append(ch); continue |
| if p[1] in layered and len(p) > 3 and to.get(p[2], (b"",))[0] == b"Material" \ |
| and p[1] in feed: |
| n = Node(b"C") |
| n.props = [("S", p[0]), uid_prop(feed[p[1]]), uid_prop(p[2]), ("S", p[3])] |
| kept.append(n); added += 1 |
| tcon.children = kept |
| tobj.children = [ch for ch in tobj.children |
| if not (len(ch.props) >= 3 and sval(ch.props[0]) in layered)] |
| return added, len(layered) |
|
|
|
|
| def translate(uid, do, remap, by_name): |
| """A donor uid, as it should be referred to inside the target.""" |
| if uid == 0: return 0 |
| if uid in remap: return remap[uid] |
| ent = do.get(uid) |
| if not ent: return None |
| cls, nm, sub, _ = ent |
| return by_name.get(cls, {}).get(clean(nm)) |
|
|
|
|
| |
|
|
| def main(argv): |
| if not argv or argv[0] not in ("--selftest", "--donor", "--inspect"): |
| print(__doc__); return 2 |
| mode, rest = argv[0], argv[1:] |
|
|
| if mode == "--selftest": |
| bad = 0 |
| for p in rest: |
| same = serialize(parse(p)) == open(p, "rb").read() |
| print("%-6s %s" % ("ok" if same else "DIFF", p)); bad += not same |
| return 1 if bad else 0 |
|
|
| if mode == "--inspect": |
| for p in rest: |
| i = inspect(p) |
| print("%-34s verts %-6d idx %-6d geom %d meshnode %d limbs %-3d skin %d cluster %-3d bindpose %d" |
| % (os.path.basename(p), i["verts"], i["poly_indices"], i["geometry"], |
| i["model_mesh"], i["limbs"], i["skins"], i["clusters"], i["bindpose"])) |
| return 0 |
|
|
| bind = "donor" |
| if "--bind" in rest: |
| i = rest.index("--bind"); bind = rest[i + 1]; rest = rest[:i] + rest[i + 2:] |
| donor, targets = rest[0], rest[1:] |
| for t in targets: |
| for p in (donor, t): |
| if serialize(parse(p)) != open(p, "rb").read(): |
| print("拒绝执行：%s 无法字节级往返" % p); return 1 |
| before = os.path.getsize(t) |
| log, size = graft(donor, t, bind=bind) |
| print("%s ← %s" % (t, donor)) |
| for line in log: print(" " + line) |
| print(" %d → %d 字节" % (before, size)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main(sys.argv[1:])) |
|
|
