1. 项目概述：当游戏模型成为性能“杀手”

在游戏开发、三维动画乃至虚拟现实项目中，我们常常会遇到一个令人头疼的问题：模型文件太大了。一个精心雕刻的高精度角色模型，面数动辄几十万甚至上百万，直接导入引擎后，不仅加载缓慢，运行时更是对GPU的严峻考验，帧率骤降、内存吃紧是家常便饭。尤其是在移动端或追求流畅体验的实时渲染场景中，模型优化是必经之路。这时，“网格简化”就成了三维美术师和TA（技术美术）手中的一把利器。

今天要聊的，就是在开源三维创作套件Blender中，利用经典的QEM（Quadric Error Metrics）算法来对高面数模型进行智能减面。不同于Blender自带的“精简修改器”（Decimate Modifier）里简单的“塌陷边”或“平面化”选项，QEM算法是一种基于几何误差度量的、更“聪明”的简化方法。它能最大程度地保留模型原有的形状特征和轮廓，在删除大量三角面的同时，让模型看起来“没怎么变”。更棒的是，我们可以通过Python脚本，将这个过程自动化、批量化，这对于需要处理大量资产的项目来说，效率提升不是一点半点。

这篇文章，我将以一个游戏开发者的视角，手把手带你理解QEM算法的核心思想，并分享一个可直接在Blender中运行的Python脚本。无论你是想优化自己的独立游戏资产，还是希望深入理解网格处理背后的原理，这篇内容都能给你带来实实在在的收获。我们将避开枯燥的纯理论推导，聚焦于“如何用起来”和“为什么这么做”，并附上我踩过的一些坑和经验之谈。

2. 核心原理：QEM算法如何“聪明”地减面？

在深入操作之前，我们有必要花点时间弄明白QEM算法到底在干什么。这能帮助你在后续调整参数时，知道每一个滑块背后的意义，而不是盲目尝试。

2.1 从“边塌陷”到“误差度量”

网格简化的本质是减少顶点和面的数量。最直接的操作就是“边塌陷”（Edge Collapse）：将一条边的两个顶点合并成一个新的顶点。那么问题来了：应该合并哪条边？合并后的新顶点应该放在哪里？

一种朴素的想法是，优先合并最短的边，或者将新顶点放在旧边的中点。但这会带来严重问题：模型上那些定义特征（如鼻子尖、眼角）的短边可能被过早合并，导致特征丢失；而放在中点也不一定是最优位置，可能会让模型表面产生不自然的凹陷或凸起。

QEM算法的聪明之处在于，它为每一个顶点定义了一个“误差二次型”（Quadric Error Metric）。这个听起来有点唬人的概念，其实可以直观理解为：这个顶点对它周围一系列三角面的“代表性”有多好。如果一个顶点移动了，它会导致周围所有关联的面都发生形变，QEM值就是这些形变程度的平方和。

具体来说，算法为模型中的每个三角面计算一个代表其平面方程的4x4矩阵（称为二次误差矩阵）。然后，将共享同一个顶点的所有面的这些矩阵加起来，就得到了属于这个顶点的二次误差矩阵。当我们要塌陷一条边（v1, v2）时：

1. 计算一个候选的新顶点v_new的位置。理论上，最优位置是能使合并后总QEM误差最小的点，这可以通过求解一个小型线性方程组得到。
2. 计算将v1和v2塌陷到v_new这个操作所带来的“代价”（Cost），这个代价就是v_new处的QEM误差值。
3. 算法会优先塌陷“代价”最小的边。因为代价小，意味着这次合并对模型整体形状的改变最小。

2.2 QEM的优势：特征保持与体积守恒

基于误差度量的策略，让QEM拥有了传统方法难以比拟的优势：

• 特征保持：位于尖锐边缘、拐角处的顶点，关联的面法向差异大，其QEM误差矩阵“各向异性”强。移动这类顶点会导致很大的误差代价，因此它们在简化过程中会被保留得更久。相反，平坦区域顶点移动的代价小，会被优先合并。
• 体积近似守恒：QEM误差在数学上近似于顶点移动导致的局部体积变化平方和。因此，算法会倾向于生成一个在体积上和原始模型接近的简化模型，避免了模型整体“缩水”或“膨胀”的视觉问题。
• 自适应简化：它本质上是一种全局优化方法。算法维护一个所有边的“代价”优先队列，每次取出代价最小的边进行塌陷，然后更新受影响边的代价。如此迭代，直到达到目标面数或误差阈值。

