File size: 6,379 Bytes
a84fca7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 | #!/usr/bin/env python3
"""Read a binary FBX (Kaydara 7.x): skeleton, animation length and root joint.
Walks the node tree, collecting LimbNode/Root models as joints and the longest
KeyTime track as the timeline, then reads the `Connections` block to find which
joint sits at the top of the hierarchy. Frame rate is measured from the key
times themselves rather than assumed. Self-contained; no external deps.
"""
import os, struct, sys, zlib
SCALAR = {"Y": 2, "C": 1, "I": 4, "F": 4, "D": 8, "L": 8}
ELEM = {"f": 4, "d": 8, "l": 8, "i": 4, "b": 1}
FBX_KTIME = 46186158000 # ktime units per second
def _parse(path):
d = open(path, "rb").read()
if d[:21] != b"Kaydara FBX Binary \x00":
raise ValueError("not a binary FBX")
version = struct.unpack("<I", d[23:27])[0]
u64 = version >= 7500
NREC = 25 if u64 else 13
joints, keytimes = [], [] # joints: (uid, name); keytimes: (n, type, slice)
models, links = {}, [] # every Model uid -> name; child -> parent edges
animated = [] # object-property edges: curve node -> the model it drives
def rd_prop(p):
t = chr(d[p]); s = p; p += 1
if t in SCALAR:
p += SCALAR[t]; return p, (t, d[s + 1:p])
if t in ELEM:
length, enc, clen = struct.unpack("<III", d[p:p + 12]); p += 12
body = clen if enc else length * ELEM[t]
start = p; p += body
return p, (t, b"", length, (start, body, enc))
if t in "SR":
ln = struct.unpack("<I", d[p:p + 4])[0]; p += 4
val = d[p:p + ln]; p += ln
return p, (t, val)
raise ValueError("bad prop %r" % t)
def rd_node(p):
if u64: end, nprop, plen = struct.unpack("<QQQ", d[p:p + 24]); q = p + 24
else: end, nprop, plen = struct.unpack("<III", d[p:p + 12]); q = p + 12
if end == 0 and nprop == 0 and plen == 0:
return p + NREC
nl = d[q]; q += 1; name = d[q:q + nl]; q += nl
p = q; props = []
for _ in range(nprop):
p, pr = rd_prop(p); props.append(pr)
if name == b"Model" and len(props) >= 3:
uid = struct.unpack("<q", props[0][1])[0] if props[0][0] == "L" else 0
nm = props[1][1].split(b"\x00\x01")[0].decode("utf-8", "replace")
models[uid] = nm
if props[2][1] in (b"LimbNode", b"Root"):
joints.append((uid, nm))
elif name == b"KeyTime" and props and len(props[0]) == 4:
keytimes.append((props[0][2], props[0][0], props[0][3]))
elif name == b"C" and len(props) >= 3 and props[0][1] in (b"OO", b"OP"):
try:
a = struct.unpack("<q", props[1][1])[0]
b = struct.unpack("<q", props[2][1])[0]
except (struct.error, TypeError):
return end
(links if props[0][1] == b"OO" else animated).append((a, b))
while p < end:
if d[p:p + NREC] == b"\x00" * NREC: p += NREC; break
p = rd_node(p)
return end
p = 27
while p < len(d) - 160:
if d[p:p + NREC] == b"\x00" * NREC: break
p = rd_node(p)
return d, version, joints, keytimes, links, animated
ELEM_FMT = {"f": "f", "d": "d", "l": "q", "i": "i", "b": "b"}
def _timeline(d, keytimes):
"""Frames and frame rate, read off the longest key-time track.
The track is decoded rather than counted so the spacing is measured: every
clip in this library keys on a strict 1/30 s grid, and a clip that did not
would report its own rate instead of inheriting an assumed one.
"""
if not keytimes:
return 0, 0.0
n, t, (start, body, enc) = max(keytimes, key=lambda k: k[0])
raw = d[start:start + body]
try:
if enc:
raw = zlib.decompress(raw)
vals = struct.unpack("<%d%s" % (n, ELEM_FMT[t]), raw[:n * ELEM[t]])
except Exception:
return n, 0.0
steps = sorted({vals[i + 1] - vals[i] for i in range(len(vals) - 1)})
step = steps[0] if steps else 0
return n, round(FBX_KTIME / step, 3) if step else 0.0
def probe(path):
d, version, joints, keytimes, links, animated = _parse(path)
frames, fps = _timeline(d, keytimes)
# The exporter types every node in the hierarchy as a `LimbNode`, mesh and
# null containers included, so the topmost one is often `Null` or `U3DMesh 1`
# rather than a bone. The root reported is instead the highest joint that
# actually carries animation — the node a retargeter would drive — with the
# largest subtree breaking ties. `joint_names` carries the full list.
ids = {uid for uid, _ in joints}
parent, children = {}, {}
for child, par in links:
if child in ids and child not in parent:
parent[child] = par
children.setdefault(par, []).append(child)
def subtree(uid, seen=None):
seen = seen or set()
if uid in seen:
return 0
seen.add(uid)
return 1 + sum(subtree(c, seen) for c in children.get(uid, ()))
def depth(uid, seen=None):
seen = seen or set()
d = 0
while uid in parent and uid not in seen:
seen.add(uid); uid = parent[uid]; d += 1
return d
driven = {par for _, par in animated} & ids
pool = driven or ids
roots = sorted(((uid, nm) for uid, nm in joints if uid in pool),
key=lambda t: (depth(t[0]), -subtree(t[0])))
names = [nm for _, nm in joints]
return {
"fbx_version": version,
"num_joints": len(set(names)),
"keyframes": frames,
"fps": fps,
"duration_sec": round((frames - 1) / fps, 4) if fps and frames > 1 else 0.0,
"root_joint": roots[0][1] if roots else "",
"num_animated": len(driven),
"joints": sorted(set(names)),
"joint_names": "|".join(sorted(set(names)))[:400],
}
if __name__ == "__main__":
for p in sys.argv[1:]:
try:
r = probe(p)
print("%-34s ver=%s joints=%-4d keys=%-5d %-5s fps %.2fs root=%s" % (
os.path.basename(p), r["fbx_version"], r["num_joints"],
r["keyframes"], r["fps"], r["duration_sec"], r["root_joint"]))
except Exception as e:
print("%-34s ERROR %s" % (os.path.basename(p), str(e)[:60]))
|