第12章：游戏行业Mesh要求

LOD0: 100% 顶点 (0-50米)
LOD1: 50%  顶点 (50-100米)
LOD2: 25%  顶点 (100-200米)
LOD3: 10%  顶点 (200-500米)
LOD4: Billboard (500米+)

算法流程：

1. 计算每条边的折叠代价
2. 选择代价最小的边进行折叠
3. 更新受影响边的代价
4. 重复直到达到目标顶点数

     原始mesh           聚类网格          简化结果

    *---*---*          +---+---+         *-------*
    |\ /|\ /|          |   |   |         |\     /|
    | * | * |    =>    | * | * |   =>    | \   / |
    |/ \|/ \|          |   |   |         |  \ /  |
    *---*---*          +---+---+         *---*---*

if (distance < 50)
    使用 LOD0
else if (distance < 100)
    使用 LOD1
else if (distance < 200)
    使用 LOD2
...

过渡区间: [45米, 55米]
alpha = (distance - 45) / 10
渲染 LOD0 with alpha = 1 - alpha
渲染 LOD1 with alpha = alpha

// 顶点着色器
uniform float morphFactor; // 0到1的过渡因子
attribute vec3 position_LOD0;
attribute vec3 position_LOD1;

void main() {
    vec3 morphedPos = mix(position_LOD0, position_LOD1, morphFactor);
    gl_Position = mvpMatrix * vec4(morphedPos, 1.0);
}

场景层次结构：
         建筑群组 (HLOD)
        /    |    \
    建筑A  建筑B  建筑C
    /  \    /  \    /  \
  LOD0 LOD1 LOD0 LOD1 LOD0 LOD1

简单碰撞体 (最快)
├── 球体 (Sphere)
├── 盒体 (Box/AABB/OBB)
├── 胶囊体 (Capsule)
└── 圆柱体 (Cylinder)

复合碰撞体 (中等)
├── 多个简单体组合
└── 凸包集合

网格碰撞体 (最慢)
├── 凸网格 (Convex Mesh)
└── 三角网格 (Triangle Mesh)

算法步骤：

1. 找到极值点构成初始四面体
2. 对每个面，找到距离最远的点
3. 如果距离大于阈值，创建新的面
4. 删除被遮挡的旧面
5. 重复直到没有点在凸包外

     凹形mesh          凸分解结果

    *---*---*         *---*   *---*
    |   U   |   =>    |   |   |   |
    *-*   *-*         *-* |   | *-*

    *-*   *-*         *-* |   | *-*
      |   |             | |   | |

      *---*             *-*   *-*

   (一个凹形)        (两个凸形)

近距离交互：精确凸分解（8-12个凸体）
中距离检测：简化凸包（2-4个凸体）
远距离剔除：单个AABB或球体

高度图数据：
h[i][j] = 地形在(i,j)处的高度

碰撞检测：
给定位置(x,z)，通过双线性插值获取高度y

BSP节点结构：
struct BSPNode {
    Plane splitPlane;
    BSPNode* front;
    BSPNode* back;
    vector<Triangle> triangles; // 叶节点
}

每帧渲染流程：
CPU端：
  for each object:
    设置材质参数
    设置变换矩阵
    绑定纹理
    发送Draw Call  <- 瓶颈！

GPU端：
  执行所有Draw Call的渲染

批处理前：                批处理后：
Object1 -> DrawCall1     
Object2 -> DrawCall2  =>  BatchedMesh -> DrawCall1
Object3 -> DrawCall3     

内存使用 = 原始顶点数 × 批次中的物体数
例：1000顶点的树 × 100个实例 = 100,000顶点

每帧开销 = 排序时间 + 合并时间
适用场景：大量小物体（如粒子、弹孔、碎片）

// 顶点着色器
attribute mat4 instanceMatrix;  // 每实例数据
attribute vec4 instanceColor;

void main() {
    gl_Position = projMatrix * viewMatrix * instanceMatrix * position;
    vColor = instanceColor;
}

VertexBuffer: [mesh顶点数据]
InstanceBuffer: [
    实例0: {transform, color, custom_data},
    实例1: {transform, color, custom_data},
    ...
]

空间划分网格：
┌───┬───┬───┐
│ A │ B │ C │  每个格子内的物体合并
├───┼───┼───┤  格子大小：视锥体剔除粒度
│ D │ E │ F │  
├───┼───┼───┤
│ G │ H │ I │
└───┴───┴───┘

材质图集（Texture Atlas）：
┌─────┬─────┐
│ Mat1│ Mat2│  多个材质合并到一张纹理
├─────┼─────┤  UV坐标重新映射
│ Mat3│ Mat4│  
└─────┴─────┘

CPU端：
  准备所有物体数据
  发送单个IndirectDraw命令

GPU端：
  视锥剔除
  遮挡剔除
  LOD选择
  生成DrawCall参数
  执行渲染

网格顶点 -> 蒙皮权重 -> 骨骼

