初始化 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
+633
View File
@@ -0,0 +1,633 @@
# -*- coding: utf-8 -*-
"""材质:PMX 材质 → glTF 材质 + MToon(1.0 的 VRMC_materials_mtoon / 0.x 的 materialProperties)。
颜色按 MMD 的显示公式算,阴影色和明暗交界按 PMX 的 toon 渐变换算,VRM 1.0 的颜色因子写线性值;
透明模式看漫反射 alpha、贴图的 alpha 分布(只算材质的 UV 用到的部分)和材质表情。
"""
import io
import math
import os
import vrmio
ALPHA_GRID = 1024 # 统计 UV 覆盖区域的透明度时,贴图 alpha 缩到的最长边(像素)
def _alpha_grid(data):
"""贴图字节 → 缩小的 alpha 通道(Pillow 灰度图;最近邻缩小,不造出假的中间值)。
没有 alpha、没装 Pillow 或解不开时为 None。"""
try:
from PIL import Image
im = Image.open(io.BytesIO(data))
if im.mode in ("RGBA", "LA", "PA"):
a = im.getchannel("A")
elif im.mode == "P" and "transparency" in im.info:
a = im.convert("RGBA").getchannel("A")
else:
return None
k = ALPHA_GRID / max(a.size)
if k < 1:
a = a.resize((max(1, round(a.width * k)), max(1, round(a.height * k))), Image.NEAREST)
return a
except Exception: # noqa: BLE001 解不开就按整张图的统计
return None
def _lin(c):
"""sRGB(gamma)分量 → 线性分量。
MMD 在 gamma 空间里算颜色(材质色、toon 贴图都是 sRGB 值,直接相乘);glTF 的
baseColorFactor 和 VRM 1.0 MToon 的各个颜色因子规定是线性值,引擎会按线性来乘
贴图。以前把 gamma 值原样写进去:阴影色 0.8 实际显示成 sRGB 0.9,只暗 10%,
在游戏的环境光下基本看不见(原生 VRoid 皮肤的阴影色 0.x 写 (0.97, 0.81, 0.86),
读进来是线性 (0.93, 0.63, 0.72))。gamma 空间的乘法 a·b 对应线性的 lin(a)·lin(b),
所以换算后效果和 MMD 一致。VRM 0.x 的 materialProperties 本来就是 gamma 值,不用转。
"""
c = max(0.0, min(1.0, c))
return c / 12.92 if c <= 0.04045 else ((c + 0.055) / 1.055) ** 2.4
def _lin_rgb(rgb):
"""颜色列表的 RGB 分量转线性,第 4 个(alpha)原样保留。"""
return [round(_lin(v), 5) if i < 3 else v for i, v in enumerate(rgb)]
def _mmd_color(diffuse, ambient):
"""MMD 实际显示的材质颜色(RGBA)。
MMD 默认着色器:颜色 = saturate(漫反射 × 光源色 + 环境色),光源色默认
154/255 ≈ 0.6;alpha 取漫反射 alpha。常见的「漫反射 1、环境色 0.5」算出来
就是白色,但有的材质靠环境色调色(比如脸红:漫反射白、环境色偏红),
只用漫反射会把颜色丢掉。
"""
return [min(1.0, max(0.0, diffuse[k] * 0.6 + ambient[k]))
for k in range(3)] + [diffuse[3]]
# MMD 共享 toon(toon01~toon06.bmp)的渐变:上半白、v=0.5 处硬切到下半的颜色。
# 取自 three.js MMDLoader 内嵌的 DEFAULT_TOON_TEXTURES;它的 toon07~10 是全白的
# 占位图,不可信,这几张当作「不知道」走默认阴影
_SHARED_TOON = {
0: ((255, 255, 255), (205, 205, 205)),
1: ((255, 255, 255), (245, 225, 225)),
2: ((255, 255, 255), (154, 154, 154)),
3: ((255, 255, 255), (248, 239, 235)),
4: ((255, 255, 255), (254, 232, 223)),
5: ((255, 237, 97), (195, 172, 3)),
}
def _toon_column(rows, w, h):
"""toon 贴图 → 从上(v=0,正对光)到下(v=1,背光 / 自阴影)的平均颜色(0~1)。"""
xs = sorted({0, w // 4, w // 2, (3 * w) // 4, w - 1})
return [tuple(sum(rows[y][x][k] for x in xs) / (255.0 * len(xs)) for k in range(3))
for y in range(h)]
def _toon_shading(col):
"""MMD toon 渐变 → MToon 1.0 的 (亮部色, 阴影色, shadingShift, shadingToony)。
MMD:颜色 ×= toon(v),v = 0.5 − 0.5·N·L;自阴影(投影)里取最下端 toon(1)。
MToon 1.0:shading = linearstep(−1+toony, 1−toony, N·L + shift) × 投影,
颜色 = lerp(阴影色, 亮部色, shading)。所以
亮部色 = toon 最上端,阴影色 = 最下端(投影里正好也是它),
明暗交界在亮度降到一半的 v_mid 处:N·L = 1 − 2·v_mid → shift = 2·v_mid − 1,
过渡宽度 Δv(亮度 10%→90%)对应 N·L 的 2·Δv → toony = 1 − Δv。
星铁 / 鸣潮的皮肤 toon 在 v≈0.75 以后才变暗,换算出来 shift≈+0.6:脸上基本全亮、
只有投影是粉色——和原生 VRoid 皮肤(0.x ShadeShift −1 / Toony 1)的效果一致。
渐变几乎没有明暗差(纯白 toon)时阴影色 = 亮部色:MMD 里这种材质本来就没有阴影。
"""
if not col:
return None
lum = [0.299 * c[0] + 0.587 * c[1] + 0.114 * c[2] for c in col]
top, bot = lum[0], lum[-1]
if top - bot < 0.02:
return col[0], col[0], 0.0, 0.9
n = len(col)
def first_below(level):
for i, v in enumerate(lum):
if v <= level:
return i / max(1, n - 1)
return 1.0
v_mid = first_below(top - 0.5 * (top - bot))
dv = first_below(top - 0.9 * (top - bot)) - first_below(top - 0.1 * (top - bot))
shift = max(-1.0, min(1.0, 2.0 * v_mid - 1.0))
toony = max(0.0, min(1.0, 1.0 - dv))
return col[0], col[-1], shift, toony
def one_sided_layers(model, samples=300, inward_min=0.7, opposite_min=0.5):
"""PMX 里设计成单面、背后紧贴着一层反向表面的材质 → {材质序号: (朝里的比例, 法线相反的比例)}。
两类:描边外壳(把脸 / 身体复制一份往外推、翻面、涂黑:单面时只在边缘露出一圈当轮廓线,叫
「顔エッジ」「outline」之类)和内侧面(裙子、袖子里面另做一层翻过来的面显示里侧的贴图)。
「所有材质双面」不能套到它们上:外壳会整片盖住脸和身体,内侧面会和外层重叠闪烁。
名字靠不住,按几何判断,每个单面材质抽样最多 samples 个三角面:
朝里 面的朝向(PMX 绕序的叉积)指向它所属骨骼那一段(主要权重的骨,骨头 → 骨尾)
反向 离它最近的别的材质的顶点(模型高度的 3% 以内),顶点法线和这个面相反——外壳和它下面的表面、
内侧面和外层都是这样;眼睛、嘴里朝里的面旁边是方向一致的眼白、牙齿,不算
两项都过半(朝里 ≥ inward_min,反向 ≥ opposite_min,有效样本至少 20 个)的才算。
"""
V, F, B = model["vertices"], model["faces"], model["bones"]
mats = model["materials"]
if not V or not B or not any(m["faces"] >= 3 and not (m["flag"] & 0x01) for m in mats):
return {}
ys = [v["pos"][1] for v in V]
h = (max(ys) - min(ys)) or 1.0
r, eps = 0.03 * h, 0.0003 * h
tails = []
for b in B:
t = b.get("tail")
if b.get("tail_kind") == 1 and isinstance(t, int) and 0 <= t < len(B):
tails.append(B[t]["pos"])
elif b.get("tail_kind") == 0 and t and not isinstance(t, int):
tails.append(tuple(b["pos"][i] + t[i] for i in range(3)))
else:
tails.append(b["pos"])
mat_of = [0] * len(V)
k = 0
for mi, m in enumerate(mats):
for t in range(k, min(k + m["faces"], len(F))):
mat_of[F[t]] = mi
k += m["faces"]
cell = r / 4 # 细网格,由近到远一圈圈找:外壳离下面的表面通常只有零点几毫米
grid = {}
for vi, v in enumerate(V):
p = v["pos"]
grid.setdefault((int(p[0] // cell), int(p[1] // cell), int(p[2] // cell)), []).append(vi)
def nearest_other(p, mi):
cx, cy, cz = int(p[0] // cell), int(p[1] // cell), int(p[2] // cell)
best, bd = -1, r
for ring in range(5): # 第 ring 圈:切比雪夫距离正好是 ring 的格子
if best >= 0 and bd <= (ring - 1) * cell:
break
rng = range(-ring, ring + 1)
for dx in rng:
for dy in rng:
for dz in rng:
if max(abs(dx), abs(dy), abs(dz)) != ring:
continue
for vi in grid.get((cx + dx, cy + dy, cz + dz), ()):
if mat_of[vi] != mi:
q = V[vi]["pos"]
dd = math.sqrt((p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2 + (p[2] - q[2]) ** 2)
if eps < dd < bd:
best, bd = vi, dd
return best
def bone_of(v):
ws = list(v["wweights"]) or [1.0]
bi = max(zip(ws, v["wbones"]))[1] if v["wbones"] else -1
return bi if 0 <= bi < len(B) else -1
out, k = {}, 0
for mi, m in enumerate(mats):
n = m["faces"] // 3
start, k = k, k + m["faces"]
if n < 1 or m["flag"] & 0x01:
continue
step = max(1, n // samples)
tot, inward = 0, [] # 先只算朝里(便宜),不够的材质不用找邻居
for t in range(start, start + n * 3, 3 * step):
if t + 2 >= len(F):
break
a, b_, c = (V[F[t + j]]["pos"] for j in range(3))
u = (b_[0] - a[0], b_[1] - a[1], b_[2] - a[2])
w = (c[0] - a[0], c[1] - a[1], c[2] - a[2])
fn = (u[1] * w[2] - u[2] * w[1], u[2] * w[0] - u[0] * w[2], u[0] * w[1] - u[1] * w[0])
ln = math.sqrt(fn[0] ** 2 + fn[1] ** 2 + fn[2] ** 2)
bi = bone_of(V[F[t]])
if ln < 1e-12 or bi < 0:
continue
p = ((a[0] + b_[0] + c[0]) / 3, (a[1] + b_[1] + c[1]) / 3, (a[2] + b_[2] + c[2]) / 3)
s0, s1 = B[bi]["pos"], tails[bi] # 骨头 → 骨尾上离 p 最近的点
ab = (s1[0] - s0[0], s1[1] - s0[1], s1[2] - s0[2])
ll = ab[0] ** 2 + ab[1] ** 2 + ab[2] ** 2
f = 0.0 if ll < 1e-12 else max(0.0, min(1.0, sum((p[i] - s0[i]) * ab[i] for i in range(3)) / ll))
d = tuple(p[i] - s0[i] - ab[i] * f for i in range(3))
if math.sqrt(d[0] ** 2 + d[1] ** 2 + d[2] ** 2) < eps:
continue
tot += 1
if fn[0] * d[0] + fn[1] * d[1] + fn[2] * d[2] < 0:
inward.append((p, fn, ln))
if tot < 20 or len(inward) < inward_min * tot:
continue
opposite = 0
for p, fn, ln in inward:
q = nearest_other(p, mi)
if q >= 0:
nq = V[q]["normal"]
lq = math.sqrt(nq[0] ** 2 + nq[1] ** 2 + nq[2] ** 2) or 1.0
if (fn[0] * nq[0] + fn[1] * nq[1] + fn[2] * nq[2]) / (ln * lq) < -0.5:
opposite += 1
if opposite >= opposite_min * tot:
break
if opposite >= opposite_min * tot:
out[mi] = (len(inward) / tot, opposite / tot)
return out
def _morph_material(mat, ops, mi):
"""把材质表情作用到材质 mi 上,返回权重为 1 时的 (漫反射 RGBA, 环境色 RGB)。
PMX 材质表情:运算 0 = 乘算(基础 × 值),1 = 加算(基础 + 值);
28 个值里 [0:4] 是漫反射 RGBA、[8:11] 是环境色。グループ里的比率按
「基础 → 目标」线性插值(VRM 的 materialColorBinds 也是按权重插值)。
没有作用到这个材质返回 None。
"""
dif = list(mat["diffuse"])
amb = list(mat["ambient"])
hit = False
for m, op, vals, rate in ops:
if m != mi and m != -1:
continue
hit = True
for cur, off, n in ((dif, 0, 4), (amb, 8, 3)):
for k in range(n):
v = vals[off + k]
tgt = cur[k] * v if op == 0 else cur[k] + v
cur[k] = min(1.0, max(0.0, cur[k] + (tgt - cur[k]) * rate))
return (dif, amb) if hit else None
class MaterialBuilder:
"""逐个 PMX 材质生成 glTF 材质,贴图写进 gb(vrmio.GLBBuilder)。
flat:_flatten_morphs 的结果——会把材质隐藏掉的材质表情决定该材质用 MASK。
结果在 self.materials(glTF materials)和 self.props_0x(0.x 的 materialProperties)。
"""
def __init__(self, model, base_dir, gb, is1, flat, outline=False, force_double_sided=False,
tex_opt=None, known_alpha=None):
self.model = model
self.tex_opt = tex_opt # textures.Optimizer:嵌入前缩小 / 转 JPEG(None = 原样)
# {贴图文件的 normcase 绝对路径: png_alpha_stats 结果}:调用方已经统计过的(FBX 转换时解过)
self.known_alpha = known_alpha or {}
self._pre = {} # prefetch 提前读好的贴图:PMX 贴图序号 → _load 的结果
self.base_dir = base_dir
self.finder = vrmio.TextureFinder(base_dir)
self.tex_moved, self.tex_missing, self.tex_bad = set(), set(), set() # 贴图路径:日志里汇报
self.gb = gb
self.is1 = is1
self.outline = outline
self.force_double_sided = force_double_sided
# 「所有材质双面」时仍保持单面的:描边外壳、内侧面(one_sided_layers)
self.keep_one_sided = one_sided_layers(model) if force_double_sided else {}
self.materials = []
self.props_0x = []
self.img_cache = {}
self.tex_alpha = {} # PMX 贴图 → png_alpha_stats 结果
self.tex_grid = {} # PMX 贴图 → _alpha_grid(只有整张图里有透明像素的贴图)
self.alpha_by_uv = 0 # 按 UV 覆盖区域统计后不再算透明的材质数
self.toon_cache = {}
self.blend_rank = 0
self.sph_skipped = 0
self.morph_min_alpha = {} # PMX 材质 → 材质表情能把 alpha 压到多低
self.morph_max_alpha = {} # PMX 材质 → 材质表情能把 alpha 抬到多高
self.face_start = [] # PMX 材质 → 它的第一个面在 model["faces"] 里的位置
k = 0
for mat in model["materials"]:
self.face_start.append(k)
k += mat["faces"]
for f in flat:
ops = f[2]
for mi_, mat in enumerate(model["materials"]):
r = _morph_material(mat, ops, mi_)
if r is not None:
self.morph_min_alpha[mi_] = min(self.morph_min_alpha.get(mi_, 1.0), r[0][3])
self.morph_max_alpha[mi_] = max(self.morph_max_alpha.get(mi_, 0.0), r[0][3])
def _find(self, idx):
"""PMX 贴图序号 → 磁盘上的文件路径(找不到为 None;查找规则见 vrmio.TextureFinder)。"""
return self.finder.find(self.model["textures"][idx])[0]
def _load(self, idx):
"""PMX 贴图序号 → (原图数据, mime, 透明统计, 瘦身后的 (数据, mime), 缩小的 alpha),读不了为 None。
不改动 self 的状态,可以在线程里跑(见 prefetch)。"""
c = self._find(idx)
data, mime = vrmio.load_texture(c) if c else (None, None)
if not data:
return None
# 透明度统计用原图(瘦身后可能已是 JPEG);只有完全不透明的贴图才会转 JPEG,结论不变
key = os.path.normcase(os.path.abspath(c))
alpha = self.known_alpha[key] if key in self.known_alpha else vrmio.png_alpha_stats(data)
grid = _alpha_grid(data) if alpha and alpha[0] and alpha[1] >= alpha[0] * 0.001 else None
slim = self.tex_opt.process(data, mime) if self.tex_opt is not None else (data, mime)
return data, mime, alpha, slim, grid
def prefetch(self, threads=1):
"""材质要用的贴图先一起读好(读文件、透明统计、瘦身):Pillow 解码 / 编码在 C 里跑、不占 GIL,
几张图可以同时处理。结果留给 resolve_tex,贴图写进 GLB 的顺序不变。"""
textures = self.model["textures"]
want = []
for mat in self.model["materials"]:
if mat["faces"] < 3: # 没有三角面的材质不会生成(见 mesh.build_primitives)
continue
for idx in (mat["tex"], mat["sph"] if mat["sph_mode"] == 2 else -1):
if 0 <= idx < len(textures) and idx not in want:
want.append(idx)
if threads < 2 or len(want) < 2:
return
from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor(min(threads, len(want))) as ex:
self._pre.update(zip(want, ex.map(self._load, want)))
def resolve_tex(self, idx):
"""PMX 贴图序号 → glTF texture 序号(-1 = 没有 / 读不了)。"""
if idx is None or idx < 0 or idx >= len(self.model["textures"]):
return -1
if idx in self.img_cache:
return self.img_cache[idx]
got = self._pre.pop(idx) if idx in self._pre else self._load(idx)
rel = self.model["textures"][idx]
path, how = self.finder.find(rel)
if path is None:
self.tex_missing.add(rel)
elif got is None:
self.tex_bad.add(rel)
elif how == "moved":
self.tex_moved.add(rel)
if got is None:
self.img_cache[idx] = -1
return -1
data, mime, self.tex_alpha[idx], slim, grid = got
if grid is not None:
self.tex_grid[idx] = grid
if self.tex_opt is not None:
data, mime = self.tex_opt.account(data, slim)
ti = self.gb.add_texture(self.gb.add_image(data, mime))
self.img_cache[idx] = ti
return ti
def toon_params(self, mat):
"""材质的 toon 渐变 → (亮部色, 阴影色, shift, toony)(见 _toon_shading);
没有 toon、共享 toon07~10、贴图找不到或解不了时返回 None(走默认阴影)。"""
if mat["toon_flag"]:
key = ("shared", mat["toon"])
elif 0 <= mat["toon"] < len(self.model["textures"]):
key = ("tex", mat["toon"])
else:
return None
if key not in self.toon_cache:
r = None
if key[0] == "shared":
st = _SHARED_TOON.get(key[1])
if st:
t, b = [tuple(c / 255.0 for c in x) for x in st]
r = _toon_shading([t] * 16 + [b] * 16)
else:
path = self._find(key[1])
if path:
with open(path, "rb") as f:
img = vrmio.decode_rgba(f.read())
if img:
r = _toon_shading(_toon_column(img[2], img[0], img[1]))
self.toon_cache[key] = r
return self.toon_cache[key]
def lit_shade(self, mat, color):
"""MMD 显示色(_mmd_color)→ MToon 的 (亮部 RGBA, 阴影 RGB, shift, toony)。"""
tp = self.toon_params(mat)
if tp is None:
# 没有可用的 toon:实际几乎都是眼睛、高光、眉睫、嘴、表情贴片。按二次元的
# 惯例(原生 VRoid 的眼睛、眉毛阴影色都是白)不画阴影,不然一进投影眼睛就发黑
return list(color), list(color[:3]), 0.0, 0.9
lit, dark, shift, toony = tp
return ([color[k] * lit[k] for k in range(3)] + [color[3]],
[color[k] * dark[k] for k in range(3)], shift, toony)
def used_alpha(self, mi_, mat):
"""材质贴图的透明统计(同 png_alpha_stats),只算这个材质的 UV 覆盖到的部分。
有的模型几个部件共用一张大图集,或者贴图右边还拼着用不到的半透明图层(同一张图
u 0~1/3 是颜色,后面是别的通道):按整张图统计,不透明的身体、衣服也被当成半透明,
BLEND 的排序问题让部件在转动视角时消失、前后遮挡错乱。三角面按 UV 画到缩小的
alpha 图上,只统计盖住的像素。整张图没有透明像素的贴图不用算。"""
whole = self.tex_alpha.get(mat["tex"])
grid = self.tex_grid.get(mat["tex"])
if grid is None or mat["faces"] < 3:
return whole
from PIL import Image, ImageDraw
w, h = grid.size
mask = Image.new("L", (w, h), 0)
draw = ImageDraw.Draw(mask)
verts, faces = self.model["vertices"], self.model["faces"]
s = self.face_start[mi_]
for t in range(s, s + mat["faces"] - 2, 3):
uv = [verts[faces[t + k]]["uv"] for k in range(3)]
# 平铺(repeat):整个三角形移到最小角所在的那一格
ou, ov = math.floor(min(p[0] for p in uv)), math.floor(min(p[1] for p in uv))
draw.polygon([((u - ou) * w, (v - ov) * h) for u, v in uv], fill=255)
hist = grid.histogram(mask=mask)
st = (sum(hist), sum(hist[:250]), sum(hist[11:245]))
# UV 全落在完全透明的地方:靠 UV 表情挪过去才显示的贴片(表情符号)、靠材质表情显示的部件,
# 初始 UV 说明不了什么,按整张图
return st if st[0] - st[1] + st[2] > 0 else whole
@staticmethod
def _see_through(st):
return bool(st and st[0] and st[1] >= st[0] * 0.001)
def alpha_mode(self, mi_, mat):
"""OPAQUE / MASK / BLEND。
以前只看漫反射 alpha,贴图自带透明通道(头发高光层、瞳孔、
镂空裙摆)的材质全被写成 OPAQUE,透明区域画成实心——
实测头发被一层黑色盖住、眼睛一片黑。现在还看贴图的 alpha 分布:
* 半透明像素占可见像素的比例低(只有抗锯齿边缘)→ MASK(裁剪,
不需要排序,Unity 里最稳)
* 比例高(柔和的叠加层、薄纱)→ BLEND
材质表情会把它隐藏(alpha → 0)的不透明材质用 MASK,才能真的隐藏。
"""
st = self.used_alpha(mi_, mat)
if self._see_through(self.tex_alpha.get(mat["tex"])) and not self._see_through(st):
self.alpha_by_uv += 1
if mat["diffuse"][3] <= 0.001 and self.morph_max_alpha.get(mi_, 0.0) > 0.5:
# 默认隐藏、靠材质表情显示的部件(FBX 的替换网格:另一种手势 / 张嘴的头):
# 用 MASK,显示出来时就是普通的不透明材质,不用 BLEND 的排序
if self._see_through(st) and st[2] >= (st[0] - st[1] + st[2]) * 0.3:
return "BLEND"
return "MASK"
if mat["diffuse"][3] < 0.999:
return "BLEND"
if self._see_through(st):
n, trans, mid = st
visible = n - trans + mid
if visible <= 0 or mid >= visible * 0.3:
return "BLEND"
return "MASK"
if self.morph_min_alpha.get(mi_, 1.0) < 0.5:
return "MASK"
return "OPAQUE"
def make(self, mi_, mat):
"""生成一个 glTF 材质,返回它在 self.materials 里的序号。"""
ti = self.resolve_tex(mat["tex"])
# 亮部 / 阴影色和明暗交界按 PMX 的 toon 渐变换算(MMD 的暗部和自阴影都取
# toon 最下端的颜色)。以前一律「阴影 = 亮部 × 0.8」:灰色的阴影叠在浅色皮肤上
# 几乎看不出来,星铁、鸣潮的脸又白又平;原生 VRoid 皮肤的阴影是粉色的
diff, shade, shift, toony = self.lit_shade(mat, _mmd_color(mat["diffuse"], mat["ambient"]))
mode = self.alpha_mode(mi_, mat)
double = bool(mat["flag"] & 0x01) or (self.force_double_sided and mi_ not in self.keep_one_sided)
# 加算球面贴图(sph_mode 2)≈ MToon 的 matcap(同样是加算);
# 乘算(1)没有对应项,跳过
si = -1
if mat["sph_mode"] == 2:
si = self.resolve_tex(mat["sph"])
elif mat["sph_mode"] == 1 and 0 <= mat["sph"] < len(self.model["textures"]):
self.sph_skipped += 1
rq = 0
if mode == "BLEND": # 半透明按 PMX 材质顺序排绘制顺序
rq = min(9, self.blend_rank)
self.blend_rank += 1
edge = self.outline and bool(mat["flag"] & 0x10) and mat["edge_size"] > 0
# 材质名在模型内唯一:有的程序按材质名找材质,
# PMX 允许重名,重名时只会找到第一个
name = mat["name"] or ("mat%d" % mi_)
used = {m["name"] for m in self.materials}
k = 2
while name in used:
name = "%s_%d" % (mat["name"] or ("mat%d" % mi_), k)
k += 1
gmat = {
"name": name,
"pbrMetallicRoughness": {
"baseColorFactor": _lin_rgb(diff),
"metallicFactor": 0.0,
"roughnessFactor": 0.9,
},
"doubleSided": double,
"emissiveFactor": [0.0, 0.0, 0.0],
"alphaMode": mode,
}
if mode == "MASK":
gmat["alphaCutoff"] = 0.5
if ti >= 0:
gmat["pbrMetallicRoughness"]["baseColorTexture"] = {"index": ti}
if self.is1:
mt = {
"specVersion": "1.0",
"transparentWithZWrite": False,
"renderQueueOffsetNumber": rq,
"shadeColorFactor": _lin_rgb(shade),
"shadingShiftFactor": round(shift, 4),
"shadingToonyFactor": round(toony, 4),
"giEqualizationFactor": 0.9,
"matcapFactor": [1.0, 1.0, 1.0] if si >= 0 else [0.0, 0.0, 0.0],
"parametricRimColorFactor": [0.0, 0.0, 0.0],
"parametricRimFresnelPowerFactor": 5.0,
"parametricRimLiftFactor": 0.0,
"rimLightingMixFactor": 1.0,
"outlineWidthMode": "worldCoordinates" if edge else "none",
"outlineWidthFactor": (mat["edge_size"] * 0.001) if edge else 0.0,
"outlineColorFactor": _lin_rgb(mat["edge_color"][:3]),
"outlineLightingMixFactor": 1.0,
}
if ti >= 0:
mt["shadeMultiplyTexture"] = {"index": ti}
if si >= 0:
mt["matcapTexture"] = {"index": si}
gmat["extensions"] = {"VRMC_materials_mtoon": mt}
else:
blend = mode == "BLEND"
mask = mode == "MASK"
tex_props = {}
if ti >= 0:
tex_props["_MainTex"] = ti
tex_props["_ShadeTexture"] = ti # 以前没写,暗部只剩一块纯色
if si >= 0:
tex_props["_SphereAdd"] = si
self.props_0x.append({
"name": gmat["name"],
"shader": "VRM/MToon",
"renderQueue": (3000 + rq) if blend else (2450 if mask else 2000),
"floatProperties": {
"_Cutoff": 0.5, "_BumpScale": 1.0,
# 0.x:smoothstep(shift, shift + 1 − toony, N·L),换算成同样的交界和宽度
"_ReceiveShadowRate": 1.0,
"_ShadeShift": round(max(-1.0, min(1.0, -shift - (1.0 - toony))), 4),
"_ShadeToony": round(max(0.0, 2.0 * toony - 1.0), 4),
"_LightColorAttenuation": 0.0,
"_IndirectLightIntensity": 0.1, "_RimLightingMix": 0.0,
"_RimFresnelPower": 1.0, "_RimLift": 0.0,
# 0.x 世界坐标模式的线宽单位是厘米
"_OutlineWidth": (mat["edge_size"] * 0.1) if edge else 0.0,
"_OutlineScaledMaxDistance": 1.0,
"_OutlineLightingMix": 1.0, "_UvAnimScrollX": 0.0,
"_UvAnimScrollY": 0.0, "_UvAnimRotation": 0.0,
"_MToonVersion": 38.0, "_DebugMode": 0.0,
"_BlendMode": 2.0 if blend else (1.0 if mask else 0.0),
"_OutlineWidthMode": 1.0 if edge else 0.0,
"_OutlineColorMode": 0.0,
# Unity CullMode:0 Off / 1 Front / 2 Back。以前单面写成 1,
# 剔除的是正面
"_CullMode": 0.0 if double else 2.0,
"_OutlineCullMode": 1.0,
# 半透明:SrcAlpha / OneMinusSrcAlpha、不写深度。
# 以前透明材质也写 1/0/ZWrite=1,等于不透明
"_SrcBlend": 5.0 if blend else 1.0,
"_DstBlend": 10.0 if blend else 0.0,
"_ZWrite": 0.0 if blend else 1.0,
"_AlphaToMask": 0.0,
},
"vectorProperties": {
"_Color": [diff[0], diff[1], diff[2], diff[3]],
"_ShadeColor": shade + [1.0],
"_EmissionColor": [0.0, 0.0, 0.0, 1.0],
"_OutlineColor": list(mat["edge_color"][:3]) + [1.0],
"_RimColor": [0.0, 0.0, 0.0, 1.0],
},
"textureProperties": tex_props,
"keywordMap": {"_NORMALMAP": False, "_ALPHATEST_ON": mask,
"_ALPHABLEND_ON": blend,
"_ALPHAPREMULTIPLY_ON": False,
"MTOON_OUTLINE_WIDTH_WORLD": edge,
"MTOON_OUTLINE_COLOR_FIXED": edge},
"tagMap": {"RenderType": ("Transparent" if blend else
"TransparentCutout" if mask
else "Opaque")},
})
self.materials.append(gmat)
return len(self.materials) - 1
def log_summary(self, log):
modes = [m["alphaMode"] for m in self.materials]
log("材质透明模式:不透明 %d · 裁剪(MASK)%d · 半透明(BLEND)%d"
% (modes.count("OPAQUE"), modes.count("MASK"), modes.count("BLEND")))
if self.alpha_by_uv:
log("材质:%d 个材质的贴图有透明部分,但模型只用到不透明的区域,按不透明处理" % self.alpha_by_uv)
if self.is1:
nmc = sum(1 for m in self.materials if "matcapTexture" in
m["extensions"]["VRMC_materials_mtoon"])
else:
nmc = sum(1 for p in self.props_0x if "_SphereAdd" in p["textureProperties"])
if nmc:
log("材质:%d 个加算球面贴图转为 MToon 的 matcap" % nmc)
if self.tex_opt is not None:
if not self.tex_opt.active and (self.tex_opt.max_size or self.tex_opt.jpeg):
log("贴图:未安装 Pillow,缩小贴图和 JPEG 存储未生效", "warn")
elif self.tex_opt.summary():
log(self.tex_opt.summary())
if self.sph_skipped:
log("材质:%d 个材质的乘算球面贴图(.sph)在 MToon 中没有对应项,已忽略"
% self.sph_skipped, "warn")
if self.keep_one_sided:
names = [self.model["materials"][i]["name"] for i in sorted(self.keep_one_sided)]
log("材质:%d 个材质是描边外壳或内侧面(%s),「所有材质双面」时仍保持单面,否则会盖住模型或重叠闪烁"
% (len(names), "、".join(names[:6]) + ("…" if len(names) > 6 else "")))
def names(rels):
rels = sorted(rels)
return "、".join(r.replace("\\", "/").rsplit("/", 1)[-1] for r in rels[:6]) + ("…" if len(rels) > 6 else "")
if self.tex_moved:
log("贴图:%d 张不在模型记录的位置,已按文件名在模型文件夹里找到(%s)" % (len(self.tex_moved), names(self.tex_moved)))
if self.tex_missing:
log("贴图:%d 张找不到(%s),用到它们的材质只有底色。贴图要和模型放在一起:请加入整个文件夹或压缩包"
% (len(self.tex_missing), names(self.tex_missing)), "warn")
if self.tex_bad:
log("贴图:%d 张读取失败(%s),用到它们的材质只有底色" % (len(self.tex_bad), names(self.tex_bad)), "warn")