片场里,导演扛着摄像机走过熙熙攘攘的街道,身后跟着几百名群演。他不需要让每个人都化妆到睫毛根根分明——主角要给特写,配角给中景,远景的群演只要站出个轮廓;镜头拍不到的角落,干脆让人去休息。如果导演要求每个镜头所有人全妆站满全场,这台摄影机马上会卡成幻灯片。游戏引擎面临的正是同样的问题:场景里可能有上千个物体,全部用最高精度的模型渲染,GPU 每秒只够画一帧。LOD(细节层次)与剔除优化,就是渲染世界的“片场调度智慧”——只精雕细琢摄像机真正看得见、看得清的部分,其余用最低成本带过,甚至直接让他们“下班”。这篇文章,就带你从导演视角俯瞰整个实时渲染流水线:如何给演员分级派活(LOD)、如何让片区领队统一调度(HLOD)、如何让镜头外的人散场(视锥剔除)、如何让被挡住的人就地待命(遮挡剔除)。

岗位关联

掌握 LOD 与剔除优化,是成为游戏引擎工程师与图形程序员的硬核竞争力——它决定了你的场景能不能在千万级物体的压力下依然保持 60 帧流畅运行。

目录
  1. 可视化演示
  2. LOD核心概念
  3. LOD生成算法
  4. HLOD层次化
  5. 视锥剔除
  6. 遮挡剔除
  7. 优化综合策略
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

模拟LOD分级切换、视锥剔除与HLOD层次化合并,通过距离滑块观察网格精度与绘制调用数量的动态变化。

本节配有交互动效(进入视口后自动加载,约 3KB)。

LOD分级距离切换 近距离使用高精度网格LOD0 远距离自动降级至LOD2低精度 LOD_i = select(screenSize(d), thresholds) 基于屏幕占比选择最优网格层级。

LOD核心概念

导演手里有一张“景别表”:主角站在 3 米内,必须化妆到睫毛根根分明;10 米外的配角,唇色可以糊一点;50 米外的群演,穿个色块站那儿晃动就行。他绝不会浪费化妆师的时间给远景群演逐帧补妆——因为观众根本看不清。LOD(Level of Detail,细节层次)就是这个直觉的计算机版本:根据物体在屏幕上占据的像素大小,动态选择不同精度的模型。

屏幕越大、离得越近的物体,值得用密集的三角形网格(高模);远在天边的小东西,用几百个三角形的剪影(低模)就够了。这个“精度的弹性”靠的是预先生成多档替身:LOD0 是最高精度的“主角替身”,LOD1、LOD2 逐级减面,LOD3 只剩轮廓。游戏运行时,引擎根据物体到摄像机的距离,像导演翻“景别表”一样查表切换。

但“距离多少该切换”不能拍脑袋。核心准则是像素误差——低模替身和完美高模的几何差异,折算到屏幕上占几个像素。如果差异小于一个像素,人眼根本分辨不出来,此时切换就是无痛的。

导演的“景别表”不需要精确到厘米,但引擎的 LOD 切换表需要精确到像素。这套“分级派活”的哲学,是整个渲染优化的第一块基石。

errorpixel=errorworld×H2×d×tan⁡(θfov2)\displaystyle \text{error}_{\text{pixel}} = \frac{\text{error}_{\text{world}} \times H}{2 \times d \times \tan\left(\frac{\theta_{\text{fov}}}{2}\right)}
这个公式把“世界空间里的几何偏差”换算成“屏幕上的像素偏差”:偏差在屏幕上小于 1 像素时,换低模没人看得出来。
  1. 世界空间误差低模与高模在几何上的最大偏差,单位是米。好比替身演员与主角的身高差,差得越多越容易被识破。
    errorworld\text{error}_{\text{world}}
  2. 屏幕高度渲染目标的高度像素值,表示画面分辨率。分辨率越高,同样的几何偏差越容易被看见。
    HH
  3. 距离物体到摄像机的直线距离,单位米。距离越远,物体在屏幕上缩得越小,误差也就越不明显。
    dd
  4. 视场角摄像机镜头的垂直张开角度,手机拍摄约等于“从脚底到头顶”的量,常见取值 60 度左右。镜头越广,物体投影越小。
    θfov\theta_{\text{fov}}
  5. 误差合成整条公式把世界空间误差、屏幕高度、距离、视场角撮合在一起,输出“这个偏差在屏幕上占几个像素”,小于 1 就放心切低模。
    errorpixel<1  ⇒  切换LOD\text{error}_{\text{pixel}} < 1 \;\Rightarrow\; \text{切换LOD}