注意：虽然QEM很强大，但它并非万能。对于具有复杂材质、多UV集或顶点色信息的模型，单纯的几何简化可能会破坏这些属性之间的关联。我们的脚本会处理基础的UV插值，但对于复杂的属性映射，可能需要更专门的工具或后处理。

理解了这些，我们再打开Blender的“精简修改器”，选择“折叠”模式，其底层就是QEM算法的一种实现。接下来，我们要做的就是用Python脚本，获得比GUI操作更灵活、更自动化的控制能力。

3. 环境准备与脚本框架解析

我们不依赖任何外部Python库，完全利用Blender内置的bpy和bmesh模块进行操作。这保证了脚本在任何安装了Blender的环境下都能直接运行。

3.1 Blender Python环境确认

首先，确保你使用的Blender版本（建议2.8及以上）支持Python脚本。打开Blender，切换到“脚本”工作区，或者在任何界面按F4打开搜索菜单，输入“Python”可以找到文本编辑器。新建一个文本文件，我们将在这里编写和运行代码。

核心模块介绍：

• bpy: Blender Python的主模块，用于访问场景、对象、网格数据等。
• bmesh: 一个用于在Python中创建、编辑网格数据的强大工具包。它提供了对网格拓扑的低级访问，非常适合执行像边塌陷这样的操作。
• mathutils: Blender的数学库，包含向量、矩阵、四元数等，用于几何计算。

3.2 脚本核心逻辑与函数设计

我们的脚本将遵循一个清晰的流程，我将拆解为几个关键函数：

1. create_qem_quadrics(mesh): 遍历网格所有面，为每个顶点计算并累积其二次误差矩阵（Quadric）。这是算法的初始化阶段，也是最核心的数据准备。
2. calculate_collapse_cost(bm, edge, vertex_quadrics): 给定一条边和所有顶点的Quadric数据，计算塌陷这条边的代价，并返回最优的新顶点位置和代价值。
3. simplify_mesh(obj, target_ratio, preserve_boundary=True): 主简化函数。它接受一个Blender对象、一个简化比例（如0.5表示减少到50%的面数）和一个是否保护开放边界的标志。内部会创建一个bmesh对象，构建优先队列，并迭代执行边塌陷。
4. interpolate_vertex_attributes(bm, v_remove, v_target, v_new): 当边(v_remove, v_target)塌陷到新顶点v_new时，如何处理原顶点的UV、顶点色等属性？这个函数负责进行线性插值。

下面，我们先给出一个最简化的脚本骨架，并逐一填充血肉。

import bpy import bmesh from mathutils import Matrix, Vector import heapq from collections import defaultdict def create_qem_quadrics(bm): """ 为BMesh中的每个顶点计算并累积Quadric误差矩阵。 返回一个字典：vertex.index -> 4x4 Matrix """ vertex_quadrics = defaultdict(lambda: Matrix.Zero(4)) for face in bm.faces: # 计算面的平面方程: Ax + By + Cz + D = 0 normal = face.normal.normalized() vert = face.verts[0] d = -normal.dot(vert.co) # 平面系数向量 [A, B, C, D] p = Vector((normal.x, normal.y, normal.z, d)) # Quadric矩阵 K = p * p^T K = Matrix.Outer(p, p) # 这是一个4x4矩阵 # 将这个面的K累加到其所有顶点上 for v in face.verts: vertex_quadrics[v.index] += K return vertex_quadrics

这个函数是QEM算法的基石。它为每个面计算一个代表其空间位置的矩阵K，然后把这个矩阵加到组成该面的每一个顶点上。最终，每个顶点都存储了其周围所有面的“位置信息”之和。后续计算移动顶点的代价，就靠这个累积矩阵。

4. 算法核心：边塌陷代价计算与优先队列

有了顶点的Quadric数据，我们就可以评估塌陷任何一条边的“代价”了。

4.1 计算单次塌陷的最优位置与代价

