Files
VRMify-Enhanced/formats/uemodelio.py
T
Black-Cyan 60cce66993
Tests / test (push) Has been cancelled
初始化 VRMify 增强版(VRMify Enhanced)
导入上游源码,为所有面向用户的品牌显示处添加「增强版 / Enhanced」标识;包含 unitypackage→VRM 的纯色 Toon 材质、兽耳 SpringBone、Unity 描边、UV 接缝白边补偿修复,以及默认不强制 T-pose。146 个单元测试通过。
2026-11-15 23:21:59 +08:00

874 lines
28 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# -*- coding: utf-8 -*-
"""UEFormat(.uemodel)读写库 —— 纯标准库。
`.uemodel` 不是某游戏的私有格式,而是 **UEFormat**:FortnitePorting / FModel /
CUE4Parse 用来在「UE 资源」和「Blender / UE 插件」之间交换模型的公开中间格式,
规范在 https://github.com/h4lfheart/UEFormat (docs/generic.md + docs/uemodel.md),
Blender 插件(io_scene_ueformat)与 UE 插件都是开源的。所以它**有统一标准**。
但标准有过一次结构性改版(version.py 里的 AttributeFormatRestructure = 10),
所以实际存在两套字节布局:
v <= 9(legacy)
头部: "UEFORMAT" + FString Identifier + u8 FileVersion + FString ObjectName
+ bool bIsCompressed
主体: 从当前位置一口气读到 EOF,每个「分块」是
FString Name + i32 ArraySize + i32 ByteSize + ByteSize 字节负载
ArraySize 是**负载内**数组的元素个数,写在分块头部;
负载里不再重复数组长度。
v >= 10(AttributeFormatRestructure)
头部: 同上,但在 ObjectName 之后多了 FString ObjectPath
主体: FDataAttributeSet = i32 Count + Count × (FString Name + i32 ByteSize + 负载)
数组长度写在负载内部的 TArray 前缀里(i32 Count + 元素)。
读取端按版本自动分派;写出端两版都能写。
坐标与单位(实测样本 + UE 约定)
UE 是**左手系、Z 轴向上**,X 向前、Y 向右;1 单位 = 1 cm。
MMD/PMX 是左手系、Y 轴向上、脸朝 -Z。两边手性相同(行列式 +1),
所以只需要换轴、**不需要反绕序**(见 convert/uemodel2pmx.py)。
自检口径:`read_uemodel()` 结束时必须 `r.p == len(r.b)`,与 pmxio 的
`consumed == filesize` 一个路子;分块负载也逐个按 ByteSize 切片消费,
任何一段读偏都会在末尾暴露成「末尾字节数不符」。
"""
import os
import struct
import sys
MAGIC = b"UEFORMAT"
IDENT_MODEL = "UEMODEL"
VERSION_LATEST = 10 # AttributeFormatRestructure
V_SERIALIZE_BINORMAL = 1 # NORMALS 里开始带 binormalSign
V_MULTI_VCOLOR = 2 # VERTEXCOLORS 支持多套
V_LOD_RESTRUCTURE = 4 # LOD 变成 name + 独立大小
V_VIRTUAL_BONES = 5
V_MATERIAL_PATH = 6
V_ASSET_METADATA = 7
V_PRESERVE_TRANSFORM = 8 # BONES 带 scale
V_ATTR_RESTRUCTURE = 10 # 布局大改(见模块 docstring)
def _repair_version(v):
"""老版本写出来的 0 号版本其实等于 1(BinormalSign 已经在了)。"""
return V_SERIALIZE_BINORMAL if v == 0 else v
# ------------------------------------------------------------------ 数据结构 --
class Bone(object):
__slots__ = ("name", "parent", "pos", "rot", "scale")
def __init__(self, name="", parent=-1, pos=(0.0, 0.0, 0.0),
rot=(0.0, 0.0, 0.0, 1.0), scale=(1.0, 1.0, 1.0)):
self.name = name
self.parent = parent
self.pos = pos
self.rot = rot
self.scale = scale
class Socket(object):
__slots__ = ("name", "bone", "pos", "rot", "scale")
def __init__(self, name="", bone="", pos=(0.0, 0.0, 0.0),
rot=(0.0, 0.0, 0.0, 1.0), scale=(1.0, 1.0, 1.0)):
self.name = name
self.bone = bone
self.pos = pos
self.rot = rot
self.scale = scale
class Skeleton(object):
__slots__ = ("path", "bones", "sockets", "virtual_bones")
def __init__(self):
self.path = ""
self.bones = []
self.sockets = []
self.virtual_bones = [] # [(source, target, virtual)]
class VertexColor(object):
__slots__ = ("name", "data") # data: [(r,g,b,a)] 0~255
def __init__(self, name="COL0", data=None):
self.name = name
self.data = data or []
class Material(object):
__slots__ = ("name", "path", "first_index", "num_faces")
def __init__(self, name="", path="", first_index=0, num_faces=0):
self.name = name
self.path = path
self.first_index = first_index # 索引入缓冲(顶点索引)里的起点
self.num_faces = num_faces # 三角面数
@property
def first_face(self):
return self.first_index // 3
class Weight(object):
__slots__ = ("bone", "vertex", "weight")
def __init__(self, bone=0, vertex=0, weight=0.0):
self.bone = bone
self.vertex = vertex
self.weight = weight
class MorphDelta(object):
__slots__ = ("pos", "normal", "vertex")
def __init__(self, pos=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 0.0), vertex=0):
self.pos = pos
self.normal = normal
self.vertex = vertex
class Morph(object):
__slots__ = ("name", "deltas")
def __init__(self, name="", deltas=None):
self.name = name
self.deltas = deltas or []
class UVSet(object):
__slots__ = ("name", "uvs")
def __init__(self, name="UV0", uvs=None):
self.name = name
self.uvs = uvs or []
class Collision(object):
__slots__ = ("name", "vertices", "indices", "faces")
def __init__(self, name="", vertices=None, indices=None):
self.name = name
self.vertices = vertices or []
self.indices = indices or []
class LOD(object):
def __init__(self, name="LOD0"):
self.name = name
self.vertices = [] # [(x, y, z)]
self.normals = [] # [(x, y, z)]
self.binormals = [] # 每顶点 binormal sign(FNormal 的第一个 float)
self.tangents = [] # [(x, y, z)]
self.uvs = [] # [UVSet]
self.indices = [] # 三角面顶点索引(每 3 个一面)
self.colors = [] # [VertexColor]
self.materials = [] # [Material]
self.weights = [] # [Weight](稀疏:一个顶点可能有多条)
self.morphs = [] # [Morph]
def stats(self):
return {"verts": len(self.vertices), "tris": len(self.indices) // 3,
"mats": len(self.materials), "weights": len(self.weights),
"morphs": len(self.morphs), "uvsets": len(self.uvs)}
class UEModel(object):
def __init__(self):
self.identifier = IDENT_MODEL
self.version = VERSION_LATEST
self.name = ""
self.path = ""
self.compressed = False
self.lods = []
self.skeleton = Skeleton()
self.collisions = []
def stats(self):
return {"version": self.version, "lods": len(self.lods),
"bones": len(self.skeleton.bones),
"sockets": len(self.skeleton.sockets),
"collisions": len(self.collisions),
"skinned": bool(self.lods and self.lods[0].weights)}
# --------------------------------------------------------------------- 读取 --
class _R(object):
__slots__ = ("b", "p")
def __init__(self, data):
self.b = data
self.p = 0
def eof(self):
return self.p >= len(self.b)
def left(self):
return len(self.b) - self.p
def u8(self):
v = self.b[self.p]
self.p += 1
return v
def bool(self):
return self.u8() != 0
def i16(self):
v = struct.unpack_from("<h", self.b, self.p)[0]
self.p += 2
return v
def u16(self):
v = struct.unpack_from("<H", self.b, self.p)[0]
self.p += 2
return v
def i32(self):
v = struct.unpack_from("<i", self.b, self.p)[0]
self.p += 4
return v
def u32(self):
v = struct.unpack_from("<I", self.b, self.p)[0]
self.p += 4
return v
def f32(self):
v = struct.unpack_from("<f", self.b, self.p)[0]
self.p += 4
return v
def vec(self, n):
v = struct.unpack_from("<%df" % n, self.b, self.p)
self.p += 4 * n
return v
def ints(self, n):
v = struct.unpack_from("<%dI" % n, self.b, self.p) if n > 0 else ()
self.p += 4 * n
return v
def bytes(self, n):
v = self.b[self.p:self.p + n]
self.p += n
return v
def fstr(self):
n = self.i32()
if n <= 0:
return ""
raw = self.b[self.p:self.p + n]
self.p += n
return raw.rstrip(b"\x00").decode("utf-8", "replace")
def _chunks(r, version):
"""按版本迭代「分块」,产出 (name, array_size, payload_reader)。
负载一律按声明字节数切出来单独给一个 reader —— 与官方 iter_chunks 的
「读完 seek 到下一个块」等价,任何一段读偏都不会污染后面的分块。
"""
if version >= V_ATTR_RESTRUCTURE:
count = r.i32()
for _ in range(count):
name = r.fstr()
size = r.i32()
yield name, None, _R(r.bytes(max(0, size)))
else:
while not r.eof():
name = r.fstr()
arr = r.i32()
size = r.i32()
yield name, arr, _R(r.bytes(max(0, size)))
def _arr_len(payload, version, array_size):
"""取「数组元素个数」:v10 在负载里,v9 在分块头。"""
if version >= V_ATTR_RESTRUCTURE:
return payload.i32()
return array_size if array_size is not None else 0
def _read_lod(r, version):
lod = LOD(name=r.fstr())
if version >= V_ATTR_RESTRUCTURE:
body = r
else:
body = _R(r.bytes(max(0, r.i32())))
for name, arr, pl in _chunks(body, version):
if name == "VERTICES":
n = _arr_len(pl, version, arr)
lod.vertices = [tuple(pl.vec(3)) for _ in range(n)]
elif name == "NORMALS":
n = _arr_len(pl, version, arr)
if version >= V_SERIALIZE_BINORMAL:
for _ in range(n):
sign = pl.f32()
lod.binormals.append(sign)
lod.normals.append(tuple(pl.vec(3)))
else:
lod.normals = [tuple(pl.vec(3)) for _ in range(n)]
elif name == "TANGENTS":
n = _arr_len(pl, version, arr)
lod.tangents = [tuple(pl.vec(3)) for _ in range(n)]
elif name == "TEXCOORDS":
n = _arr_len(pl, version, arr)
for _ in range(n):
# v10 起每个 UV 通道带名字,v9 没有
uname = pl.fstr() if version >= V_ATTR_RESTRUCTURE else ""
c = pl.i32()
uv = [tuple(pl.vec(2)) for _ in range(max(0, c))]
lod.uvs.append(UVSet(uname or ("UV%d" % len(lod.uvs)), uv))
elif name == "INDICES":
n = _arr_len(pl, version, arr)
lod.indices = list(pl.ints(max(0, n)))
elif name == "VERTEXCOLORS":
n = _arr_len(pl, version, arr)
for _ in range(n):
vc = VertexColor(name="COL0")
if version >= V_MULTI_VCOLOR:
vc.name = pl.fstr()
c = pl.i32()
raw = pl.bytes(max(0, c) * 4)
vc.data = [tuple(raw[i * 4:i * 4 + 4]) for i in range(max(0, c))]
lod.colors.append(vc)
elif name == "MATERIALS":
n = _arr_len(pl, version, arr)
for _ in range(n):
mat = Material(name=pl.fstr())
if version >= V_MATERIAL_PATH:
mat.path = pl.fstr()
mat.first_index = pl.i32()
mat.num_faces = pl.i32()
lod.materials.append(mat)
elif name == "WEIGHTS":
n = _arr_len(pl, version, arr)
for _ in range(n):
b = pl.u16() if version >= V_ATTR_RESTRUCTURE else pl.i16()
lod.weights.append(Weight(b, pl.i32(), pl.f32()))
elif name == "MORPHTARGETS":
n = _arr_len(pl, version, arr)
for _ in range(n):
mo = Morph(name=pl.fstr())
c = pl.i32()
for _ in range(max(0, c)):
p = tuple(pl.vec(3))
nn = tuple(pl.vec(3))
mo.deltas.append(MorphDelta(p, nn, pl.i32()))
lod.morphs.append(mo)
# 未知分块按声明大小跳过(已经按 ByteSize 切片,天然安全)
return lod
def _read_bones(payload, n, version):
"""骨骼数组:v10 带 scale;v9 不带。带自动回退以兼容不同写入器。"""
with_scale = version >= V_ATTR_RESTRUCTURE
bones = []
try:
for _ in range(n):
b = Bone(name=payload.fstr())
b.parent = payload.i32()
b.pos = tuple(payload.vec(3))
b.rot = tuple(payload.vec(4))
b.scale = tuple(payload.vec(3)) if with_scale else ()
bones.append(b)
except struct.error:
return None
if payload.p != len(payload.b):
return None
if not with_scale:
# 若按「无 scale」读却没正好吃到末尾,改按「有 scale」重来
alt = _R(payload.b)
bones2 = []
try:
for _ in range(n):
b = Bone(name=alt.fstr())
b.parent = alt.i32()
b.pos = tuple(alt.vec(3))
b.rot = tuple(alt.vec(4))
b.scale = tuple(alt.vec(3))
bones2.append(b)
except struct.error:
return bones
if alt.p == len(alt.b):
return bones2
return bones
def _read_skeleton(r, version):
sk = Skeleton()
for name, arr, pl in _chunks(r, version):
if name == "METADATA":
sk.path = pl.fstr()
elif name == "BONES":
n = _arr_len(pl, version, arr)
got = _read_bones(pl, max(0, n), version)
if got is not None:
sk.bones = got
elif name == "SOCKETS":
n = _arr_len(pl, version, arr)
for _ in range(max(0, n)):
s = Socket(name=pl.fstr(), bone=pl.fstr())
s.pos = tuple(pl.vec(3))
s.rot = tuple(pl.vec(4))
s.scale = tuple(pl.vec(3))
sk.sockets.append(s)
elif name == "VIRTUALBONES":
n = _arr_len(pl, version, arr)
for _ in range(max(0, n)):
sk.virtual_bones.append((pl.fstr(), pl.fstr(), pl.fstr()))
return sk
def _read_collision(h, version):
col = Collision(name=h.fstr())
nv = h.i32()
col.vertices = [tuple(h.vec(3)) for _ in range(max(0, nv))]
ni = h.i32()
col.indices = list(h.ints(max(0, ni)))
return col
def _decompress_body(r, src):
"""读取压缩体头部并解压,返回未压缩的字节流(分块流)。
支持 UEFormat 已用到的两种压缩:ZSTD(需 zstandard 第三方库)、
GZIP(标准库 gzip)。压缩体头部布局见 parse_uemodel 中的说明。
"""
import io
cfmt = (r.fstr() or "").upper()
uncompressed = r.i32()
compressed = r.i32()
payload = r.bytes(compressed) if compressed > 0 else r.left()
if cfmt == "ZSTD":
try:
import zstandard as zstd
except ImportError:
raise ValueError("该 .uemodel 是 ZSTD 压缩体,但运行环境缺少 zstandard 库,"
"无法解压:%s" % src)
dctx = zstd.ZstdDecompressor()
try:
if uncompressed > 0:
return dctx.decompress(payload, uncompressed)
# 帧内未记录原始大小:改用流式解压读完整帧
with dctx.stream_reader(io.BytesIO(payload)) as reader:
return reader.read()
except Exception as e:
raise ValueError("ZSTD 解压失败:%s(%s)" % (src, e))
elif cfmt in ("GZIP", "GZIPSTREAM"):
import gzip
try:
return gzip.decompress(payload)
except Exception as e:
raise ValueError("GZIP 解压失败:%s(%s)" % (src, e))
else:
raise ValueError("不支持的压缩格式 %r:%s" % (cfmt, src))
def read_uemodel(path, verbose=False):
"""读 .uemodel。返回 UEModel;末尾字节数不符直接抛 ValueError。"""
with open(path, "rb") as f:
data = f.read()
return parse_uemodel(data, verbose=verbose, src=path)
def parse_uemodel(data, verbose=False, src=""):
r = _R(data)
if r.bytes(8) != MAGIC:
raise ValueError("不是 UEFormat 文件(魔数不是 UEFORMAT):%s" % src)
m = UEModel()
m.identifier = r.fstr()
m.version = r.u8()
m.name = r.fstr()
if m.version >= V_ATTR_RESTRUCTURE:
m.path = r.fstr() # v10 起才有 ObjectPath
m.compressed = r.bool()
if m.compressed:
# 压缩体头部紧跟在 bIsCompressed 之后(UEFormat 规范):
# FString CompressionFormat + i32 UncompressedSize
# + i32 CompressedSize + CompressedData
# 解压后得到的就是未压缩的「分块流」,从偏移 0 起按普通流程解析即可。
raw = _decompress_body(r, src)
r = _R(raw)
if m.identifier not in ("UEMODEL", ""):
raise ValueError("不是模型文件(Identifier=%r):%s" % (m.identifier, src))
if m.version > VERSION_LATEST:
raise ValueError("UEFormat 版本 %d 高于本库支持的 %d:%s"
% (m.version, VERSION_LATEST, src))
ver = _repair_version(m.version)
for name, arr, pl in _chunks(r, ver):
if name == "LODS":
n = _arr_len(pl, ver, arr)
for _ in range(max(0, n)):
m.lods.append(_read_lod(pl, ver))
elif name == "SKELETON":
m.skeleton = _read_skeleton(pl, ver)
elif name == "COLLISION":
n = _arr_len(pl, ver, arr)
for _ in range(max(0, n)):
m.collisions.append(_read_collision(pl, ver))
# 未知顶层分块忽略
if r.p != len(r.b):
raise ValueError("解析失步:消费 %d 字节,文件 %d 字节(差 %d)"
% (r.p, len(r.b), len(r.b) - r.p))
if verbose:
print_uemodel(m, src=src)
return m
# --------------------------------------------------------------------- 写出 --
class _W(object):
__slots__ = ("buf",)
def __init__(self):
self.buf = bytearray()
def u8(self, v):
self.buf.append(v & 0xFF)
def bool(self, v):
self.u8(1 if v else 0)
def i16(self, v):
self.buf += struct.pack("<h", int(v))
def u16(self, v):
self.buf += struct.pack("<H", int(v) & 0xFFFF)
def i32(self, v):
self.buf += struct.pack("<i", int(v))
def u32(self, v):
self.buf += struct.pack("<I", int(v))
def f32(self, v):
self.buf += struct.pack("<f", float(v))
def vec(self, v):
self.buf += struct.pack("<%df" % len(v), *[float(x) for x in v])
def raw(self, b):
self.buf += b
def fstr(self, s):
b = (s or "").encode("utf-8")
self.i32(len(b))
self.buf += b
def get(self):
return bytes(self.buf)
def _pack_chunk(name, array_size, payload, version):
w = _W()
w.fstr(name)
if version < V_ATTR_RESTRUCTURE:
w.i32(array_size if array_size is not None else 0)
w.i32(len(payload))
w.raw(payload)
return w.get()
def _pack_attrset(items, version):
"""items: [(name, array_size, payload_bytes)]"""
w = _W()
if version >= V_ATTR_RESTRUCTURE:
w.i32(len(items))
for name, arr, payload in items:
w.raw(_pack_chunk(name, arr, payload, version))
return w.get()
def _pack_vec_array(vecs, version, width=3):
w = _W()
if version >= V_ATTR_RESTRUCTURE:
w.i32(len(vecs))
for v in vecs:
w.vec(v)
return w.get()
def _pack_indices(idx, version):
w = _W()
if version >= V_ATTR_RESTRUCTURE:
w.i32(len(idx))
for v in idx:
w.u32(v)
return w.get()
def _pack_lod(lod, version):
w = _W()
items = []
nv = len(lod.vertices)
items.append(("VERTICES", nv, _pack_vec_array(lod.vertices, version)))
nrm = _W()
if version >= V_ATTR_RESTRUCTURE:
nrm.i32(nv)
for i in range(nv):
n = lod.normals[i] if i < len(lod.normals) else (0.0, 0.0, 1.0)
sign = lod.binormals[i] if i < len(lod.binormals) else 1.0
nrm.f32(sign)
nrm.vec(n)
if version < V_SERIALIZE_BINORMAL:
# 极老版本(本库不产出):只写向量
old = _W()
for i in range(nv):
old.vec(lod.normals[i] if i < len(lod.normals) else (0.0, 1.0, 0.0))
items.append(("NORMALS", nv, old.get()))
else:
items.append(("NORMALS", nv, nrm.get()))
if lod.tangents:
items.append(("TANGENTS", nv, _pack_vec_array(lod.tangents, version)))
tex = _W()
if version >= V_ATTR_RESTRUCTURE:
tex.i32(len(lod.uvs))
for i, st in enumerate(lod.uvs):
if version >= V_ATTR_RESTRUCTURE:
tex.fstr(st.name or ("UV%d" % i))
tex.i32(len(st.uvs))
for uv in st.uvs:
tex.vec(uv)
items.append(("TEXCOORDS", len(lod.uvs), tex.get()))
items.append(("INDICES", len(lod.indices),
_pack_indices(lod.indices, version)))
if lod.colors:
vc = _W()
if version >= V_ATTR_RESTRUCTURE:
vc.i32(len(lod.colors))
for st in lod.colors:
if version >= V_MULTI_VCOLOR:
vc.fstr(st.name or "COL0")
vc.i32(len(st.data))
for c in st.data:
vc.u8(c[0] if len(c) > 0 else 255)
vc.u8(c[1] if len(c) > 1 else 255)
vc.u8(c[2] if len(c) > 2 else 255)
vc.u8(c[3] if len(c) > 3 else 255)
items.append(("VERTEXCOLORS", len(lod.colors), vc.get()))
if lod.materials:
mm = _W()
if version >= V_ATTR_RESTRUCTURE:
mm.i32(len(lod.materials))
for mt in lod.materials:
mm.fstr(mt.name)
if version >= V_MATERIAL_PATH:
mm.fstr(mt.path)
mm.i32(mt.first_index)
mm.i32(mt.num_faces)
items.append(("MATERIALS", len(lod.materials), mm.get()))
if lod.weights:
wt = _W()
if version >= V_ATTR_RESTRUCTURE:
wt.i32(len(lod.weights))
for x in lod.weights:
if version >= V_ATTR_RESTRUCTURE:
wt.u16(x.bone)
else:
wt.i16(x.bone)
wt.i32(x.vertex)
wt.f32(x.weight)
items.append(("WEIGHTS", len(lod.weights), wt.get()))
if lod.morphs:
mo = _W()
if version >= V_ATTR_RESTRUCTURE:
mo.i32(len(lod.morphs))
for m in lod.morphs:
mo.fstr(m.name)
mo.i32(len(m.deltas))
for d in m.deltas:
mo.vec(d.pos)
mo.vec(d.normal)
mo.i32(d.vertex)
items.append(("MORPHTARGETS", len(lod.morphs), mo.get()))
body = _pack_attrset(items, version)
if version >= V_ATTR_RESTRUCTURE:
# v10 的 UEModelLOD = FString Name + FDataAttributeSet(规范 docs/uemodel.md):
# 名字照写,但属性集**自带** i32 Count 定界,不再套一层 ByteSize。
# 曾经漏写这里的名 → 读取端读了名,整条 LOD 流错位,末尾报「解析失步」。
w.fstr(lod.name or "")
w.raw(body)
else:
w.fstr(lod.name)
w.i32(len(body))
w.raw(body)
return w.get()
def _pack_skeleton(sk, version):
items = []
if sk.path:
w = _W()
w.fstr(sk.path)
items.append(("METADATA", 1, w.get()))
bw = _W()
if version >= V_ATTR_RESTRUCTURE:
bw.i32(len(sk.bones))
for b in sk.bones:
bw.fstr(b.name)
bw.i32(b.parent)
bw.vec(b.pos)
bw.vec(b.rot if len(b.rot) == 4 else (0.0, 0.0, 0.0, 1.0))
if version >= V_ATTR_RESTRUCTURE:
bw.vec(b.scale if len(b.scale) == 3 else (1.0, 1.0, 1.0))
items.append(("BONES", len(sk.bones), bw.get()))
if sk.sockets:
sw = _W()
if version >= V_ATTR_RESTRUCTURE:
sw.i32(len(sk.sockets))
for s in sk.sockets:
sw.fstr(s.name)
sw.fstr(s.bone)
sw.vec(s.pos)
sw.vec(s.rot)
sw.vec(s.scale)
items.append(("SOCKETS", len(sk.sockets), sw.get()))
if sk.virtual_bones:
vw = _W()
if version >= V_ATTR_RESTRUCTURE:
vw.i32(len(sk.virtual_bones))
for t in sk.virtual_bones:
vw.fstr(t[0])
vw.fstr(t[1])
vw.fstr(t[2])
items.append(("VIRTUALBONES", len(sk.virtual_bones), vw.get()))
return _pack_attrset(items, version)
def _pack_collision(col, version):
w = _W()
w.fstr(col.name)
w.i32(len(col.vertices))
for v in col.vertices:
w.vec(v)
w.i32(len(col.indices))
for i in col.indices:
w.i32(i)
return w.get()
def build_uemodel_bytes(m, version=None):
"""把 UEModel 序列化成字节。version=None 用 m.version。"""
ver = _repair_version(int(version if version else m.version))
w = _W()
w.raw(MAGIC)
w.fstr(m.identifier or IDENT_MODEL)
w.u8(ver)
w.fstr(m.name)
if ver >= V_ATTR_RESTRUCTURE:
w.fstr(m.path or "")
w.bool(False)
items = []
lw = _W()
if ver >= V_ATTR_RESTRUCTURE:
lw.i32(len(m.lods))
for lod in m.lods:
lw.raw(_pack_lod(lod, ver))
items.append(("LODS", len(m.lods), lw.get()))
items.append(("SKELETON", 1, _pack_skeleton(m.skeleton, ver)))
if m.collisions:
cw = _W()
if ver >= V_ATTR_RESTRUCTURE:
cw.i32(len(m.collisions))
for col in m.collisions:
cw.raw(_pack_collision(col, ver))
items.append(("COLLISION", len(m.collisions), cw.get()))
w.raw(_pack_attrset(items, ver))
return w.get()
def write_uemodel(m, path, version=None):
data = build_uemodel_bytes(m, version=version)
tmp = path + ".tmp"
with open(tmp, "wb") as f:
f.write(data)
os.replace(tmp, path)
return len(data)
# ----------------------------------------------------------------- 文本输出 --
def print_uemodel(m, src=""):
if src:
print("文件:%s" % src)
print("UEFormat v%d · %s · 名称 %s" % (m.version, m.identifier, m.name))
if m.path:
print(" 资源路径:%s" % m.path)
sk = m.skeleton
print(" 骨骼 %d · 插槽 %d · 虚拟骨 %d · 碰撞 %d"
% (len(sk.bones), len(sk.sockets), len(sk.virtual_bones),
len(m.collisions)))
if sk.path:
print(" 骨骼资源:%s" % sk.path)
for i, lod in enumerate(m.lods):
st = lod.stats()
print(" LOD[%d] %-8s 顶点 %d · 三角面 %d · 材质 %d · 权重 %d · 表情 %d · UV %d"
% (i, lod.name, st["verts"], st["tris"], st["mats"],
st["weights"], st["morphs"], st["uvsets"]))
for mt in lod.materials[:40]:
print(" 材质 %-42s 面 %6d 起 %d"
% (mt.name[:42], mt.num_faces, mt.first_index))
if len(lod.materials) > 40:
print(" …另有 %d 个材质" % (len(lod.materials) - 40))
for mo in lod.morphs[:40]:
print(" 表情 %-30s 顶点 %d" % (mo.name[:30], len(mo.deltas)))
if len(lod.morphs) > 40:
print(" …另有 %d 个表情" % (len(lod.morphs) - 40))
if sk.bones:
print(" 前 12 根骨骼:")
for b in sk.bones[:12]:
print(" %-28s parent=%-4d pos=(%.3f, %.3f, %.3f)"
% (b.name[:28], b.parent, b.pos[0], b.pos[1], b.pos[2]))
def main(argv=None):
argv = list(sys.argv[1:] if argv is None else argv)
if not argv:
print("用法:python formats/uemodelio.py <model.uemodel> [--roundtrip]")
return 1
path = argv[0]
m = read_uemodel(path, verbose=True)
if "--roundtrip" in argv:
for ver in (9, 10):
tmp = os.path.join(os.path.dirname(os.path.abspath(path)), "_rt_v%d.uemodel" % ver)
write_uemodel(m, tmp, version=ver)
back = read_uemodel(tmp)
ok = (len(back.lods) == len(m.lods)
and back.skeleton.bones and len(back.skeleton.bones) == len(m.skeleton.bones))
print("往返 v%d:%d 字节 → %s" % (ver, os.path.getsize(tmp),
"一致" if ok else "不一致"))
os.remove(tmp)
return 0
if __name__ == "__main__":
sys.exit(main())