| """Per-take motion: which `AnimationStack` in an FBX actually carries animation. |
| |
| `fbx_takes.py` counts the stacks; this says which of them hold anything. The two |
| disagree on four files in this library, where a C4D export left an empty second |
| stack named `Take 001` beside the real motion — no layers with curves under it, |
| nothing to play. Counting stacks calls those files two-take; following the |
| connections shows they hold one action and one empty shell. |
| |
| Walks `Connections` from each stack down through its layers and curve nodes to |
| the curves themselves, then reports how many of those curves move. |
| """ |
| import struct, sys, zlib, collections |
| SCALAR={"Y":2,"C":1,"I":4,"F":4,"D":8,"L":8}; ELEM={"f":4,"d":8,"l":8,"i":4,"b":1} |
| FMT={"f":"f","d":"d","l":"q","i":"i","b":"b"} |
|
|
| def analyse(path): |
| d=open(path,"rb").read(); u64=struct.unpack("<I",d[23:27])[0]>=7500; N=25 if u64 else 13 |
| obj={}; conn=[]; curve_vals={} |
| def rp(p,want): |
| 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: |
| n,enc,cl=struct.unpack("<III",d[p:p+12]); p+=12 |
| body=cl if enc else n*ELEM[t]; raw=d[p:p+body]; p+=body |
| if want and n: |
| try: |
| if enc: raw=zlib.decompress(raw) |
| return p,(t,struct.unpack("<%d%s"%(n,FMT[t]),raw[:n*ELEM[t]])) |
| except Exception: return p,(t,None) |
| return p,(t,None) |
| if t in "SR": |
| ln=struct.unpack("<I",d[p:p+4])[0]; p+=4; v=d[p:p+ln]; p+=ln; return p,(t,v) |
| raise ValueError(t) |
| def rn(p,owner=None): |
| if u64: e,np_,pl=struct.unpack("<QQQ",d[p:p+24]); q=p+24 |
| else: e,np_,pl=struct.unpack("<III",d[p:p+12]); q=p+12 |
| if e==0 and np_==0 and pl==0: return p+N |
| nl=d[q]; q+=1; nm=d[q:q+nl]; q+=nl; p=q |
| want = nm==b"KeyValueFloat"; props=[] |
| for _ in range(np_): |
| p,x=rp(p,want); props.append(x) |
| mine=owner |
| if nm in (b"AnimationStack",b"AnimationLayer",b"AnimationCurveNode",b"AnimationCurve") and len(props)>=2: |
| uid=struct.unpack("<q",props[0][1])[0] |
| obj[uid]=(nm.decode(), props[1][1].split(b"\x00\x01")[0].decode("utf8","replace")) |
| mine=uid |
| elif nm==b"C" and len(props)>=3: |
| try: conn.append((props[0][1], struct.unpack("<q",props[1][1])[0], struct.unpack("<q",props[2][1])[0])) |
| except Exception: pass |
| elif want and props and props[0][1]: |
| v=props[0][1] |
| if owner is not None: curve_vals[owner]=max(v)-min(v) |
| while p<e: |
| if d[p:p+N]==b"\x00"*N: p+=N; break |
| p=rn(p,mine) |
| return e |
| p=27 |
| while p<len(d)-160: |
| if d[p:p+N]==b"\x00"*N: break |
| p=rn(p) |
| kids=collections.defaultdict(list) |
| for kind,child,parent in conn: kids[parent].append(child) |
| out=[] |
| for uid,(t,name) in obj.items(): |
| if t!="AnimationStack": continue |
| curves=[] |
| for lay in [c for c in kids[uid] if obj.get(c,("",""))[0]=="AnimationLayer"]: |
| for cn in [c for c in kids[lay] if obj.get(c,("",""))[0]=="AnimationCurveNode"]: |
| for cv in [c for c in kids[cn] if obj.get(c,("",""))[0]=="AnimationCurve"]: |
| if cv in curve_vals: curves.append(curve_vals[cv]) |
| moving=[r for r in curves if r>1e-6] |
| out.append((name, len(curves), len(moving), max(curves) if curves else 0.0)) |
| return out |
|
|
| def takes_with_motion(path): |
| """How many of the file's stacks actually carry a curve.""" |
| return sum(1 for _, ncurves, _, _ in analyse(path) if ncurves) |
|
|
|
|
| if __name__=="__main__": |
| import os |
| for f in sys.argv[1:]: |
| print(os.path.basename(f)) |
| for name,n,mv,mx in analyse(f): |
| print(" take %-24s curves=%-4d moving=%-4d max_range=%.4f%s" |
| %(name,n,mv,mx," <- empty" if not n else "")) |
|
|