def calculate_collapse_cost(bm, edge, vertex_quadrics, preserve_boundary=True): """ 计算塌陷一条边的代价。 返回: (cost, optimal_position) 如果边可塌陷，否则 (float('inf'), None) """ v1, v2 = edge.verts # 获取两个顶点的Quadric并相加 Q = vertex_quadrics[v1.index] + vertex_quadrics[v2.index] # 边界保护：如果设置了保护边界，且这条边是边界边，则赋予极高代价（或禁止） if preserve_boundary and edge.is_boundary: # 对于需要严格保护的边界（如模型轮廓），可以直接返回无限大代价 # 但有时为了达到简化目标，可以允许边界简化，只是代价更高。 # 这里我们采用一个简单策略：边界边代价乘以一个惩罚因子 boundary_penalty = 10.0 # 继续计算，但最后代价会乘以惩罚因子 # 我们需要求解 Q * v' = [0,0,0,1]^T 来找到最优顶点v‘ (齐次坐标) # 即求解线性方程组。更稳定的做法是使用Q的左上角3x3子矩阵加上位移约束。 # 构造矩阵A和向量b A = Matrix() for i in range(4): row = [] for j in range(4): row.append(Q[i][j]) A.append(row) # 将A的最后一行替换为 [0,0,0,1]，将b设为 [0,0,0,1] # 这相当于约束 v‘的齐次坐标w分量为1 A[3] = [0,0,0,1] b = Vector((0,0,0,1)) try: # 尝试求解线性方程组 A * x = b optimal_pos_homogeneous = A.inverted() @ b optimal_position = optimal_pos_homogeneous.xyz / optimal_pos_homogeneous.w except: # 如果矩阵奇异（不可逆），则 fallback 到边的中点 optimal_position = (v1.co + v2.co) / 2 # 计算代价: v‘^T * Q * v‘ (实际上就是误差值) v_homo = Vector((optimal_position.x, optimal_position.y, optimal_position.z, 1)) # 计算二次型: v^T * Q * v cost = v_homo.dot(Q @ v_homo) # 更准确的写法是 v_homo @ (Q @ v_homo) # 应用边界惩罚 if preserve_boundary and edge.is_boundary: cost *= boundary_penalty # 额外的约束检查：例如，防止面翻转（可选，较复杂，此处略） return cost, optimal_position

这段代码有几个关键点：

1. 最优位置求解：理论上最优位置是使误差函数梯度为零的点，这导出了一个线性方程组。我们通过构造并求解一个4x4方程组来找到它。使用齐次坐标是为了处理平移。
2. 退化情况处理：当矩阵不可逆时（例如，在共面或退化面上），我们回退到简单的边的中点。这是一个重要的稳健性处理。
3. 边界保护：通过给边界边的代价乘以一个惩罚因子（如10.0），我们让算法“不太情愿”去塌陷边界，从而更好地保持模型的轮廓。你可以根据需要调整这个因子。

4.2 构建与管理优先队列

简化过程是一个循环：每次找到代价最小的边，塌陷它，然后更新受影响边的代价。一个高效的优先队列（这里用Python的heapq模块）至关重要。