LOD生成算法

替身演员不能随便找个路人——至少身形和主角相近。道具组拿着主角的全身扫描模型,把多余的细节一处处削去,确保轮廓还在、标志性特征还在,但布线从十万面降到几千面。这个过程叫网格简化(mesh simplification),最经典的手法叫边折叠。

边折叠的想法很朴素:把一条边的两个端点合并成一个点,这条边两侧的两个三角形就消失了。反复执行“找到一条边、合并、删三角形”,模型面数就逐步下降。但问题来了:每次该折哪条边?折错了,主角的鼻子会被拉成一块平板。于是有了 QEM(Quadric Error Metrics,二次误差度量)算法——它为每个顶点维护一个 4×4 的二次误差矩阵 Q,折叠后新点的误差由两个顶点的矩阵相加来决定,误差最小的边优先折叠。

道具组每次“削一块”前都拿皮尺量偏差,偏差最小的先削。批量削完,就得到一套从“本尊 1:1”到“轮廓剪影”的连续替身序列。预先生成固定的几档就叫离散 LOD,运行时实时增减细节的则叫连续 LOD(如渐进网格)。

E(v)=vT(Q1+Q2)v\displaystyle E(\mathbf{v}) = \mathbf{v}^T (Q_1 + Q_2) \mathbf{v}
QEM 的直觉是:折叠后的新顶点距离“原来所有相邻平面”越近,这个折叠越安全。E 值越小,折叠越不容易破坏轮廓。
  1. 新顶点坐标折叠后生成的新顶点,用齐次坐标表示为四维列向量。它是替代两个旧顶点的新位置。
    v=(x,y,z,1)T\mathbf{v} = (x, y, z, 1)^T
  2. 二次误差矩阵每个顶点保存一个 4×4 对称矩阵,编码了“该顶点偏离相邻曲面的距离平方”信息。
    Q=∑p∈planesppTQ = \sum_{p \in \text{planes}} \mathbf{p}\mathbf{p}^T
  3. 矩阵相加折叠两个顶点时,将两个矩阵相加,作为折叠后统一的质量度量。
    Q1+Q2Q_1 + Q_2
  4. 二次型求值两边夹一个矩阵的乘法叫二次型,数学上的效果是“带权重的距离平方”。值越小,说明折叠后的顶点偏离原表面越轻微,越值得先行折叠。
    vT(Q1+Q2)v\mathbf{v}^T (Q_1 + Q_2) \mathbf{v}

HLOD层次化

开放世界片场有上万个演员,导演不可能逐一指挥每个演员的走位。他给每个片区配一个“领队”:远景时只招呼领队“你带五十人站到山丘上”,至于领队身后具体的演员怎么站,不用操心。HLOD(Hierarchical LOD,层次化细节层次)就是这种领队机制。

普通的 LOD 管的是单个物体,HLOD 管的是整组物体。构建阶段用八叉树(octree)把空间切成层级块:叶节点是单个物体的 LOD,内部节点把子节点们的几何体合并、简化成一个大网格。当这组物体足够远时,CPU 只提交这一个“超级替身”的绘制调用,而不是底下一百个分散的网格。

导演手里的“分镜调度表”就是这棵 HLOD 树:远处整片森林一个手势带过,走近了再下钻到每一棵树,甚至每一根树枝。这就是开放世界能同时渲染整座城市、帧率却稳如老狗的秘诀。

