| |
| """Graft an embedded texture into a binary FBX that references one externally. |
| |
| fbx_embed_texture.py --selftest <fbx>... byte-identical round trip |
| fbx_embed_texture.py --donor <fbx> <fbx>... copy the donor's Video/Content |
| into each target, in place |
| |
| Truebones embeds its textures in the FBX itself — 73 of the 74 species carry the |
| pixels in a `Video/Content` property, so a clip renders correctly wherever it is |
| opened. `Cat` is the exception: its four standalone clips were exported without |
| "embed media", so they carry only a `RelativeFilename` pointing at a `Cat.fbm/` |
| directory that does not exist. They render untextured from `animation/`, whose |
| flat layout puts no image anywhere the importer's search can reach. |
| |
| The fix is not a re-export, which would rebuild the rig. The file is parsed into |
| its node tree, one `Content` node is inserted into `Video`, and the tree is |
| re-serialized with recomputed offsets — every node record stores an absolute end |
| offset, so an insertion shifts everything after it. Nothing else is touched. |
| |
| The `Content` node is copied verbatim from a donor file of the same species that |
| does have it (`Cat-ALL.fbx`), rather than synthesised, so the property encoding |
| and node framing are known-good rather than guessed. |
| |
| Correctness gate: with no edits the serializer must reproduce its input byte for |
| byte (`--selftest`). Some nodes carry a trailing null record despite having no |
| children; that is tracked per node so round trips stay exact. |
| |
| Writes through a temporary file and renames it into place. Every clip here is a |
| hardlink of one in `Truebone_Z-OO/`, and writing to such a path writes through to |
| the original. |
| """ |
| import os, struct, sys |
|
|
| ELEM = {'f':4,'d':8,'l':8,'i':4,'b':1} |
| SCALAR = {"Y":2,"C":1,"I":4,"F":4,"D":8,"L":8} |
|
|
|
|
| class Node: |
| __slots__ = ("name","props","children","nullrec") |
| def __init__(s, name): s.name=name; s.props=[]; s.children=[]; s.nullrec=False |
|
|
|
|
| def parse(path): |
| d=open(path,'rb').read() |
| assert d[:21]==b"Kaydara FBX Binary \x00", "not a binary FBX" |
| version=struct.unpack("<I",d[23:27])[0]; u64=version>=7500 |
| NREC=25 if u64 else 13 |
|
|
| 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]); hdr=d[p:p+12]; p+=12 |
| body=clen if enc else length*ELEM[t] |
| data=d[p:p+body]; p+=body |
| return p,(t,hdr+data) |
| if t in "SR": |
| ln=struct.unpack("<I",d[p:p+4])[0]; p+=4 |
| data=d[p:p+ln]; p+=ln |
| return p,(t,data) |
| raise ValueError("bad prop type %r @%d"%(t,s)) |
|
|
| def is_null(p): return p+NREC<=len(d) and d[p:p+NREC]==b"\x00"*NREC |
|
|
| 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 None,p+NREC |
| nl=d[q]; q+=1; name=d[q:q+nl]; q+=nl |
| n=Node(name); p=q |
| for _ in range(nprop): |
| p,pr=rd_prop(p); n.props.append(pr) |
| while p<end: |
| if is_null(p): n.nullrec=True; p+=NREC; break |
| c,p2=rd_node(p) |
| if c is None: n.nullrec=True; p=p2; break |
| n.children.append(c); p=p2 |
| return n,end |
|
|
| p=27; top=[]; tnull=False |
| while p<len(d): |
| if is_null(p): tnull=True; p+=NREC; break |
| n,p2=rd_node(p) |
| if n is None: tnull=True; p=p2; break |
| top.append(n); p=p2 |
| return {"header":d[:27],"u64":u64,"top":top,"footer":d[p:], |
| "toplevel_null":tnull,"orig":d,"version":version} |
|
|
|
|
| def pbytes(t,pay): |
| if t in "SR": return t.encode()+struct.pack("<I",len(pay))+pay |
| return t.encode()+pay |
|
|
| def nsize(n,u64): |
| NREC=25 if u64 else 13 |
| sz=NREC+len(n.name) |
| sz+=sum(len(pbytes(t,p)) for t,p in n.props) |
| sz+=sum(nsize(c,u64) for c in n.children) |
| if n.nullrec: sz+=NREC |
| return sz |
|
|
| def wnode(out,n,u64): |
| NREC=25 if u64 else 13 |
| props=b"".join(pbytes(t,p) for t,p in n.props) |
| end=len(out)+nsize(n,u64) |
| out += struct.pack("<QQQ",end,len(n.props),len(props)) if u64 else \ |
| struct.pack("<III",end,len(n.props),len(props)) |
| out += bytes([len(n.name)])+n.name+props |
| for c in n.children: wnode(out,c,u64) |
| if n.nullrec: out+=b"\x00"*NREC |
|
|
| def serialize(t): |
| out=bytearray(t["header"]) |
| for n in t["top"]: wnode(out,n,t["u64"]) |
| if t["toplevel_null"]: out+=b"\x00"*(25 if t["u64"] else 13) |
| out+=t["footer"] |
| return bytes(out) |
|
|
|
|
| def walk(nodes): |
| for n in nodes: |
| yield n |
| for x in walk(n.children): yield x |
|
|
| def donor_content(path): |
| """The `Content` node of the donor's `Video`, with its raw payload.""" |
| t=parse(path) |
| for n in walk(t["top"]): |
| if n.name!=b"Video": continue |
| for c in n.children: |
| if c.name==b"Content" and c.props and c.props[0][0]=="R" and len(c.props[0][1])>64: |
| return c |
| raise SystemExit("donor has no Video/Content: "+path) |
|
|
| def graft(path, content): |
| """Insert a copy of `content` into every Video node that lacks one.""" |
| t=parse(path); added=0 |
| for n in walk(t["top"]): |
| if n.name!=b"Video": continue |
| if any(c.name==b"Content" for c in n.children): continue |
| c=Node(b"Content"); c.props=list(content.props); c.nullrec=content.nullrec |
| |
| idx=max((i for i,ch in enumerate(n.children) |
| if ch.name in (b"RelativeFilename", b"Filename")), default=len(n.children)-1) |
| n.children.insert(idx+1, c); added+=1 |
| return added, serialize(t) |
|
|
|
|
| if __name__=="__main__": |
| a=sys.argv[1:] |
| if a and a[0]=="--selftest": |
| ok=True |
| for f in a[1:]: |
| t=parse(f); same=serialize(t)==t["orig"]; ok&=same |
| print(" %-30s identical=%s (%d bytes)"%(os.path.basename(f),same,len(t["orig"]))) |
| sys.exit(0 if ok else 1) |
| if a and a[0]=="--donor": |
| content=donor_content(a[1]) |
| print("donor blob: %d bytes"%len(content.props[0][1])) |
| for f in a[2:]: |
| t=parse(f) |
| assert serialize(t)==t["orig"], "round trip failed, refusing to edit "+f |
| n,data=graft(f, content) |
| tmp=f+".tmp" |
| open(tmp,"wb").write(data) |
| os.replace(tmp, f) |
| print(" %-30s +%d Content %d -> %d bytes"%(os.path.basename(f),n,len(t["orig"]),len(data))) |
| sys.exit(0) |
| sys.exit(__doc__) |
|
|