def simplify_mesh(obj, target_ratio=0.5, preserve_boundary=True): """ 主简化函数。 obj: Blender对象（必须是网格对象） target_ratio: 目标面数相对于原始面数的比例（0-1） preserve_boundary: 是否保护开放边界 """ import time start_time = time.time() # 1. 创建BMesh并导入网格数据 mesh = obj.data bm = bmesh.new() bm.from_mesh(mesh) bm.verts.ensure_lookup_table() bm.edges.ensure_lookup_table() bm.faces.ensure_lookup_table() original_face_count = len(bm.faces) target_face_count = int(original_face_count * target_ratio) print(f"开始简化，原始面数: {original_face_count}, 目标面数: {target_face_count}") # 2. 计算初始Quadrics vertex_quadrics = create_qem_quadrics(bm) # 3. 为每条边计算初始代价，并加入优先队列 # 优先队列元素: (cost, edge.index, (v1.index, v2.index), optimal_position) # 使用edge.index作为tie-breaker，因为cost可能相同 heap = [] edge_data = {} # 映射 edge.index -> (optimal_position, cost) for edge in bm.edges: if len(edge.link_faces) == 0: continue # 跳过孤立的边（理论上不应该有） cost, optimal_pos = calculate_collapse_cost(bm, edge, vertex_quadrics, preserve_boundary) # 存储数据 edge_data[edge.index] = (optimal_pos, cost) # 入堆 heapq.heappush(heap, (cost, edge.index, (edge.verts[0].index, edge.verts[1].index))) # 4. 迭代塌陷循环 removed_verts = set() while len(bm.faces) > target_face_count and heap: # 取出当前代价最小的边 cost, edge_idx, (v1_idx, v2_idx) = heapq.heappop(heap) # 检查边是否仍然有效（可能在之前的塌陷中被删除了） try: edge = bm.edges[edge_idx] except: continue # 边已不存在，跳过 # 检查顶点是否仍然有效 if v1_idx in removed_verts or v2_idx in removed_verts: continue v1 = bm.verts[v1_idx] v2 = bm.verts[v2_idx] # 获取之前计算的最优位置 optimal_pos, stored_cost = edge_data.get(edge_idx, (None, float('inf'))) if optimal_pos is None or abs(stored_cost - cost) > 1e-6: # 数据不一致，重新计算（安全措施） cost, optimal_pos = calculate_collapse_cost(bm, edge, vertex_quadrics, preserve_boundary) # 执行边塌陷：将v1塌陷到optimal_pos，并合并v2 # 注意：bmesh.ops.pointmerge 可以合并顶点，但我们需要控制新顶点位置。 # 策略：先将v1移动到optimal_pos，然后将v2合并到v1。 v1.co = optimal_pos # 使用bmesh操作合并顶点 bmesh.ops.pointmerge(bm, verts=[v1, v2], merge_co=v1.co) # 标记被移除的顶点 removed_verts.add(v2_idx) # 5. 更新受影响的边和Quadrics # 找出所有与v1（现在是合并后的顶点）相连的边 for edge in v1.link_edges: # 重新计算这条边的代价 new_cost, new_optimal_pos = calculate_collapse_cost(bm, edge, vertex_quadrics, preserve_boundary) edge_data[edge.index] = (new_optimal_pos, new_cost) # 将新的代价推入堆中（允许重复，旧的无效条目会在弹出时被跳过） heapq.heappush(heap, (new_cost, edge.index, (edge.verts[0].index, edge.verts[1].index))) # 更新v1的Quadric为合并后的Quadric (v1 + v2) vertex_quadrics[v1.index] = vertex_quadrics.get(v1_idx, Matrix.Zero(4)) + vertex_quadrics.get(v2_idx, Matrix.Zero(4)) # 清理已删除顶点的Quadric数据（可选） if v2_idx in vertex_quadrics: del vertex_quadrics[v2_idx] # 可选：每简化一定比例，打印进度 if len(bm.faces) % 500 == 0: print(f"当前面数: {len(bm.faces)}") # 6. 将BMesh数据写回原始网格 bm.to_mesh(mesh) bm.free() mesh.update() end_time = time.time() print(f"简化完成！最终面数: {len(mesh.polygons)}， 耗时: {end_time - start_time:.2f}秒") return obj

这个主函数是脚本的大脑。它管理了整个简化生命周期。其中，优先队列的管理和无效条目的处理是容易出错的地方。我们采用“惰性删除”策略：即使堆里某条边的数据过期了（边已被删除），我们也先弹出它，然后在处理时检查其有效性并跳过。这比在每次塌陷后主动从堆中删除所有受影响边要简单高效。

5. 属性插值与脚本完整实现

几何简化之后，模型的外观还依赖于UV、顶点色等属性。如果直接合并顶点，这些属性会丢失，导致贴图错乱。因此，在塌陷边时，我们需要将旧顶点的属性插值到新顶点上。

5.1 UV与顶点色的插值策略

Blender的BMesh为每个顶点-环（loop）存储了UV、顶点色等数据。当边(v_remove, v_target)塌陷到v_new时，我们需要为v_new生成这些数据。一个简单而有效的策略是基于距离的线性插值。