顶点数据结构：
struct SkinnedVertex {
    vec3 position;
    vec3 normal;
    vec2 uv;
    ivec4 boneIndices;  // 最多4根骨骼影响
    vec4 boneWeights;   // 对应权重，和为1
}

    根骨骼 (Root)
    /    \
  骨盆    脊椎
  /  \      |
腿L  腿R   胸部
           /  \
        臂L    臂R

肘部横截面：

  糟糕的拓扑：          良好的拓扑：
  *---*---*            *-*-*-*-*
  |   |   |            |||||||||
  *---*---*            *-*-*-*-*
  (变形会出现褶皱)      (平滑弯曲)

避免：              推荐：
  *---*---*          *---*---*
  |   |   |          |\ /|\ /|
  *---*              | * | * |
  |   |              |/ \|/ \|
  *---*              *---*---*

骨骼A影响区 -> 过渡区 -> 骨骼B影响区
   1.0      0.75  0.5  0.25    0.0    (骨骼A权重)
   0.0      0.25  0.5  0.75    1.0    (骨骼B权重)

LOD0 (近距离): 完整骨骼 (60+骨骼)
LOD1 (中距离): 主要骨骼 (30骨骼)
LOD2 (远距离): 核心骨骼 (15骨骼)
LOD3 (超远):   刚体替代

// 顶点着色器
uniform mat4 boneMatrices[MAX_BONES];

vec4 skinnedPos = vec4(0.0);
for(int i = 0; i < 4; i++) {
    skinnedPos += boneWeights[i] * 
                  boneMatrices[boneIndices[i]] * 
                  vec4(position, 1.0);
}

网格密度：10-20cm每个四边形
拓扑要求：规则四边形网格
约束边：固定点、缝合线

关键区域边环：

- 眼部：放射状边环
- 嘴部：环形边环
- 鼻唇沟：对角边环

顶点处理能力：100-200万顶点/帧
像素填充率：2-4 Gpixels/s
内存带宽：10-30 GB/s
纹理单元：8-16个

PC格式：                移动格式：
position: float3 (12B)  position: half3 (6B)
normal: float3 (12B)    normal: int10_3 (4B)
uv: float2 (8B)        uv: half2 (4B)
tangent: float4 (16B)   tangent: int10_3 (4B)
总计: 48B/顶点          总计: 18B/顶点

使用16位索引而非32位：

- 最多65536个顶点per mesh
- 节省50%索引缓冲内存
- 需要大mesh分割

iOS设备：

- PVRTC (2-4 bpp)
- ASTC (可变比特率)

Android设备：

- ETC2 (4-8 bpp)
- ASTC (推荐)

减少纹理切换：
独立纹理 -> Draw Call多
纹理图集 -> Draw Call少

图集大小限制：

- 低端设备：1024×1024
- 中端设备：2048×2048
- 高端设备：4096×4096

precision mediump float;  // 移动平台默认
precision lowp float;     // 颜色计算
precision highp float;    // 位置计算

// 避免的操作：

- 复杂数学函数 (sin, cos, pow)
- 动态分支
- 依赖纹理读取

功能开关：
#ifdef USE_NORMAL_MAP
#ifdef USE_SPECULAR
#ifdef USE_FOG

变体数量控制：< 100个

典型移动游戏内存分配：
总内存：2-4GB
游戏可用：1-2GB
  纹理：400-600MB
  Mesh：100-200MB  <- 严格限制
  音频：100-150MB
  其他：400-600MB

场景分块：

- 核心资源常驻
- 按需加载周边
- 及时卸载远处

LOD内存管理：
仅保留当前需要的LOD级别

温度监控：
< 35°C: 全速运行
35-40°C: 降低10% 频率
40-45°C: 降低25% 频率
> 45°C: 降低50% 频率

自适应质量：

- 动态调整渲染分辨率
- 减少后处理效果
- 降低LOD阈值

传统管线：
Source Mesh -> LODs -> Render

Nanite管线：
Source Mesh -> Cluster Hierarchy -> Virtual Texturing -> Render

Mesh划分为128三角形的集群
构建BVH树进行层次剔除
运行时选择合适的集群级别

集群大小选择：

- 太小：剔除开销大
- 太大：过度绘制多
- 最优：128个三角形

规则定义：
F -> F[+F]F[-F]F
其中：
F = 前进并画线

+ = 右转
- = 左转
[ = 保存状态
] = 恢复状态

1. 定义瓦片及其连接规则
2. 从种子位置开始
3. 根据约束传播可能性
4. 塌缩到具体瓦片
5. 生成对应几何

Houdini节点图 -> 
参数化资产 ->
引擎运行时生成 ->
优化后的游戏mesh

基础mesh (立即加载)
├── 细节层1 (延迟100ms)
├── 细节层2 (延迟500ms)
└── 细节层3 (按需加载)

玩家位置预测：

- 基于移动方向
- 基于视线方向
- 基于历史路径

预加载策略：
半径R内：全部加载
半径2R内：加载LOD0-1
半径3R内：仅加载LOD0

照片采集 -> 
点云生成 ->
网格重建 ->
游戏优化 ->
LOD生成