初始化 VRMify 增强版(VRMify Enhanced)
Tests / test (push) Has been cancelled

导入上游源码,为所有面向用户的品牌显示处添加「增强版 / Enhanced」标识;包含 unitypackage→VRM 的纯色 Toon 材质、兽耳 SpringBone、Unity 描边、UV 接缝白边补偿修复,以及默认不强制 T-pose。146 个单元测试通过。
This commit is contained in:
2026-11-15 23:21:59 +08:00
commit 60cce66993
114 changed files with 56114 additions and 0 deletions
+873
View File
@@ -0,0 +1,873 @@
# -*- 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())