def interpolate_vertex_attributes(bm, v_remove, v_target, v_new): """ 将v_remove和v_target的属性插值到v_new上。 这里以UV和顶点色为例。 """ # 获取网格的UV层和顶点色层（按名称，假设使用默认层） uv_layer = bm.loops.layers.uv.active vcol_layer = bm.loops.layers.color.active if not uv_layer and not vcol_layer: return # 计算权重：可以简单使用1:1，或者基于到新顶点的距离反比 # 这里使用简单平均 weight_remove = 0.5 weight_target = 0.5 # 我们需要找到v_new对应的loop。由于v_new是新建或移动的顶点，可能还没有loop数据。 # 更实际的做法是：在bmesh.ops.pointmerge操作后，v_target的loop数据会转移到v_remove上。 # 因此，我们在调用此函数时，实际上是对合并后的顶点（即v_remove，其坐标已更新为v_new）更新其loop数据。 # 所以这里的 v_new 参数在pointmerge后就是 v_remove。 # 我们遍历v_remove（即新顶点）的所有loop，为其重新计算属性。 for face in v_new.link_faces: for loop in face.loops: if loop.vert == v_new: # 这个loop对应新顶点 # 我们需要找到这个loop在原始两个顶点上的对应loop的插值。 # 这是一个复杂的拓扑匹配问题。简化方案：对每个loop，找到其所在的面，然后找到该面中原来属于v_remove和v_target的loop（如果存在），进行插值。 # 由于实现复杂，一个生产级的简化器会维护更完整的属性映射关系。 # 作为示例，我们这里采用一个非常简化的处理：仅当面的顶点顺序恰好能对应时。 pass # 具体实现见下方“注意事项”

实操心得：属性插值的复杂性完整的属性插值是网格简化中最棘手的部分之一，远比几何计算复杂。因为UV是存储在“环”上，而一个顶点在不同的面上可能有不同的UV值（例如，在纹理接缝处）。塌陷边可能会改变网格的拓扑连接，导致旧的“环”关系断裂。

对于大多数实际应用，我建议采取以下折中方案：

1. 使用Blender内置算法：我们脚本的核心是QEM几何简化。对于属性，可以依赖Blender BMesh在pointmerge操作时的内部逻辑，它通常会尝试插值属性。虽然不完美，但对于没有复杂UV接缝的模型，结果可以接受。
2. 先简化，后手动修复：对于重要的角色或道具，在剧烈简化后，在UV编辑器中检查并手动修复重要的UV变形区域，这比编写一个完美的自动插值器更省时间。
3. 使用专业工具：对于生产流程，业界有更成熟的网格简化库（如OpenMesh、CGAL的简化算法），它们通常提供了更完善的属性处理机制。我们的脚本更适合学习原理和快速原型。

考虑到上述复杂性，我们将提供一个简化但可工作的完整脚本，它专注于QEM几何简化，并包含一个基础的UV插值占位符。你可以根据项目需求进一步完善属性处理部分。

5.2 完整可运行的Python脚本

以下是整合了所有部分，并添加了用户交互接口的完整脚本。你可以将其复制到Blender的文本编辑器中，选中你想要简化的网格物体，然后运行脚本。