useHLOD(i)={trueif erroridi<ϵfalseotherwise\displaystyle \text{useHLOD}(i) = \begin{cases} \text{true} & \text{if } \dfrac{\text{error}_i}{d_i} < \epsilon \\[8pt] \text{false} & \text{otherwise} \end{cases}
这个判定式是导演的“领队调度规则”:只要这个片区替身的误差相对距离小到可忽略,就直接用领队,不再下钻到具体演员。
  1. 节点误差该 HLOD 节点合并网格与完整几何的最大偏差,构建时由简化算法算出。
    errori=max⁡p∥p−p′∥  (轮廓差)\text{error}_i = \max_{\mathbf{p}} \|\mathbf{p} - \mathbf{p}'\|\;\text{(轮廓差)}
  2. 距离摄像机到该节点包围球中心的距离,体现“这片区域离镜头多远”。
    di=∥ci−ccam∥d_i = \|\mathbf{c}_i - \mathbf{c}_{\text{cam}}\|
  3. 阈值引擎预设的严格程度,越小画面越精细、下钻越频繁。
    ϵ>0\epsilon > 0
  4. 判定逻辑误差远小于距离,说明“这组东西在屏幕上糊成一团也看不出毛病”,直接播报领队,省下海量提交请求。
    erroridi<ϵ\frac{\text{error}_i}{d_i} < \epsilon

视锥剔除

“这条镜头拍主角肩膀!”站在镜头后面的群演松了口气——他们不进画面,不用表演。视锥剔除(Frustum Culling)就是把这个直觉写进引擎:只渲染摄像机视野范围内的物体,镜头后面、侧面的统统跳过。

摄像机的视野范围在几何上叫视锥体(frustum),像一个被远近两个裁剪面截断的四棱锥。判断一个物体是否在视锥内,最实用的办法是用“包围体”来近似:用一个包围球或包围盒套住物体,再把这个近似体与视锥的六个平面(上、下、左、右、近、远)逐一测试。包围球测试尤其便宜——只需算一次球心到平面的距离。

导演拿着景别板给演员贴标签:镜头内的留下,镜头外的散场。在工程中,视锥剔除是性价比最高的一刀——一次平面测试能砍掉一半以上的物体,而且完全不影响画面内容。

side=n⋅p+d\displaystyle \text{side} = \mathbf{n} \cdot \mathbf{p} + d
这个式子回答“点 p 在平面哪一侧”:结果是正数在平面内侧(视锥内部),负数在外侧。对包围球来说,如果小球整体跑到某个平面外,这个物体就可以直接下班。
  1. 平面法向量指向视锥内部的方向向量,已单位化,代表“哪边算里面”。
    n=(nx,ny,nz)T\mathbf{n} = (n_x, n_y, n_z)^T
  2. 平面常数决定平面在空间中偏移原点的距离。
    dd
  3. 测试点取包围球的球心,或包围盒八个顶点之一来代表物体位置。
    p=(px,py,pz)T\mathbf{p} = (p_x, p_y, p_z)^T
  4. 剔除判定若 side 小于负的包围球半径,说明整个球都在平面外,物体被排除。
    side<−r⇒culled\text{side} < -r \Rightarrow \text{culled}

遮挡剔除

镜头对着主角拍近景,主角身后站着一位演员——他其实在画面里,却被主角的身体完全挡住,观众什么也看不见。导演摆摆手:“你站那别动,反正拍不到你。”这就是遮挡剔除(Occlusion Culling):解决“在镜头里、却被其他物体挡住”的浪费。

很多人以为物体进了视锥就一定会被渲染,其实 GPU 在光栅化之后还要做深度测试,被挡住的像素最终会被丢弃。可问题是:顶点着色、光栅化的开销已经花出去了——就像群演已经化了大浓妆站进片场,最后导演说不拍他,妆白化了。遮挡剔除的价值,就是让这些注定看不见的物体压根不上妆。

常用的方案是硬件遮挡查询:先用一个极简的深度代理(比如一面墙的包围盒)渲染一遍,然后让 GPU 回答“这个物体的包围盒有没有任何像素通过了深度测试”。如果没有,下一帧就不提交它的绘制命令。

导演的“站位表”上,每个被完全挡住的人名都画了个叉。城市街道是遮挡剔除的天堂——一堵墙挡掉半条街,一栋楼挡掉一个街区,省下的是实打实的 GPU 算力。

visible={trueif sdepth>0falseotherwise\displaystyle \text{visible} = \begin{cases} \text{true} & \text{if } s_{\text{depth}} > 0 \\[8pt] \text{false} & \text{otherwise} \end{cases}
这是 GPU 对导演的回话:只要有哪怕一个采样点通过深度测试,说明有戏,值得渲染;一个都没有,说明彻底被挡,下一帧直接休息。
  1. 深度采样数光栅化后,该物体包围盒内通过深度测试的像素采样点数量。
    sdepths_{\text{depth}}
  2. 零判定没有任何采样点通过测试,即完全被遮挡。
    sdepth=0s_{\text{depth}} = 0
  3. 可见性决策有通过就提交渲染,没有就跳过。典型用法是用上一帧的查询结果决定当前帧,用一帧的延迟换几十帧的节约。
    visible=true⇒submit draw\text{visible} = \text{true} \Rightarrow \text{submit draw}

优化综合策略

真正的片场导演不会只靠一招:开机前先清场(视锥剔除),再检查站位关系(遮挡剔除),安排近景替身细节(LOD),远景直接遥控整片群演(HLOD)。四招按顺序叠加,才组成了完整的调度系统。渲染引擎也是如此。

正确的处理顺序是:先在 CPU 侧做视锥剔除和遮挡剔除,把看不见的物体从提交列表中摘掉;再对剩余可见物体按距离挑选 LOD;最后按材质对绘制命令排序合并批次,降低状态切换次数。顺序不能反——如果先算 LOD 再剔除,等于替一群不用上场的演员化妆。

现代开放世界引擎把这套流程做成了“自动导演”:开发者只需设定目标帧率和像素误差容限,系统自动分析场景并生成配置表——哪些物体能合并、哪些需要高模、哪些区域启动物理遮挡查询。片场里最高级的导演不是嗓门最大的,而是让每个演员都恰到好处地发光的那位。

Ctotal=∑i∈Vvisible(Csubmit(i)+Craster(i))\displaystyle C_{\text{total}} = \sum_{i \in V_{\text{visible}}} \left( C_{\text{submit}}(i) + C_{\text{raster}}(i) \right)
这个公式是导演的预算表:总开销等于所有“真正上场演员”的登场费加演出费。优化的目标就是同时减少上场人数(剔除)和单人演出费(LOD)。
  1. 可见集合经过视锥与遮挡剔除后,真正需要渲染的物体索引集合。
    Vvisible={i∣inFrustum(i)∧unoccluded(i)}V_{\text{visible}} = \{i \mid \text{inFrustum}(i) \land \text{unoccluded}(i)\}
  2. 提交开销CPU 为每个物体发起一次绘制调用的固定成本,主要来自状态切换和命令提交。
    Csubmit(i)C_{\text{submit}}(i)
  3. 光栅开销GPU 填充该物体像素的实际成本,与三角形数量成正比。
    Craster(i)∝triangles(i)C_{\text{raster}}(i) \propto \text{triangles}(i)
  4. 总优化目标在保证像素误差不超限的前提下,让总开销降到帧预算以内。
    min⁡Ctotals.t.errorpixel≤1\min C_{\text{total}} \quad \text{s.t.} \quad \text{error}_{\text{pixel}} \le 1

AI 应用场景

批量资产 LOD 自动生成

阶段:离线资产生产 / 数据优化

解决的问题:手工制作 LOD 是美术管线大瓶颈。一个模型要手动减面 2 到 3 档,开放世界有上万资产,纯人力根本做不完。AI 可以基于 QEM 算法自动生成 LOD0 至 LOD3 系列模型,再让机器学习模型根据像素误差自动验证每个级别的切换距离,美术只需检查最高档位的艺术效果。

具体案例:某 3A 工作室采用“AI 减面管线”,将一套城市资产从模型扫描到四档 LOD 的产出时间从两周压缩到半天。AI 还自动发现了“门窗细节在 LOD1 就该消失、轮廓在 LOD2 就该保形”的规律,并沉淀为资产规范。

开放世界运行时动态调度

阶段:运行时渲染 / 性能优化

解决的问题:玩家在开放世界中位置不固定,固定 LOD 配置表在复杂视野下会频繁掉帧。AI 通过强化学习观察玩家视野的统计特征(俯视、平视、奔跑、静止),动态调整 HLOD 的阈值和视锥剔除的包围体精度,让帧率稳定在目标值。

具体案例:某开放世界项目在玩家登上高塔俯视全城时,自动加密遮挡查询并降低远景 LOD 精度;当玩家进入街道巷战时,自动提高近处物体的 LOD 档位。实测在相同画质下帧率提升约 35%。

数字孪生城市漫游

阶段:实时可视化 / 场景优化

解决的问题:城市级 BIM 与 GIS 数据包含数百万栋建筑,直接渲染必然卡死。通过 HLOD 将整片街区合并为一个简化网格,再叠加视锥与遮挡剔除,实现“高层俯瞰用街区模式、街道漫游切换单栋模式”的自动调度。

具体案例:某智慧城市平台接入 120 平方公里的倾斜摄影数据,利用 AI 生成的 HLOD 配置表在 Web 端实现了 60 帧的连续漫游,用户拖拽地图时几乎感受不到加载延迟。

Python 演示

python125 行
import mathimport random  class Vec3:    """极简三维向量, 仅用于演示."""    def __init__(self, x, y, z):        self.x = x        self.y = y        self.z = z     def dot(self, other):        return self.x * other.x + self.y * other.y + self.z * other.z     def add_scaled(self, other, scale):        return Vec3(            self.x + other.x * scale,            self.y + other.y * scale,            self.z + other.z * scale,        )  class FrustumPlane:    """一个平面: n*p + d = 0, n 朝视锥内部."""    def __init__(self, n, d):        self.n = n        self.d = d     def distance_to_point(self, p):        return self.n.dot(p) + self.d  class Frustum:    """用 6 个平面围成的视锥体."""    def __init__(self, planes):        self.planes = planes     def contains_sphere(self, center, radius):        for plane in self.planes:            if plane.distance_to_point(center) < -radius:                return False        return True  class Mesh:    """网格替身: 只记录三角形数量."""    def __init__(self, name, tri_count):        self.name = name        self.tri_count = tri_count  class SceneObject:    """场景物体: 持有 LOD0 到 LOD3 四档替身."""    def __init__(self, obj_id, center, radius, lods):        self.obj_id = obj_id        self.center = center        self.radius = radius        self.lods = lods     def pick_lod(self, distance):        if distance < 20:            return self.lods[0]        if distance < 60:            return self.lods[1]        if distance < 120:            return self.lods[2]        return self.lods[3]  def build_demo_scene(num_objects=200):    """随机生成场景: 物体散布在 200x200 区域."""    random.seed(42)    scene = []    for i in range(num_objects):        cx = random.uniform(-100, 100)        cz = random.uniform(-100, 100)        radius = random.uniform(1, 3)        lods = [            Mesh("建筑_高模", 20000),            Mesh("建筑_中模", 5000),            Mesh("建筑_低模", 1200),            Mesh("建筑_剪影", 150),        ]        scene.append(SceneObject(i, Vec3(cx, 0, cz), radius, lods))    return scene  def main():    inv_sqrt2 = 1.0 / math.sqrt(2.0)    planes = [        FrustumPlane(Vec3(0, 0, 1), -5),        FrustumPlane(Vec3(0, 0, -1), 200),        FrustumPlane(Vec3(-inv_sqrt2, 0, inv_sqrt2), 0),        FrustumPlane(Vec3(inv_sqrt2, 0, inv_sqrt2), 0),        FrustumPlane(Vec3(0, -inv_sqrt2, inv_sqrt2), 2 * inv_sqrt2),        FrustumPlane(Vec3(0, inv_sqrt2, inv_sqrt2), -2 * inv_sqrt2),    ]    frustum = Frustum(planes)    camera = Vec3(0, 2, -40)    scene = build_demo_scene()     visible_objs = []    total_triangles = 0    for obj in scene:        # 第一步: 视锥剔除, 不在视野内的直接跳过        if not frustum.contains_sphere(obj.center, obj.radius):            continue        dist = (obj.center.add_scaled(camera, -1)).length()        lod = obj.pick_lod(dist)        visible_objs.append((obj.obj_id, lod.name, lod.tri_count))        total_triangles += lod.tri_count     draw_calls = len(visible_objs)    full_cost = len(scene) * 20000    print(f"场景物体总数: {len(scene)}")    print(f"视锥剔除后可见: {draw_calls}")    print(f"经过 LOD 后的三角形总数: {total_triangles}")    print(f"未优化时三角形总数(预估): {full_cost}")    print(f"节省: {(1 - total_triangles / full_cost) * 100:.1f}%")    for obj_id, lod_name, tris in visible_objs[:8]:        print(f"  可见物体 #{obj_id}: 使用{lod_name}, {tris} 三角形")  if __name__ == "__main__":    main()
目的:完整演示了“视锥剔除 + 距离选 LOD”的经典管线,统计优化前后的三角形数量与绘制调用,展示渲染优化带来的数量级收益。
  1. def contains_sphere(self, center, radius):包围球与六个平面的测试入口,一个球被任何平面排除即整体不可见。
  2. if plane.distance_to_point(center) < -radius:球心在平面外侧且距离超过半径,说明整个球都滚出了视锥。
  3. def pick_lod(self, distance):根据距离查“景别表”,返回对应档位替身。
  4. if distance < 20:导演的“特写区”:20 米内的物体必须用最高模。
  5. if not frustum.contains_sphere(obj.center, obj.radius):先剔除再选 LOD,顺序不能反。
  6. lod = obj.pick_lod(dist)只有确定“要上场”的演员才去挑替身。
  7. total_triangles += lod.tri_count累加最终提交的三角形数,这是 GPU 真正要扛的负荷。
  8. full_cost = len(scene) * 20000设想一个不做任何优化的“全员皆主角”方案,作为对比基准。

常见误区

误区以为 LOD 就是美术用建模软件导出几个低模,引擎加载后自己会选,程序员不用管。

正解LOD0/LOD1/LOD2 只是“替身演员”的库存,真正的 LOD 系统是引擎里的调度逻辑:包括距离判定、像素误差阈值、切换迟滞(防止频繁抖动)、以及填充率预算。美术负责造替身,引擎工程师负责在何时何地派谁上场。缺了引擎侧的调参,再好的替身也只会造成画面闪烁。

为何常见:所见即所得的美术流程中,美术接触不到运行时的“切换”动作,误以为模型做出来就完事了。

误区既然物体已经被视锥筛选过一轮,剩下的都该渲染,遮挡剔除只是锦上添花甚至浪费性能。

正解视锥内的物体可能被墙、山体、其他建筑挡得严严实实。城市街道场景中,视锥内经常有 70% 的物体被遮挡。没有遮挡剔除,这些“看不见的演员”会全部走一遍顶点着色和光栅化,白白烧掉 GPU。遮挡查询的开销远远小于它省下的渲染开销。

为何常见:初学者调试时只看到视锥线框,没打开深度可视化,感受不到被挡物体的实际渲染代价。

误区切换 LOD 时模型轮廓突然变化,玩家觉得这是程序员的锅,应该彻底消除。

正解这是质量与性能的权衡。完全无突变的统一高精度渲染,GPU 扛不住。成熟方案会用淡入淡出(dither)或几何过渡把突变模糊掉,但引擎的目标从来不是零突变,而是把突变控制在人眼察觉阈值内(小于 1 像素误差)。

为何常见:玩家视角看到模型“跳了一下”非常直观刺眼,而看不到背后每帧节省的数百万三角形。

误区GPU 遮挡查询要等结果,同步等待时 GPU 空转,帧率反而下降,所以干脆不用。

正解查询确实有开销,但成熟的引擎不会傻等——要么用上一帧的深度缓冲做软件遮挡预判,要么把查询结果延迟一帧使用。一次查询省下的是成百上千个绘制调用,收益远大于开销。很多新手在自研引擎里直接同步回读 glGetQueryObject,帧率暴跌,于是得出“遮挡剔除没用”的谬论。

为何常见:把“错误的同步用法”当成了“技术本身有缺陷”,忽略了两帧流水线化的工程智慧。

误区以为 HLOD 只是把多个物体的 LOD 放进同一个父节点,和普通场景树的加速没有本质区别。

正解HLOD 的关键在“合并 + 简化”:父节点不是包围盒,而是对整组几何体做真实的网格减面,生成一个大低模。远处时一个父网格替代几百个物体,绘制调用从几百骤降到一次。这要用到空间层次(八叉树/BVH)与网格简化算法的联合设计,远不止“堆叠”那么简单。

为何常见:名字里带 LOD,容易被字面理解成“LOD 的集合”,看不到“层次化合并 + 简化”这一层本质。

面试题

Q1. 关于 LOD 核心目标,下列说法正确的是?

单选题 · easy

  • A.提高所有模型的精度
  • B.保持观感并减少三角形数← 正确答案
  • C.消除所有渲染误差
  • D.用高模替换屏幕上的低模

答案:B。LOD 的目标是在人眼可接受的质量下减少三角形数,就像导演让远景群演用替身,观众察觉不到差别却省了大量成本。A 说反了,C 是理想化不可达,D 会让性能更差。

Q2. 视锥剔除主要解决哪类问题?

单选题 · easy

  • A.物体被其他物体挡住
  • B.物体不在摄像机视野内← 正确答案
  • C.物体离摄像机距离太远
  • D.物体重叠导致的画面闪烁

答案:B。视锥剔除解决“镜头拍不到”的问题,对应导演让镜头外的群演散场。A 是遮挡剔除的职责,C 是 LOD 的职责,D 与剔除无关。

Q3. 下列哪些属于剔除优化的类型?

多选题 · easy

  • A.视锥剔除← 正确答案
  • B.遮挡剔除← 正确答案
  • C.背面剔除← 正确答案
  • D.阴影剔除

答案:ABC。视锥剔除去掉镜头外物体,遮挡剔除去掉被挡住物体,背面剔除去掉法线背向相机的三角形面,三者都是剔除。阴影剔除不是渲染管线中的标准剔除类型,别被骗了——阴影通常用阴影贴图技术,而非“剔除”。

Q4. LOD 中“像素误差”的含义是?

单选题 · mid

  • A.物体在屏幕上投影的误差← 正确答案
  • B.模型贴图分辨率差异误差
  • C.世界坐标系顶点位置误差
  • D.显示器像素间距产生的误差

答案:A。像素误差指简化模型相对完整模型的几何偏差折算到屏幕上的像素数。和贴图分辨率、显示器硬件无关。它统一了“空间距离”和“视觉感受”两个维度,是 LOD 切换的核心度量。

Q5. 下列哪些 LOD 生成技术属于网格简化方法?

多选题 · mid

  • A.边折叠网格简化算法← 正确答案
  • B.顶点聚类合并算法← 正确答案
  • C.法线贴图纹理烘焙
  • D.二次误差矩阵度量← 正确答案

答案:ABD。边折叠、顶点聚类、QEM 都是几何层面的网格简化手段。法线贴图烘焙是把高模细节“画”到低模上,不减少三角形数量,属于贴图技术而非几何简化。

Q6. HLOD 相比普通 LOD 的最大优势是?

单选题 · mid

  • A.每个物体独立选择自身 LOD
  • B.整组物体合并为一个简化网格← 正确答案
  • C.提高单个物体制作的精度
  • D.加快场景中纹理资源的加载

答案:B。HLOD 是“片区领队”机制,把整组物体合并简化成一个网格,绘制调用从几百骤降到一次。A 恰恰是普通 LOD 的特征,C、D 与 HLOD 的核心目标无关。

Q7. 包围球视锥测试中,球被剔除的充分条件是?

单选题 · mid

  • A.球心位于视锥体内部
  • B.球体与视锥边界相交
  • C.某平面外侧距球心超半径← 正确答案
  • D.球半径超过视锥体边长

答案:C。只要球心到任意一个平面的外侧距离大于球半径,整个球就完全在视锥外,可以剔除。球心在内部或与边界相交都说明物体可能可见;半径超过视锥边长本身不构成剔除条件。

Q8. 硬件遮挡查询的典型用法是?

单选题 · hard

  • A.同步回读查询结果并立即渲染
  • B.用上一帧查询结果决定当前帧← 正确答案
  • C.每帧在 CPU 端做光线发射测试
  • D.关闭深度测试来加速遮挡查询

答案:B。GPU 查询结果回读很慢,同步等待会导致 GPU 空转。成熟引擎采用“延迟一帧”策略:用上一帧的查询结果决定当前帧是否渲染。关闭深度测试会让遮挡查询失去意义,CPU 光线投射是软件方案而非硬件查询。

Q9. 开放场景中降低绘制调用数量的有效组合策略包含?

多选题 · hard

  • A.视锥剔除不渲染视野外物体← 正确答案
  • B.遮挡剔除剔除被遮挡的物体← 正确答案
  • C.HLOD 合并远景物体组← 正确答案
  • D.提高相机 FOV 来扩大可见视野

答案:ABC。视锥和遮挡剔除减少“上场的演员数”,HLOD 把整组演员合并成一个替身,三者都是降低绘制调用的正道。D 扩大 FOV 反而让更多物体进入视野,增加绘制调用。

Q10. QEM 边折叠中,二次误差矩阵的数学本质是?

单选题 · extreme

  • A.顶点颜色误差的加权和
  • B.邻接平面距离平方加权和← 正确答案
  • C.顶点法线方向的平均偏差
  • D.三角形面积变化的总和

答案:B。QEM 把顶点折叠的误差建模为“新顶点到所有相邻平面距离的平方和”,平面越远误差越大,折叠越不安全。它只管几何位置偏差,与颜色、法线方向、面积变化无关。这个度量让边折叠能从“最安全”的边开始,保住模型轮廓。