backend: 交付网站后端 + 本地自助管理后台 + 测试工程(已脱敏)

Browse Source
范围由店主圈定:网页后端 / 自助后端、本地的自助管理后台、
用于测试的 Blender 工程、以及部署层的反代片段。

出站纪律:所有指向真实环境的值(域名/端口/盘符路径/IP/账户名)已替换为占位;
代码里本来就没有硬编码凭据(令牌走文件与环境变量)。
Blender 工程因内嵌绝对路径,做了等长替换(文件字节数未变,结构完好)。

两份交接文档各含《我们的思路与方法》,并要求对方回:
问题分析 + 改正意见 + 他改了什么(含是否动到接口/字段/数据格式)。
This commit is contained in:
Suda
2026-10-05 18:52:33 +08:00
parent 1903daafc3
commit 1d67fda9d5
30 changed files with 8486 additions and 0 deletions
+651
View File
@@ -0,0 +1,651 @@
# -*- coding: utf-8 -*-
"""
商单渲染流程自动化(宿主 Windows 用)—— 跑起来 0 token
金钻 2026-09-19 原话:
「如果方便的话可以直接写个脚本,到时候如果不需要修改的话,直接按流程,
复制所需工程到商单文件夹往后补一个新的编号。皮肤也放进去。
然后根据皮肤粗细臂去选择对应集合,渲染出图」
一条命令完成:
1. 成品文件夹用成品名(`飞跃樱花林` / `飞跃樱花林1080`),重名自动加 -2
2. 新建成品文件夹;工程复制到**临时目录**(原文件不动,渲完就删)
3. 皮肤先放进成品文件夹
4. 自动判定皮肤是【粗臂 classic 4px】还是【细臂 slim 3px】
5. 按判定切换场景里的 粗臂 / 细臂 集合(view layer exclude)
6. 换皮肤贴图(pack 打包)
7. 渲染出图 → 017\\飞跃樱花林.png + 017\\飞跃樱花林无压缩版.png
(默认 1000 不带数字;换分辨率才带,如 飞跃樱花林1080.png。越高越慢)
8. 写 _CHANGES.md 与 _make_order.log
用法:
blender.exe -b --factory-startup --python make_order.py -- ^
--template "<ARCHIVE_DIR>" ^
--skin "<WIN-PATH>" ^
--orders-dir "<ARCHIVE_DIR>" ^
[--block-texture "<WIN-PATH>"] [--num 017] [--out-name 麦田萤火] ^
[--res 2048] [--out-dir "...\\商单\\麦田萤火"] [--keep-blend] ^
[--no-uncompressed] [--no-render] [--dry-run]
要点(踩过的坑,别改回去):
* 必须 `-b --factory-startup` —— 宿主 Blender 装了 MMD 系 addon,不 factory-startup
时会重复注册崩(ValueError: register_class(...): already registered)。
* 但 factory-startup 会丢掉用户的 Cycles GPU 偏好 → 掉回 CPU,**慢 10 倍**
(实测 1000×1000 / 180 samples:GPU 37.4s vs CPU 378.9s)。
所以脚本里 setup_render_device() 显式切 GPU,别删。
* 判臂型用 bpy.data.images 读 alpha,不依赖 PIL;注意 img.pixels 是 **bottom-up**,
取像素必须翻转 y。
* 渲染耗时长(CPU 下 6 分钟+),从我这边跑要走后台 + 轮询日志,别用前台 timeout。
* **工程文件不保留**(2026-09-30 金钻):一份 .blend 二十多兆,攒起来受不住。
工程复制到 tempfile.mkdtemp() 的临时目录,渲完立刻删;`--keep-blend` 只在调试时用。
成品文件夹里只有:皮肤 + 成图 + 订单信息.json。
* **臂集合名/层级各模板都不一样**(实测三种):1~4 顶层 `粗臂`/`细臂`;
5~6 嵌在 `Collection` 里叫 `Player Wide Rig`/`Player Slim Rig`;
7 顶层 `01_角色_粗臂`/`02_角色_细臂`。
→ find_layer() 递归整棵树 + 中英双认(WIDE_KEYS/SLIM_KEYS)。
写死任一种都会让模板 exit 5 渲不出来(5/6/7 全中过)。
* 皮肤 `img.pack()` 必须在改 filepath **之前** —— 工程现在在临时目录,
先改路径的话 pack 会拿相对路径去 <WIN-PATH> 找源文件,报 not found。
"""
import argparse
import atexit
import os
import re
import shutil
import sys
import tempfile
import time
import traceback
import bpy
LOGLINES = []
# ---- 成品命名(金钻 2026-09-30 定稿)----
# 默认分辨率 1000 → <模板名>.png + <模板名>无压缩版.png
# 其它分辨率 N → <模板名>N.png + <模板名>N无压缩版.png
# 例:飞跃樱花林 在 1000 → 飞跃樱花林.png / 飞跃樱花林无压缩版.png
# 飞跃樱花林 在 1080 → 飞跃樱花林1080.png / 飞跃樱花林1080无压缩版.png
DEFAULT_RES = 1000
UNC_SUFFIX = "无压缩"
def out_base(out_name, res):
"""模板名 + (非默认分辨率才带数字)"""
res = int(res)
return out_name if res == DEFAULT_RES else "%s%d" % (out_name, res)
def make_out_dir(root, base):
"""成品文件夹用成品名(金钻 2026-09-30):`飞跃樱花林` / `飞跃樱花林1080`。
同名已存在就往后加 -2 / -3 —— 同一个模板被买两次不能互相覆盖。
序号仍然记在文件夹里的 订单信息.json(好查账)。"""
d = os.path.join(root, base)
n = 2
while os.path.exists(d):
d = os.path.join(root, "%s-%d" % (base, n))
n += 1
os.makedirs(d, exist_ok=True)
return d
def std_name(out_name, res):
return out_base(out_name, res) + ".png"
def unc_name(out_name, res):
return out_base(out_name, res) + UNC_SUFFIX + ".png"
def log(*a):
s = " ".join(str(x) for x in a)
LOGLINES.append(s)
print("[MAKE-ORDER] " + s, flush=True)
def parse_args():
argv = sys.argv
if "--" in argv:
argv = argv[argv.index("--") + 1:]
else:
argv = []
ap = argparse.ArgumentParser()
ap.add_argument("--template", required=True, help="干净模板 .blend 绝对路径")
ap.add_argument("--skin", required=True, help="皮肤 png 绝对路径")
ap.add_argument("--orders-dir", required=True, help="商单根目录绝对路径")
ap.add_argument("--out-dir", default=None,
help="直接指定成品文件夹(调用方用来做重名处理;给了就不再用 --num)")
ap.add_argument("--keep-blend", action="store_true",
help="调试用:保留临时工程文件(默认渲完就删)")
ap.add_argument("--block-texture", default=None, help="可选:方块贴图 png")
ap.add_argument("--num", default=None, help="手动指定商单编号(3 位)")
ap.add_argument("--out-name", default=None, help="出图名,默认取模板名去编号前缀")
ap.add_argument("--res", type=int, default=DEFAULT_RES,
help="渲染分辨率。默认 1000(文件名不带数字);换别的值会写进文件名。"
"越高越慢:1000≈40s、2048≈2.5min、4096≈10min")
ap.add_argument("--skin-material", default=None, help="皮肤材质名(默认自动找)")
# 金钻 2026-10-01:页面让买家手动改粗/细臂,但以前**根本没传进来** —— 永远按自动判定走,
# 买家改了也白改。现在由渲染机按「这张皮肤」的臂型传进来(多皮肤单每张各自一个臂型)。
ap.add_argument("--arm", default="auto", choices=["auto", "classic", "slim"],
help="粗臂(classic)/细臂(slim);auto=按皮肤自动判定(默认)")
ap.add_argument("--uncompressed", action=argparse.BooleanOptionalAction, default=True,
help="输出 16bit 无压缩版(默认开;要关就 --no-uncompressed)")
ap.add_argument("--no-render", action="store_true")
ap.add_argument("--dry-run", action="store_true")
return ap.parse_args(argv)
# ---------------------------------------------------------------- 编号 / 目录
def next_order_number(orders_dir, forced=None):
if forced:
return forced
n = 0
for name in os.listdir(orders_dir):
m = re.fullmatch(r"(\d{3})", name)
if m and os.path.isdir(os.path.join(orders_dir, name)):
n = max(n, int(m.group(1)))
return "%03d" % (n + 1)
# ------------------------------------------------------- 皮肤臂型判定(核心)
def _px(img, x, y, w, h):
"""取 (x,y) alpha,y 从左上往下数;bpy pixels 是左下起 → 翻转 y。"""
yy = h - 1 - y
return img.pixels[(yy * w + x) * 4 + 3]
def detect_arm_model(skin_abs):
"""读皮肤 alpha 判粗臂/细臂。返回 (model, score, notes)
model: 'classic'(粗臂 4px) / 'slim'(细臂 3px) / 'unknown'
依据:64x64 标准布局,右臂区 (40,16)-(55,31)。
粗臂:每个 4x4 面填满 → 侧面行 y=25 在 x40..55 无透明列;top/bottom 面各占 4px
细臂:每个 4x4 面只用 3x3 → 每 4px 段第 4 列透明
"""
notes = []
img = bpy.data.images.load(skin_abs, check_existing=False)
try:
ow, oh = img.size
# 皮肤分辨率不固定:64 是基准,128/256/512/1024…都是同一套 64 网格的整倍数放大,
# 一律缩到 64×64 再判臂型(和下单页的判定保持完全一致)。
if ow != oh:
return "unknown", 0, "非正方形 %dx%d(旧版 2:1,无独立左右臂/腿)" % (ow, oh)
if ow < 64:
return "unknown", 0, "尺寸过小 %dx%d" % (ow, oh)
if ow != 64:
img.scale(64, 64)
w, h = img.size
classic = 0
slim = 0
# 判据1:侧面行 y=25,x=40..55 的透明列数
nt = sum(1 for x in range(40, 56) if _px(img, x, 25, w, h) == 0.0)
if nt >= 2:
slim += 1
else:
classic += 1
notes.append("side-row(y25) transparent cols=%d" % nt)
# 判据2/3:top/bottom 面第 4 列是否存在(细臂该列为空)
for (x, lab) in ((47, "top-face-4th"), (51, "bottom-face-4th")):
if _px(img, x, 17, w, h) == 0.0:
slim += 1
notes.append("%s alpha=0" % lab)
else:
classic += 1
notes.append("%s opaque" % lab)
# 判据4:y16..19 里 x44..51 的有效列数(粗臂 8,细臂 6)
cols = sum(1 for x in range(44, 52)
if any(_px(img, x, y, w, h) > 0 for y in range(16, 20)))
if cols <= 6:
slim += 1
else:
classic += 1
notes.append("face-active cols=%d/8" % cols)
model = "slim" if slim > classic else "classic"
return model, max(slim, classic), "; ".join(notes)
finally:
try:
bpy.data.images.remove(img)
except Exception:
pass
# ------------------------------------------------------------- 场景操作
def find_skin_node(mat_name=None, skin_abs=None):
"""找皮肤图像纹理节点。返回 (material, node) 或 (None, None)
⚠️ 2026-10-01 踩坑(金钻报:「空艇那张皮肤还是默认皮肤材质」):
老逻辑是「名字里带 skin/皮肤 就选,否则**拿第一个贴图节点**」。
空艇模板里第一个贴图节点不是角色皮肤(大概是环境/天空),于是换了个寂寞 ——
角色身上还是模板自带的默认皮肤,而"站立正反"因为节点名带 skin 所以正常。
新逻辑:**给每个候选节点打分挑最高的**,并把候选全打日志(下次出问题一眼看得出)。
分:材质/图片名带 skin|皮肤 +3;图片尺寸 == 上传皮肤的尺寸 +2;≤128 的小图 +1
都不沾(全是大背景图)→ 才退回第一个,并明确警告。
"""
pairs = []
for m in bpy.data.materials:
if not m.use_nodes or not m.node_tree:
continue
for n in m.node_tree.nodes:
if n.type == "TEX_IMAGE" and n.image is not None:
pairs.append((m, n))
if not pairs:
return None, None
if mat_name:
for m, n in pairs:
if m.name == mat_name:
log("皮肤节点 → 按参数指定材质 %s" % m.name)
return m, n
log("⚠️ 指定材质 %r 没找到,改走自动打分" % mat_name)
def size_of(img):
try:
return (int(img.size[0]), int(img.size[1]))
except Exception:
return (0, 0)
want = (0, 0)
if skin_abs:
try:
tmp = bpy.data.images.load(skin_abs, check_existing=False)
want = size_of(tmp)
except Exception:
want = (0, 0)
board = []
for m, n in pairs:
nm = (m.name or "") + " " + (n.image.name or "") + " " + (n.image.filepath or "")
low = nm.lower()
s = 0
if "skin" in low or "皮肤" in nm:
s += 3
w, h = size_of(n.image)
if want != (0, 0) and (w, h) == want:
s += 2
if 0 < w <= 128 and 0 < h <= 128:
s += 1
board.append((s, m, n, (w, h)))
board.sort(key=lambda x: -x[0])
log("贴图节点候选:%s" % ";".join(
"%s/%s %sx%s 分=%d" % (mm.name, (nn.image.name or "?"), wh[0], wh[1], sc)
for sc, mm, nn, wh in board))
best = board[0]
if best[0] == 0:
log("⚠️ 没有节点沾『皮肤』特征(全是大图?) → 按第一个来,可能渲出默认皮肤")
# ⭐ 2026-10-01:**同分的全都要换**。空艇模板里有「角色皮肤_粗臂 / 角色皮肤_细臂」
# 两个皮肤材质(模板作者自己那套工作皮肤),只换排第一的那个 → 用细臂集合渲染时
# 角色身上还是模板自带的深褐色皮肤(金钻报的"还是默认皮肤"就是这原因)。
# 只认"最高分"这一档,是为了不误伤 64x64 的杂图(那张模板里还有床 blue/purple,
# 同尺寸但名字不含 skin,分更低 → 不会被换)。
picked = [x for x in board if x[0] == best[0]]
log("皮肤节点 → 选中 %d 个(分=%d):%s"
% (len(picked), best[0], "、".join(x[1].name + "/" + x[2].name for x in picked)))
return picked
def swap_image(node, new_abs, rel_to_blend):
"""给图像纹理节点换图并打包。
⚠️ 顺序不能反:**必须先 pack() 再改 filepath**。
先改 filepath 的话,Blender 会拿那个相对路径去找源文件;工程一旦不在
皮肤旁边(现在工程走临时目录),就会报
RuntimeError: Unable to pack file, source path '<WIN_DIR>' not found
(2026-09-30 实踩:`//_assets/` 是相对 .blend 所在目录解析的,
.blend 搬去 temp 后就不指向皮肤了。)
"""
old = node.image
img = bpy.data.images.load(new_abs, check_existing=False)
try:
img.pack() # 此刻 filepath 还是绝对路径,找得到源文件
except Exception as e:
log("⚠️ pack 失败(皮肤仍能用于本次渲染,只是工程不自包含): %r" % e)
img.filepath = rel_to_blend # 已打包,路径只剩记录意义
node.image = img
node.interpolation = "Closest"
try:
node.image.colorspace_settings.name = "sRGB"
except Exception:
pass
if old is not None and old.users == 0:
try:
bpy.data.images.remove(old)
except Exception:
pass
return img
# 粗臂/细臂集合在各模板里叫什么,都不一定 —— 2026-09-30 实测三种:
# 1~4 :顶层 `粗臂` / `细臂`
# 5~6 :**嵌在 `Collection` 里**,叫 `Player Wide Rig` / `Player Slim Rig`(英文)
# 7 :顶层 `01_角色_粗臂` / `02_角色_细臂`
# 所以判定必须 ① 递归整棵树 ② 中英双认。写死任何一种都会漏。
WIDE_KEYS = ("粗臂", "wide rig", "wide_rig", "wide-rig")
SLIM_KEYS = ("细臂", "slim rig", "slim_rig", "slim-rig")
def find_layer(root, keys):
"""在**整棵**集合树里找名字命中 keys 的层(广度优先,先浅后深)。
广度优先很重要:1~4 的顶层 `粗臂` 里还嵌着一个 `Player Wide Rig`,
先命中外层才是对的(切外层等于整体切换)。
"""
queue = [root]
while queue:
cur = queue.pop(0)
for ch in cur.children:
low = ch.name.lower()
if any(k.lower() in low for k in keys):
return ch
queue.append(ch)
return None
def set_arm_rig(model):
"""按臂型切换粗臂/细臂。返回 (ok, msg)。
⚠️ **找不到不是错误**:真遇到既没中文也没英文臂集合的模板,
说明那套模板本来就只有一套角色、不需要切 —— 这种情况要放行继续渲染。
(早先版本直接 return False,导致 5/6/7 三个模板全部 exit 5 渲不出来。)
"""
lc = bpy.context.view_layer.layer_collection
wide = find_layer(lc, WIDE_KEYS)
slim = find_layer(lc, SLIM_KEYS)
if wide is None and slim is None:
return True, "此模板没有粗臂/细臂集合,跳过切臂型(按单角色渲)"
if wide is not None:
wide.exclude = (model != "classic")
if slim is not None:
slim.exclude = (model != "slim")
return True, "粗臂[%s].exclude=%s / 细臂[%s].exclude=%s" % (
wide.name if wide else "缺", wide.exclude if wide else "-",
slim.name if slim else "缺", slim.exclude if slim else "-")
def visible_armatures():
out = []
for o in bpy.data.objects:
if o.type == "ARMATURE":
try:
if o.visible_get():
out.append(o.name)
except Exception:
pass
return out
def setup_render_device():
"""--factory-startup 不加载用户偏好 → Cycles 会掉回 CPU(慢 10 倍)。
这里显式把渲染设备切到 GPU。返回描述串。"""
sc = bpy.context.scene
info = []
try:
if not hasattr(sc, "cycles"):
return "no-cycles"
sc.cycles.device = "GPU"
addon = bpy.context.preferences.addons.get("cycles")
if addon is None:
return "GPU 已设但找不到 cycles 偏好面板(可能仍走 CPU)"
cp = addon.preferences
for dt in ("OPTIX", "CUDA", "HIP", "ONEAPI"):
try:
cp.compute_device_type = dt
info.append("type=%s" % dt)
break
except Exception:
continue
cp.get_devices()
used = []
for d in cp.devices:
if d.type != "CPU":
d.use = True
used.append(d.name)
if not used:
for d in cp.devices:
d.use = True
info.append("devices=%s" % (", ".join(used) if used else "CPU-only"))
except Exception as e:
info.append("设置失败:%r" % e)
return "; ".join(info)
def render_to(out_dir, out_name, res, do_render=True, uncompressed=False):
sc = bpy.context.scene
sc.render.resolution_x = res
sc.render.resolution_y = res
sc.render.resolution_percentage = 100
sc.render.image_settings.file_format = "PNG"
dev = setup_render_device()
log("渲染设备 %s" % dev)
target = os.path.join(out_dir, out_name + ".png")
sc.render.filepath = target
if not do_render:
return target, False
t0 = time.time()
bpy.ops.render.render(write_still=True)
dt = time.time() - t0
# compositor 若带 File Output,可能写到别处;兜底找最新 png
if not os.path.exists(target):
cands = [f for f in os.listdir(out_dir) if f.lower().endswith(".png")]
if cands:
newest = max(cands, key=lambda f: os.path.getmtime(os.path.join(out_dir, f)))
target = os.path.join(out_dir, newest)
unc = None
if uncompressed:
unc = os.path.join(out_dir, out_name + UNC_SUFFIX + ".png")
ok = False
# 先试「从已渲好的 Render Result 直接另存」—— 省掉一次完整渲染(一张约 37s)
try:
sc.render.image_settings.file_format = "PNG"
sc.render.image_settings.color_depth = "16"
sc.render.image_settings.compression = 0
rr = bpy.data.images.get("Render Result")
if rr is not None:
rr.save_render(filepath=unc, scene=sc)
ok = os.path.exists(unc) and os.path.getsize(unc) > 1024
except Exception as e:
log("无压缩版直接另存失败,回退到重渲: %r" % e)
if not ok:
# 兜底:老老实实再渲一遍(慢一倍,但保证有图)
try:
sc.render.filepath = unc
bpy.ops.render.render(write_still=True)
ok = os.path.exists(unc) and os.path.getsize(unc) > 1024
except Exception as e:
log("无压缩版重渲也失败: %r" % e)
log("无压缩版 %s %s" % ("OK" if ok else "FAIL", unc))
if not ok:
unc = None
return target, dt, unc
# ------------------------------------------------------------------- main
def main():
a = parse_args()
t_start = time.time()
for p, lab in ((a.template, "template"), (a.skin, "skin"), (a.orders_dir, "orders-dir")):
if not os.path.exists(p):
log("FATAL %s 不存在: %s" % (lab, p))
return 2
tpl_name = os.path.basename(a.template)
blend_name = re.sub(r"^\d+", "", os.path.splitext(tpl_name)[0]) or os.path.splitext(tpl_name)[0]
out_name = a.out_name or blend_name
base = out_base(out_name, a.res)
# 成品文件夹用成品名(模板名[+分辨率]);重名加 -2。
# 工程文件不放这里 —— 走临时目录,渲完就删(金钻:不保留工程文件,避免累计拖慢)。
if a.out_dir:
order_dir = a.out_dir
os.makedirs(order_dir, exist_ok=True)
num = os.path.basename(order_dir)
elif a.num:
num = a.num
order_dir = os.path.join(a.orders_dir, num)
os.makedirs(order_dir, exist_ok=True)
else:
order_dir = make_out_dir(a.orders_dir, base)
num = os.path.basename(order_dir)
log("编号 %s" % num)
log("成品目录 %s" % order_dir)
log("模板 %s" % tpl_name)
log("出图名 %s" % base)
if a.dry_run:
log("DRY-RUN 只做目录/复制/判定,不改场景不渲染")
# --- 1) 临时工程目录(每次一份全新副本;渲完删掉)---
work = tempfile.mkdtemp(prefix="ys_order_%s_" % re.sub(r"\W+", "_", base))
if not a.keep_blend:
# ⚠️ 工程文件不保留(金钻:一份 .blend 二十多兆,攒起来受不住)。
# 任何返回路径都要清掉 —— atexit 兜底,正常结束前再显式删一次。
atexit.register(shutil.rmtree, work, True)
dst_blend = os.path.join(work, tpl_name)
shutil.copy2(a.template, dst_blend)
log("临时工程 %s(渲完删除)" % dst_blend)
# --- 2) 素材 ---
# ⚠️ 皮肤**先放进成品文件夹**(金钻 2026-09-30):渲染失败也留得下素材
skin_abs = os.path.join(order_dir, os.path.basename(a.skin))
if not os.path.exists(skin_abs) or os.path.abspath(skin_abs) != os.path.abspath(a.skin):
shutil.copy2(a.skin, skin_abs)
log("皮肤 → %s" % skin_abs)
block_abs = None
if a.block_texture and os.path.exists(a.block_texture):
block_abs = os.path.join(order_dir, os.path.basename(a.block_texture))
if not os.path.exists(block_abs):
shutil.copy2(a.block_texture, block_abs)
log("方块贴图 → %s" % block_abs)
# --- 3) 臂型判定 ---
model, score, notes = detect_arm_model(skin_abs)
log("臂型判定 %s (票数 %d) | %s" % (model.upper(), score, notes))
if a.arm != "auto" and a.arm != model:
# 指定优先:买家/金钻在页面上手动改过就听他的(自动判定只写进日志备查)
log("臂型指定 %s(自动判定是 %s)→ 按指定的走" % (a.arm.upper(), model.upper()))
model = a.arm
if model == "unknown":
log("FATAL 皮肤尺寸不支持,无法判定臂型")
return 3
if a.dry_run:
log("DRY-RUN 结束,未开 Blender 场景。耗时 %.1fs" % (time.time() - t_start))
_write_log(order_dir, num, model, notes, a, out_name, None)
return 0
# --- 4) 打开副本,改场景 ---
bpy.ops.wm.open_mainfile(filepath=dst_blend)
log("已打开 %s" % dst_blend)
picked = find_skin_node(a.skin_material, skin_abs)
if not picked:
log("FATAL 场景里找不到可用的图像纹理节点")
return 4
rel = "//" + os.path.basename(skin_abs) # 图片已 pack,路径仅作记录
# ⚠️ 2026-10-01 实踩:一开始写成"每个节点各 load+pack 一次",空艇这种双皮肤材质模板
# 直接让 Blender 崩掉(退出码 9)。正确做法是**只加载打包一次**,多个节点共用同一张图。
try:
img = bpy.data.images.load(skin_abs, check_existing=False)
try:
img.pack() # 此刻 filepath 还是绝对路径,找得到源文件
except Exception as e:
log("⚠️ pack 失败(皮肤仍能用于本次渲染,只是工程不自包含): %r" % e)
img.filepath = rel # 已打包,路径只剩记录意义
# ⚠️ board 里每项是**四元组** (分数, 材质, 节点, 尺寸) ——
# 写成 `for mat, node in picked` 会 ValueError: too many values to unpack
# (2026-10-01 实踩:空艇+站立两个模板全因此渲染失败,退出码 4)
for _sc, mat, node, _wh in picked:
node.image = img
log("换皮肤 材质=%s 节点=%s → %s(已打包)" % (mat.name, node.name, rel))
except Exception as e:
log("FATAL 换皮肤失败:%r" % e)
return 4
ok, msg = set_arm_rig(model)
log("选集合 %s | %s" % ("OK" if ok else "FAIL", msg))
if not ok: # 现在只有"真找不到"才会走到这(正常模板不会)
return 5
log("可见骨架 %s" % ", ".join(visible_armatures()))
log("工程 不保存(渲完随临时目录一起删)")
# --- 5) 渲染 ---
# 成品命名见文件顶部 out_base():默认 1000 不带数字,其它分辨率带数字。
target, dt, unc = render_to(order_dir, base, a.res,
do_render=not a.no_render,
uncompressed=a.uncompressed)
# 渲完立刻删工程:别把 20 多兆的 .blend 留在盘上
if a.keep_blend:
log("临时工程 保留(--keep-blend):%s" % work)
else:
shutil.rmtree(work, ignore_errors=True)
log("临时工程 已删除(不保留 .blend)")
if a.no_render:
unc = None
log("跳过渲染(--no-render)")
else:
log("渲染完成 %s (%.1fs)" % (target, dt if isinstance(dt, float) else 0))
log("成品 %s + %s" % (std_name(out_name, a.res), unc_name(out_name, a.res)))
_write_log(order_dir, num, model, notes, a, out_name, target)
log("全部完成 耗时 %.1fs" % (time.time() - t_start))
return 0
def _write_log(order_dir, num, model, notes, a, out_name, target):
stamp = time.strftime("%Y-%m-%d %H:%M:%S")
body = [
"# 商单 %s —— 自动生成(make_order.py)" % num,
"",
"生成时间:%s" % stamp,
"",
"## 输入",
"- 模板:`%s`" % a.template,
"- 皮肤:`%s`" % os.path.basename(a.skin),
"- 方块贴图:%s" % (os.path.basename(a.block_texture) if a.block_texture else "(无)"),
"",
"## 自动判定",
"- **皮肤臂型:%s**(%s)" % (model.upper(), notes),
"- 集合切换:%s" % ("粗臂" if model == "classic" else "细臂"),
"",
"## 输出",
"- 工程:`%s`" % os.path.basename(a.template),
"- 出图:`%s`%s" % (std_name(out_name, a.res),
("、`%s`" % unc_name(out_name, a.res)) if target else ""),
"",
"## 说明",
"皮肤臂型判定依据(64x64 标准布局,右臂区 40..55 / 16..31):",
"- 侧面行 y=25 在 x40..55 的透明列数:细臂每 4px 段留 1 列空 → ≥2 列透明",
"- top/bottom 面第 4 列(x=47 / x=51):细臂该列为空",
"- y16..19 中 x44..51 的有效列数:粗臂 8 列,细臂 6 列",
"四项投票多数决;票数接近时请人工复核。",
"",
"---",
"",
"### 运行日志",
"",
"```",
] + LOGLINES + ["```", ""]
try:
with open(os.path.join(order_dir, "_CHANGES.md"), "w", encoding="utf-8") as f:
f.write("\n".join(body))
with open(os.path.join(order_dir, "_make_order.log"), "w", encoding="utf-8") as f:
f.write("\n".join(LOGLINES) + "\n")
except Exception as e:
print("write log failed: %r" % e)
if __name__ == "__main__":
try:
sys.exit(main())
except Exception:
traceback.print_exc()
log("FATAL 未捕获异常")
sys.exit(9)