import bpy import bmesh from mathutils import Matrix, Vector import heapq from collections import defaultdict def create_qem_quadrics(bm): """计算每个顶点的Quadric误差矩阵。""" vertex_quadrics = defaultdict(lambda: Matrix.Zero(4)) for face in bm.faces: if face.hide: continue normal = face.normal.normalized() vert = face.verts[0] d = -normal.dot(vert.co) p = Vector((normal.x, normal.y, normal.z, d)) # 构造4x4矩阵 K = p * p^T K = Matrix() for i in range(4): row = [] for j in range(4): row.append(p[i] * p[j]) K.append(row) for v in face.verts: vertex_quadrics[v.index] += K return vertex_quadrics def calculate_collapse_cost(bm, edge, vertex_quadrics, boundary_weight=10.0): """计算塌陷一条边的代价和最优新顶点位置。""" v1, v2 = edge.verts Q = vertex_quadrics[v1.index] + vertex_quadrics[v2.index] # 构造矩阵A = Q，但将最后一行替换为[0,0,0,1]以强制解的第4维为1 A = Matrix(Q) A[3] = [0,0,0,1] b = Vector((0,0,0,1)) try: A_inv = A.inverted() optimal_pos_homo = A_inv @ b # 从齐次坐标转换回3D坐标 if abs(optimal_pos_homo[3]) > 1e-6: optimal_pos = optimal_pos_homo.xyz / optimal_pos_homo.w else: optimal_pos = (v1.co + v2.co) / 2 except: # 矩阵奇异，回退到边的中点 optimal_pos = (v1.co + v2.co) / 2 # 计算代价 v^T * Q * v v_homo = Vector((optimal_pos.x, optimal_pos.y, optimal_pos.z, 1)) cost = v_homo.dot(Q @ v_homo) # 边界惩罚 if edge.is_boundary: cost *= boundary_weight return cost, optimal_pos def simplify_mesh_qem(obj, ratio=0.5, preserve_boundary=True, boundary_weight=5.0): """ 使用QEM算法简化选中的网格对象。 Args: obj: Blender网格对象 ratio: 目标面数比例 (0.0 ~ 1.0) preserve_boundary: 是否强调保护边界 boundary_weight: 边界边代价乘数（越大越保护） """ if obj.type != 'MESH': print("错误：请选择一个网格对象。") return mesh = obj.data # 进入对象模式并取消所有编辑状态 bpy.context.view_layer.objects.active = obj bpy.ops.object.mode_set(mode='OBJECT') bm = bmesh.new() bm.from_mesh(mesh) bm.verts.ensure_lookup_table() bm.edges.ensure_lookup_table() bm.faces.ensure_lookup_table() original_face_count = len(bm.faces) target_face_count = max(1, int(original_face_count * ratio)) print(f"[QEM简化] 开始: {original_face_count} -> {target_face_count} 面") # 计算初始Quadrics print("正在计算初始Quadric矩阵...") vertex_quadrics = create_qem_quadrics(bm) # 初始化优先队列和边数据缓存 heap = [] edge_optimal_data = {} # edge.index -> (optimal_position, cost) print("正在构建初始边代价队列...") for edge in bm.edges: if len(edge.link_faces) == 0: continue # 跳过孤边 cost, optimal_pos = calculate_collapse_cost(bm, edge, vertex_quadrics, boundary_weight) edge_optimal_data[edge.index] = (optimal_pos, cost) # 使用边索引作为tie-breaker heapq.heappush(heap, (cost, edge.index, (edge.verts[0].index, edge.verts[1].index))) removed_verts = set() collapse_count = 0 print("开始迭代塌陷...") while len(bm.faces) > target_face_count and heap: cost, edge_idx, (v1_idx, v2_idx) = heapq.heappop(heap) # 有效性检查 try: edge = bm.edges[edge_idx] except IndexError: continue # 边已被删除 if v1_idx in removed_verts or v2_idx in removed_verts: continue if edge.is_valid is False: continue v1 = bm.verts[v1_idx] v2 = bm.verts[v2_idx] # 获取缓存的最优位置和代价 optimal_pos, cached_cost = edge_optimal_data.get(edge_idx, (None, None)) if optimal_pos is None or abs(cached_cost - cost) > 1e-5: # 缓存失效，重新计算 cost, optimal_pos = calculate_collapse_cost(bm, edge, vertex_quadrics, boundary_weight) edge_optimal_data[edge_idx] = (optimal_pos, cost) # ---- 执行塌陷操作 ---- # 策略：将v1移动到最优位置，然后将v2合并到v1 old_v1_co = v1.co.copy() v1.co = optimal_pos # 使用bmesh的pointmerge操作，它会处理拓扑连接和基础属性插值 # 找到所有需要合并的顶点（v1和v2） verts_to_merge = [v for v in (v1, v2) if v.is_valid] if len(verts_to_merge) == 2: # 执行合并，合并后的顶点是v1 bmesh.ops.pointmerge(bm, verts=verts_to_merge, merge_co=v1.co) # 标记v2已被移除 removed_verts.add(v2_idx) collapse_count += 1 # ---- 更新受影响的边 ---- # 更新v1的Quadric vertex_quadrics[v1.index] = vertex_quadrics.get(v1_idx, Matrix.Zero(4)) + vertex_quadrics.get(v2_idx, Matrix.Zero(4)) # 清理v2的Quadric数据 if v2_idx in vertex_quadrics: del vertex_quadrics[v2_idx] # 重新计算所有与v1相连的边的代价，并推入堆中 for e in v1.link_edges: if not e.is_valid: continue new_cost, new_optimal = calculate_collapse_cost(bm, e, vertex_quadrics, boundary_weight) edge_optimal_data[e.index] = (new_optimal, new_cost) heapq.heappush(heap, (new_cost, e.index, (e.verts[0].index, e.verts[1].index))) # 进度提示 if collapse_count % 100 == 0: print(f" 已塌陷 {collapse_count} 条边，当前面数: {len(bm.faces)}") # 清理并写回网格 print("简化完成，正在更新网格数据...") bm.normal_update() bm.to_mesh(mesh) bm.free() mesh.update() final_face_count = len(mesh.polygons) print(f"[QEM简化] 完成！最终面数: {final_face_count}， 共塌陷 {collapse_count} 条边。") print(f"面数减少比例: {(original_face_count - final_face_count)/original_face_count*100:.1f}%") # ---- 用户界面与执行部分 ---- # 获取当前选中的物体 selected_objs = [obj for obj in bpy.context.selected_objects if obj.type == 'MESH'] if not selected_objs: print("错误：未选中任何网格物体。") else: for obj in selected_objs: print(f"\n正在处理对象: {obj.name}") # 设置简化参数：目标比例为原面数的30%，开启边界保护 simplify_mesh_qem(obj, ratio=0.3, preserve_boundary=True, boundary_weight=5.0) print("\n脚本执行完毕。建议在简化后手动检查UV和法线，必要时使用'加权法向'修改器或'重新计算外侧'。")

6. 参数调优、常见问题与实战技巧

脚本跑起来了，但效果可能不尽如人意。别急，网格简化是一门实践的艺术，需要根据模型特点调整参数。

6.1 关键参数解析与调优指南

1. ratio(目标比例): 这是最重要的参数。建议从0.5（减半）开始尝试。对于高模（如数百万面），可以尝试0.1甚至更低；对于已经较低的模型，0.7或0.8可能更安全。切忌一步到位，可以分多次简化，每次观察效果。
2. boundary_weight(边界权重): 控制边界保护强度。默认值5.0意味着边界边的塌陷代价是内部的5倍。
   • 对于封闭模型（如角色、道具）：可以设置得较高（10.0-50.0），甚至结合preserve_boundary逻辑完全禁止边界塌陷，以保持模型轮廓。
   • 对于有复杂开口或内部结构的模型：可能需要降低该值（如2.0），否则可能导致简化无法进行（因为所有边都是边界）。
3. preserve_boundary: 一个布尔开关。当为True时，上述边界权重生效。如果你不关心边界（例如，简化一个即将被其他几何体完全遮挡的内部部件），可以设为False。

实操心得：迭代简化与检查点不要试图用一个极高的简化比例（如0.1）一次性完成。更好的工作流是：

1. 复制一份原始模型作为备份。
2. 使用比例0.7进行第一次简化，检查主要轮廓和特征。
3. 如果效果满意，对简化后的模型再次应用脚本，使用比例0.5（相对于当前模型）。这相当于总共简化到原始面数的0.35（0.7*0.5）。这种分步法往往比单步简化到0.35能更好地保持特征。

6.2 常见问题、错误排查与修复

即使算法正确，在实际操作中你仍会遇到各种问题。下面是一个速查表：

6.3 进阶技巧与工作流整合

1. 选择性简化：你不需要简化整个模型。在运行脚本前，进入编辑模式，选中需要高精度保持的区域（如角色脸部），将其顶点组（Vertex Group）指定一个高权重。然后修改脚本，在计算边代价时，如果边关联了高权重顶点，就大幅增加其塌陷代价。这可以实现局部保护简化。
2. 与法线贴图烘焙工作流结合：这是游戏行业的黄金标准。流程是：拥有一个高模（Hi-Poly）和一个通过此方法生成的、拓扑良好的低模（Low-Poly）。将低模的UV展开好，然后在烘焙软件（或Blender的烘焙功能）中，将高模的细节以法线贴图的形式烘焙到低模上。这样，低模在游戏中就能呈现出高模的细节。我们的脚本是生成这个优质低模的关键一步。
3. 批处理：你可以轻松修改脚本，遍历场景中所有特定集合（Collection）下的网格物体，进行批量简化，并记录每个物体的简化日志，非常适合清理整个场景的资产。

网格简化是三维内容创作中从“作品”到“产品”的关键一步。通过理解QEM算法的原理，并掌握这个可定制化的脚本工具，你就能在面对性能瓶颈时，游刃有余地对模型资产进行优化，在视觉质量和运行效率之间找到最佳平衡点。记住，没有一次完美的简化，多尝试、多观察、结合多种工具，才是高效的工作之道。