目录
什么是 glTF？
glTF 文件结构与数据组织
缓冲区系统：高效的二进制数据存储
使用 tinygltf 库实现高效解析
实现健壮的 glTF 加载器
理解基于物理的渲染（PBR）材质
材质系统的演进
PBR 材质核心属性
纹理格式与压缩
glTF/glb 中的嵌入式纹理
纹理加载：遍历 glTF 纹理并提取元数据
纹理加载：格式检测与缓冲区访问
纹理加载：KTX2 解析与验证
纹理加载：Basis Universal 转码
纹理加载：Vulkan 资源创建与 GPU 上传
理解场景图与层级变换
场景图的重要性
场景图中的变换
理解 3D 几何与网格数据
3D 模型的组成单元
glTF 中的网格组织
理解动画系统
3D 图形中的动画技术
动画核心概念
glTF 动画系统
与渲染管线的集成
从资源加载到渲染的流程
渲染优化
内存管理考量
基于 KTX2 和 Basis Universal 的高效纹理内存管理
与 Vulkan 渲染管线的集成
纹理内存管理最佳实践
总结与下一步
什么是 glTF？
glTF（GL Transmission Format，GL 传输格式）是由 Khronos 集团（OpenGL 和 Vulkan 的研发机构）制定的标准 3D 文件格式。它常被称作 “3D 领域的 JPEG”，旨在成为通用、高效的 3D 内容交换格式。
glTF 的核心目标是打通 3D 内容创作工具（如 Blender、Maya、3ds Max）与游戏、可视化工具等实时渲染应用之间的壁垒。在 glTF 出现之前，开发者往往需要编写自定义导出器，或使用未针对实时渲染优化的中间格式。
glTF 的核心优势包括：
- 高效性（Efficiency）：针对加载速度和渲染性能优化，需处理的额外计算最少
- 完整性（Completeness）：单一格式整合几何、材质、纹理、动画、场景层级等所有数据
- PBR 支持（PBR Support）：原生支持现代基于物理的渲染（PBR）材质
- 标准化（Standardization）：行业广泛采用，减少自定义导出器的开发需求
- 可扩展性（Extensibility）：支持厂商专属特性扩展，同时保持核心兼容性
glTF 文件结构与数据组织
glTF 文件包含多个结构化组织的核心组件：
- 场景与节点（Scenes and Nodes）：构建场景图的层级结构，用于组织场景中的对象
- 网格（Meshes）：3D 几何数据（顶点、索引、法线、UV 等属性）
- 材质（Materials）：基于物理的渲染（PBR）模型定义的表面属性
- 纹理与图像（Textures and Images）：材质用视觉数据，支持多种纹理类型
- 动画（Animations）：用于驱动节点动画的关键帧数据（位置、旋转、缩放）
- 蒙皮（Skins）：骨骼动画相关数据（关节层级、顶点权重）
- 相机（Cameras）：透视或正交相机的定义
缓冲区系统：高效的二进制数据存储
glTF 最强大的特性之一是其三级缓冲区系统：
- 缓冲区（Buffers）：原始二进制数据块（类似磁盘上的文件）
- 缓冲区视图（BufferViews）：指向缓冲区中特定偏移和长度的视图
- 访问器（Accessors）：描述如何解析 bufferView 中的数据（类型、组件类型、数量等）
该系统允许不同属性（位置、法线、UV）共享同一个底层缓冲区，降低内存占用和文件体积。例如：
- 单个缓冲区可存储所有顶点数据
- 一个 bufferView 指向缓冲区中的位置数据
- 另一个 bufferView 指向法线数据
- 访问器定义如何解析每个 bufferView（如解析为 vec3 浮点型数据）
使用 tinygltf 库实现高效解析
从头编写 glTF 解析器工程量巨大，因此我们选择使用 tinygltf 库：
- 轻量级、仅头文件的 C++ 库，易于集成
- 透明支持 .gltf 和 .glb 两种格式
- 处理 JSON 和二进制数据解析的复杂逻辑
- 提供简洁的 API 访问所有 glTF 组件
- 处理缓冲区系统细节（包括 base64 编码数据）
使用 tinygltf 能让我们专注于将解析后的数据转换为引擎内部结构，而非处理 JSON 和二进制数据解析的底层细节。
实现健壮的 glTF 加载器
实现生产级别的 glTF 加载器时，需考虑以下要点：
- 错误处理（Error Handling）：健壮处理格式错误的文件，实现优雅的失败机制
- 格式检测（Format Detection）：同时支持 .gltf 和 .glb 格式
- 内存管理（Memory Management）：高效分配和处理大容量数据
- 扩展支持（Extension Support）：处理可选的 glTF 扩展
以下是文件加载的基础实现：
void loadModel(const std::string& modelPath) {
// 创建 tinygltf 加载器
tinygltf::Model gltfModel;
tinygltf::TinyGLTF loader;
std::string err, warn;
// 检测文件扩展名，选择对应的加载方式
bool ret = false;
std::string extension = modelPath.substr(modelPath.find_last_of(".") + 1);
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
if (extension == "glb") {
ret = loader.LoadBinaryFromFile(&gltfModel, &err, &warn, modelPath);
} else if (extension == "gltf") {
ret = loader.LoadASCIIFromFile(&gltfModel, &err, &warn, modelPath);
} else {
err = "Unsupported file extension: " + extension + ". Expected .gltf or .glb";
}
// 处理警告和错误
if (!warn.empty()) {
std::cout << "glTF warning: " << warn << std::endl;
}
if (!err.empty()) {
std::cout << "glTF error: " << err << std::endl;
}
if (!ret) {
throw std::runtime_error("Failed to load glTF model");
}
// 清空现有模型数据
model = Model();
// 处理加载的数据（后续章节详细讲解）
}
同时支持 .gltf 和 .glb 格式，能为美术人员的工作流提供灵活性。
glTF 包含两种格式，各有优势：
- .gltf：基于 JSON 的格式，引用外部二进制和图像文件
- 人类可读，便于调试
- 资源管理更便捷（纹理作为独立文件）
- 更适合开发阶段的工作流
- .glb：二进制格式，将所有数据整合到单个文件中
- 体积更紧凑，分发效率更高
- 减少加载时的文件操作次数
- 更适合部署和分发
理解基于物理的渲染（PBR）材质
本节简要介绍与 glTF 加载相关的 PBR 材质知识。如需深入了解 PBR 概念和光照模型，请参考《光照与材质》章节中的 “基于物理的渲染” 部分。
材质定义了表面在渲染时的视觉表现。现代游戏和引擎采用基于物理的渲染（PBR）技术，该技术基于物理原理模拟光线与真实世界材质的交互方式。
材质系统的演进
3D 图形中的材质系统经历了显著演进：
- 基础材质（1990 年代）：简单的漫反射颜色，可选镜面高光
- 多纹理材质（2000 年代）：组合多张纹理实现不同效果
- 基于着色器的材质（2000 年代后期）：通过自定义着色器程序实现高级效果
- 基于物理的渲染（2010 年代）：基于真实世界表面物理属性的材质
PBR 代表了实时图形学的当前最高水平。它能在不同光照条件下呈现更真实的效果，且确保在任意环境中外观一致。
PBR 材质核心属性
glTF 中的 PBR 模型基于 “金属度 – 粗糙度” 工作流，包含以下核心属性：
- 基础颜色（Base Color）：表面的反照率 / 漫反射颜色（RGB 或纹理）
- 金属度（Metalness）：表面的金属特性（0.0 = 非金属，1.0 = 金属）
- 金属无漫反射，但有强镜面反射
- 非金属（电介质）有漫反射，镜面反射极弱
- 粗糙度（Roughness）：表面的光滑 / 粗糙程度（0.0 = 镜面，1.0 = 完全粗糙）
- 控制导致光线散射的微表面细节
- 影响反射和镜面高光的锐利度
- 法线贴图（Normal Map）：无需额外几何面即可增加表面细节
- 扰动表面法线，营造更多细节的视觉效果
- 比添加实际几何面更高效
- 遮挡贴图（Occlusion Map）：模拟表面缝隙中的自阴影效果
- 暗化接收环境光较少的区域
- 增强深度和细节的感知
- 自发光（Emissive）：使表面发光（RGB 或纹理）
- 用于屏幕、灯光、霓虹灯等发光物体
- 不受场景光照影响
这些属性可设置为常量值，或通过纹理贴图实现表面的空间变化。后续章节将详细讲解 PBR 的实现细节。
纹理格式与压缩
在我们的引擎中，纹理采用基于 Basis Universal 压缩的 KTX2 格式，该方案具备以下优势：
- 减小文件体积：Basis Universal 压缩在保持视觉质量的同时大幅降低纹理体积
- GPU 就绪格式：KTX2 纹理可直接转码为平台专属的 GPU 格式
- 跨平台兼容性：Basis Universal 纹理适配不同平台和图形 API
- 多级渐远纹理（Mipmap）支持：KTX2 原生支持 mipmap，提升渲染质量和性能
glTF/glb 中的嵌入式纹理
glTF 格式支持两种纹理包含方式：
- 外部引用：.gltf 文件引用外部图像文件
- 嵌入式数据：图像以二进制数据形式直接嵌入 .glb 文件
我们的引擎采用嵌入 KTX2 纹理的 .glb 格式，该方案：
- 减少加载时的文件操作次数
- 确保所有纹理与模型始终配套可用
- 简化资源管理和分发流程
glTF 规范通过图像对象的 bufferView 属性支持嵌入式纹理。使用 KTX2 纹理时，mimeType 会设置为 "image/ktx2" 以标识格式。
纹理加载流程包含多个复杂步骤，需打通 glTF 抽象纹理引用与 Vulkan 底层 GPU 资源之间的链路。
纹理加载：遍历 glTF 纹理并提取元数据
首先遍历 glTF 模型的纹理定义，提取定位和识别每个纹理资源所需的基础信息：
// 首先加载模型中的所有纹理
std::vector<Texture> textures;
for (size_t i = 0; i < gltfModel.textures.size(); i++) {
const auto& texture = gltfModel.textures[i];
const auto& image = gltfModel.images[texture.source];
Texture tex;
tex.name = image.name.empty() ? "texture_" + std::to_string(i) : image.name;
glTF 纹理系统采用间接引用设计：纹理引用图像，图像包含实际像素数据或其引用。这种分离设计允许多个纹理共享同一图像数据，但使用不同的采样参数（如不同的过滤或环绕模式）。我们的遍历流程会构建所有纹理资源的完整清单，供材质后续引用。
命名策略为调试和资源管理提供了关键支撑。美术人员在 3D 软件中创建纹理时设置的有意义名称，能帮助开发者在开发过程中快速识别纹理用途；兜底命名方案则确保即便美术人员未提供描述性名称，每个纹理仍有唯一标识符。
纹理加载：格式检测与缓冲区访问
接下来判断纹理是否嵌入 glTF 文件，并识别其格式，为后续加载策略奠定基础：
// 检查图像是否以 KTX2 格式嵌入
if (image.mimeType == "image/ktx2" && image.bufferView >= 0) {
// 获取包含 KTX2 数据的缓冲区视图
const auto& bufferView = gltfModel.bufferViews[image.bufferView];
const auto& buffer = gltfModel.buffers[bufferView.buffer];
// 从缓冲区提取 KTX2 数据
const uint8_t* ktx2Data = buffer.data.data() + bufferView.byteOffset;
size_t ktx2Size = bufferView.byteLength;
MIME 类型检测确保我们处理的是特定的 KTX2 格式 —— 相比 PNG、JPEG 等传统图像格式，KTX2 专为 GPU 纹理设计，支持 Basis Universal 压缩、多级 mipmap、直接兼容 GPU 格式等高级特性。bufferView 检查则确认图像数据嵌入在 glTF 文件中，而非外部引用。
缓冲区访问模式体现了 glTF 精巧的数据组织体系：我们无需复制数据，而是直接获取加载后的 glTF 缓冲区中 KTX2 数据的指针。该方式最大限度减少内存占用，避免昂贵的复制操作，这在处理动辄数百 MB 的大型纹理数据集时尤为重要。
纹理加载：KTX2 解析与验证
使用专业的 KTX-Software 库加载 KTX2 纹理数据，并执行初始验证，确保纹理数据可用：
// 使用 KTX-Software 库加载 KTX2 纹理
ktxTexture2* ktxTexture = nullptr;
KTX_error_code result = ktxTexture2_CreateFromMemory(
ktx2Data, ktx2Size,
KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
&ktxTexture
);
if (result != KTX_SUCCESS) {
std::cerr << "Failed to load KTX2 texture: " << ktxErrorString(result) << std::endl;
continue;
}
KTX-Software 库提供对复杂 KTX2 格式的健壮解析能力，处理多级 mipmap、多种像素格式、元数据等细节 —— 这些细节若从零实现，复杂度极高。KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT 标志指示库立即将实际像素数据加载到内存中，为后续处理步骤做准备。
此阶段的错误处理至关重要：纹理文件可能在资源管线处理或文件传输过程中损坏。当某个纹理加载失败时继续处理下一个纹理，可避免单个有问题的纹理导致整个模型加载失败。这种优雅降级的设计是生产级系统的核心要求 —— 内容问题不应导致应用崩溃。
纹理加载：Basis Universal 转码
处理 Basis Universal 压缩纹理的转码流程，将其转换为 GPU 原生格式，以实现最优运行时性能：
// 若纹理使用 Basis Universal 压缩，将其转码为 GPU 友好格式
if (ktxTexture->isCompressed && ktxTexture2_NeedsTranscoding(ktxTexture)) {
// 根据 GPU 能力选择合适的格式
ktx_transcode_fmt_e transcodeFmt = KTX_TTF_BC7_RGBA;
// 针对不支持 BC7 的设备，使用替代格式
// if (!deviceSupportsBC7) {
// transcodeFmt = KTX_TTF_ASTC_4x4_RGBA;
// }
// if (!deviceSupportsASTC) {
// transcodeFmt = KTX_TTF_ETC2_RGBA;
// }
// 转码纹理
result = ktxTexture2_TranscodeBasis(ktxTexture, transcodeFmt, 0);
if (result != KTX_SUCCESS) {
std::cerr << "Failed to transcode KTX2 texture: " << ktxErrorString(result) << std::endl;
ktxTexture2_Destroy(ktxTexture);
continue;
}
}
Basis Universal 是纹理压缩领域的革命性方案，解决了跨平台开发的核心问题：不同 GPU 支持不同的纹理压缩格式。传统方案需为不同平台存储多份纹理，大幅增加存储需求；而 Basis Universal 将纹理存储为中间格式，加载时可快速转码为任意 GPU 原生格式。
格式选择逻辑（注释部分）展示了生产级系统如何处理 GPU 能力差异：桌面 GPU 通常支持画质极佳的 BC7 压缩，而移动 GPU 多使用 ASTC 或 ETC2 格式。转码流程在运行时基于目标 GPU 的实际能力执行，确保在所有平台上都能获得最优性能和画质。
转码操作本身计算量较大，但仅在资源加载阶段执行一次。相比未压缩纹理，转码后的 GPU 原生格式在渲染阶段性能显著提升，因此前期的转码开销是值得的。转码失败时会清理部分处理的资源，避免错误场景下的内存泄漏。
纹理加载：Vulkan 资源创建与 GPU 上传
最后创建 GPU 渲染所需的 Vulkan 资源，并将处理后的纹理数据上传至显存：
// 创建 Vulkan 图像、内存和视图
vk::Format format = static_cast<vk::Format>(ktxTexture2_GetVkFormat(ktxTexture));
vk::Extent3D extent{
static_cast<uint32_t>(ktxTexture->baseWidth),
static_cast<uint32_t>(ktxTexture->baseHeight),
static_cast<uint32_t>(ktxTexture->baseDepth)
};
uint32_t mipLevels = ktxTexture->numLevels;
// 创建 Vulkan 图像
vk::ImageCreateInfo imageCreateInfo{
.imageType = vk::ImageType::e2D,
.format = format,
.extent = extent,
.mipLevels = mipLevels,
.arrayLayers = 1,
.samples = vk::SampleCountFlagBits::e1,
.tiling = vk::ImageTiling::eOptimal,
.usage = vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eTransferDst,
.sharingMode = vk::SharingMode::eExclusive,
.initialLayout = vk::ImageLayout::eUndefined
};
// 创建图像、分配内存并绑定（为简洁起见，省略部分代码）
// …
// 将纹理数据上传至图像
ktxTexture2_VkUploadEx(ktxTexture, &ktxVulkanTexture, &vkDevice, &vkQueue,
&ktxVulkanDeviceMemory, &ktxVulkanImage,
&ktxVulkanImageView, &ktxVulkanImageLayout,
&ktxVulkanImageMemory);
// 将 Vulkan 资源存储到纹理对象中
tex.image = ktxVulkanImage;
tex.imageView = ktxVulkanImageView;
tex.memory = ktxVulkanImageMemory;
// 清理 KTX 资源
ktxTexture2_Destroy(ktxTexture);
} else {
// 处理其他图像格式或外部引用（省略代码）
// …
}
// 为纹理创建采样器
VkSamplerCreateInfo samplerInfo = {};
// …（省略代码）
textures.push_back(tex);
}
// 加载材质并关联纹理
for (const auto& material : gltfModel.materials) {
Material mat;
// 基础颜色
if (material.pbrMetallicRoughness.baseColorFactor.size() == 4) {
mat.baseColorFactor.r = material.pbrMetallicRoughness.baseColorFactor[0];
mat.baseColorFactor.g = material.pbrMetallicRoughness.baseColorFactor[1];
mat.baseColorFactor.b = material.pbrMetallicRoughness.baseColorFactor[2];
mat.baseColorFactor.a = material.pbrMetallicRoughness.baseColorFactor[3];
}
// 金属度和粗糙度因子
mat.metallicFactor = material.pbrMetallicRoughness.metallicFactor;
mat.roughnessFactor = material.pbrMetallicRoughness.roughnessFactor;
// 关联材质与纹理
if (material.pbrMetallicRoughness.baseColorTexture.index >= 0) {
const auto& texture = gltfModel.textures[material.pbrMetallicRoughness.baseColorTexture.index];
mat.baseColorTexture = &textures[texture.source];
}
if (material.pbrMetallicRoughness.metallicRoughnessTexture.index >= 0) {
const auto& texture = gltfModel.textures[material.pbrMetallicRoughness.metallicRoughnessTexture.index];
mat.metallicRoughnessTexture = &textures[texture.source];
}
if (material.normalTexture.index >= 0) {
const auto& texture = gltfModel.textures[material.normalTexture.index];
mat.normalTexture = &textures[texture.source];
}
if (material.occlusionTexture.index >= 0) {
const auto& texture = gltfModel.textures[material.occlusionTexture.index];
mat.occlusionTexture = &textures[texture.source];
}
if (material.emissiveTexture.index >= 0) {
const auto& texture = gltfModel.textures[material.emissiveTexture.index];
mat.emissiveTexture = &textures[texture.source];
}
model.materials.push_back(mat);
}
接下来，我们讲解这些模块如何协同工作。
理解场景图与层级变换
场景图是一种树形层级数据结构，用于组织 3D 场景的空间表示。它是计算机图形学和游戏引擎中的核心概念，是组织复杂场景的基础框架。
场景图的重要性
相比扁平的对象集合，场景图具备多项关键优势：
- 层级变换（Hierarchical Transformations）：子对象继承父对象的变换属性，便于建模复杂关系
- 空间组织（Spatial Organization）：基于逻辑关系组织对象，简化场景管理
- 动画支持（Animation Support）：层级结构是骨骼动画和复杂运动模式的核心
- 高效遍历（Efficient Traversal）：支持优化的渲染、剔除、拾取操作
- 实例化支持（Instancing Support）：同一对象可在不同位置多次呈现，应用不同变换
以下是实际应用示例：
- 带装备的角色：角色移动时，所有附属装备（武器、护甲）应随之移动。使用场景图时，只需移动角色节点，所有子节点会自动继承变换。
- 带活动部件的载具：载具的车轮可独立旋转，同时整个载具移动。场景图能自然表达这种运动层级。
- 关节动画：带骨骼的角色需要关节相对于父关节运动。场景图直接建模这种父子关系。
场景图中的变换
场景图最强大的特性之一是其变换处理方式：
- 每个节点存储相对于父节点的局部变换
- 全局变换通过组合节点局部变换与父节点全局变换计算得出
- 这种设计能直观建模复杂的层级运动
变换管线的典型流程：
以下是从 glTF 数据构建场景图的实现：
// 第一遍遍历：创建所有节点
for (size_t i = 0; i < gltfModel.nodes.size(); i++) {
const auto& node = gltfModel.nodes[i];
model.linearNodes[i] = new Node();
model.linearNodes[i]->index = static_cast<uint32_t>(i);
model.linearNodes[i]->name = node.name;
// 获取变换数据
if (node.translation.size() == 3) {
model.linearNodes[i]->translation = glm::vec3(
node.translation[0], node.translation[1], node.translation[2]
);
}
// … 处理旋转和缩放
}
// 第二遍遍历：建立父子关系
for (size_t i = 0; i < gltfModel.nodes.size(); i++) {
const auto& node = gltfModel.nodes[i];
for (int childIdx : node.children) {
model.linearNodes[childIdx]->parent = model.linearNodes[i];
model.linearNodes[i]->children.push_back(model.linearNodes[childIdx]);
}
}
我们采用两遍遍历的方式，确保所有节点创建完成后再建立关联。
理解 3D 几何与网格数据
3D 模型以网格（mesh）表示 —— 由顶点、边、面组成的集合，定义对象的形状。理解这些数据的组织结构是实现高效渲染的关键。
3D 模型的组成单元
3D 几何的基础组件包括：
- 顶点（Vertices）：3D 空间中定义形状的点
- 索引（Indices）：指向顶点的引用，定义顶点如何连接形成三角形
- 属性（Attributes）：与顶点关联的附加数据：
- 位置（Positions）：3D 坐标（x, y, z）
- 法线（Normals）：垂直于表面的方向向量（用于光照计算）
- 纹理坐标（UVs）：用于将纹理映射到表面的 2D 坐标
- 切线和副切线（Tangents and Bitangents）：用于法线贴图的向量
- 颜色（Colors）：顶点级颜色数据
- 蒙皮权重和索引（Skinning Weights and Indices）：用于骨骼动画
现代 3D 图形使用三角形网格的原因：
- 三角形始终是平面的（三点确定一个平面）
- 三角形是能表示任意表面的最简单多边形
- 图形硬件针对三角形处理做了优化
glTF 中的网格组织
glTF 以兼顾存储和渲染效率的方式组织网格数据：
- 网格（Meshes）：构成逻辑对象的图元集合
- 图元（Primitives）：网格的独立部分，各有专属材质
- 属性（Attributes）：顶点数据（位置、法线、纹理坐标等）
- 索引（Indices）：定义三角形的顶点引用
这种组织方式带来以下优势：
- 通过数据共享提升内存使用效率
- 单个网格内支持材质变化
- 通过批处理优化渲染性能
以下是网格数据的提取实现：
// 加载网格
for (size_t i = 0; i < gltfModel.nodes.size(); i++) {
const auto& node = gltfModel.nodes[i];
if (node.mesh >= 0) {
const auto& mesh = gltfModel.meshes[node.mesh];
// 处理每个图元
for (const auto& primitive : mesh.primitives) {
Mesh newMesh;
// 设置材质
if (primitive.material >= 0) {
newMesh.materialIndex = primitive.material;
}
// 提取顶点位置、法线和纹理坐标（省略代码）
// …
// 提取定义三角形的索引（省略代码）
// …
// 将网格分配给节点
model.linearNodes[i]->mesh = newMesh;
}
}
}
理解动画系统
动画能将静态 3D 模型转化为虚拟世界中鲜活的实体。健壮的动画系统是打造沉浸式、动态 3D 应用的核心。
3D 图形中的动画技术
3D 图形中常用的动画技术包括：
- 关键帧动画（Keyframe Animation）：定义特定时间点的特定姿态，在帧间插值生成平滑动画
- 骨骼动画（Skeletal Animation）：通过骨骼层级变形网格
- 形态目标动画（Morph Target Animation）：在预定义网格形状间插值
- 程序动画（Procedural Animation）：通过算法和物理生成动画
- 粒子系统（Particle Systems）：用简单规则驱动大量小元素的动画
现代游戏通常组合使用这些技术，其中骨骼动画是角色运动的核心。
动画核心概念
理解动画系统需掌握以下核心概念：
- 关键帧（Keyframes）：明确定义动画值的特定时间点
- 插值（Interpolation）：计算关键帧之间的值，生成平滑运动
- 通道（Channels）：指定动画目标属性（如位置、旋转）
- 混合（Blending）：按不同权重组合多个动画
- 重定向（Retargeting）：将为一个模型创建的动画应用到另一个模型
glTF 动画系统
glTF 采用灵活的动画系统，可表示多种动画技术：
- 动画（Animations）：通道和采样器的集合
- 通道（Channels）：连接采样器与节点属性（平移、旋转、缩放）
- 采样器（Samplers）：包含时间戳、数值和插值方法的关键帧数据
- 目标（Targets）：被动画的属性（平移、旋转、缩放，或形态目标权重）
glTF 支持三种插值方法：
- LINEAR：恒速平滑过渡
- STEP：无插值的突变
- CUBICSPLINE：带控制点的平滑曲线，支持加减速
该系统支持复杂动画，可独立驱动模型的特定部分，实现行走、面部表情、复杂交互等动作。
以下是动画数据的加载实现：
// 加载动画
for (const auto& anim : gltfModel.animations) {
Animation animation;
animation.name = anim.name;
// 加载关键帧数据
for (const auto& sampler : anim.samplers) {
AnimationSampler animSampler{};
// 设置插值类型（LINEAR、STEP 或 CUBICSPLINE）（省略代码）
// …
// 提取关键帧时间和数值（省略代码）
// …
animation.samplers.push_back(animSampler);
}
// 将采样器连接到节点属性
for (const auto& channel : anim.channels) {
AnimationChannel animChannel{};
// 设置目标节点和属性（平移、旋转或缩放）（省略代码）
// …
animation.channels.push_back(animChannel);
}
model.animations.push_back(animation);
}
与渲染管线的集成
加载模型数据后，我们讲解其与渲染管线其他部分的集成方式。
从资源加载到渲染的流程
从 glTF 文件到屏幕像素的完整流程包含以下阶段：
该管线支持高效渲染包含动画模型的复杂场景。
渲染优化
多项优化技术可提升模型渲染性能：
- 批处理（Batching）：将相似对象分组，减少绘制调用（draw calls）
- 实例化（Instancing）：用不同变换渲染同一网格的多个实例
- 细节层级（LOD）：远距离使用简化版模型
- 视锥体剔除（Frustum Culling）：跳过相机视野外的对象渲染
- 遮挡剔除（Occlusion Culling）：跳过被其他对象遮挡的对象渲染
内存管理考量
加载模型（尤其是大型模型）时，内存管理至关重要：
- 顶点数据：存储在 GPU 缓冲区中，实现高效渲染
- 索引：尽可能使用 16 位索引，节省内存
- 纹理：使用带 Basis Universal 压缩的 KTX2，大幅降低内存占用
- 实例化：为不同实例复用同一模型数据，仅应用不同变换
基于 KTX2 和 Basis Universal 的高效纹理内存管理
纹理通常占用 3D 应用中绝大部分 GPU 内存。带 Basis Universal 压缩的 KTX2 提供多项内存优化优势：
- 超级压缩（Supercompression）：相比未压缩格式，Basis Universal 可将纹理体积减小 4-10 倍
- GPU 原生格式：纹理转码为 GPU 可直接采样的格式，避免运行时解压缩
- Mipmap：KTX2 支持 mipmap，不仅提升视觉质量，还降低远距离对象的内存占用
- 格式选择：转码器可根据目标 GPU 能力选择最优格式：
- 桌面 GPU（NVIDIA、AMD、Intel）使用 BC7
- 移动 GPU（ARM、高通）使用 ASTC
- 老旧移动 GPU 使用 ETC2
与 Vulkan 渲染管线的集成
为高效集成 KTX2 纹理与 Vulkan：
- 描述符集（Descriptor Sets）：创建描述符集，将纹理图像视图和采样器绑定到着色器绑定点
- 管线布局（Pipeline Layout）：定义包含这些描述符集的管线布局
- 着色器访问（Shader Access）：在着色器中通过对应绑定点访问纹理
以下是为 PBR 纹理设置描述符集的简化示例：
// 为 PBR 纹理创建描述符集布局
std::array<vk::DescriptorSetLayoutBinding, 5> bindings{
// 基础颜色纹理
vk::DescriptorSetLayoutBinding{
.binding = 0,
.descriptorType = vk::DescriptorType::eCombinedImageSampler,
.descriptorCount = 1,
.stageFlags = vk::ShaderStageFlagBits::eFragment
},
// 金属度-粗糙度纹理
vk::DescriptorSetLayoutBinding{
.binding = 1,
.descriptorType = vk::DescriptorType::eCombinedImageSampler,
.descriptorCount = 1,
.stageFlags = vk::ShaderStageFlagBits::eFragment
},
// 法线贴图
vk::DescriptorSetLayoutBinding{
.binding = 2,
.descriptorType = vk::DescriptorType::eCombinedImageSampler,
.descriptorCount = 1,
.stageFlags = vk::ShaderStageFlagBits::eFragment
},
// 遮挡贴图
vk::DescriptorSetLayoutBinding{
.binding = 3,
.descriptorType = vk::DescriptorType::eCombinedImageSampler,
.descriptorCount = 1,
.stageFlags = vk::ShaderStageFlagBits::eFragment
},
// 自发光贴图
vk::DescriptorSetLayoutBinding{
.binding = 4,
.descriptorType = vk::DescriptorType::eCombinedImageSampler,
.descriptorCount = 1,
.stageFlags = vk::ShaderStageFlagBits::eFragment
}
};
vk::DescriptorSetLayoutCreateInfo layoutInfo{
.bindingCount = static_cast<uint32_t>(bindings.size()),
.pBindings = bindings.data()
};
vk::raii::DescriptorSetLayout descriptorSetLayout(device, layoutInfo);
// 为每个材质创建描述符集，并更新其纹理数据
for (const auto& material : model.materials) {
// 从描述符池分配描述符集
vk::DescriptorSetAllocateInfo allocInfo{
.descriptorPool = descriptorPool,
.descriptorSetCount = 1,
.pSetLayouts = &*descriptorSetLayout
};
vk::raii::DescriptorSet descriptorSet = std::move(vk::raii::DescriptorSets(device, allocInfo).front());
// 更新描述符集，绑定纹理图像视图和采样器
std::vector<vk::WriteDescriptorSet> descriptorWrites;
if (material.baseColorTexture) {
vk::DescriptorImageInfo imageInfo{
.sampler = material.baseColorTexture->sampler,
.imageView = material.baseColorTexture->imageView,
.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal
};
vk::WriteDescriptorSet write{
.dstSet = *descriptorSet,
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorCount = 1,
.descriptorType = vk::DescriptorType::eCombinedImageSampler,
.pImageInfo = &imageInfo
};
descriptorWrites.push_back(write);
}
// 其他纹理的类似绑定操作
// …
device.updateDescriptorSets(descriptorWrites, {});
// 将描述符集存储到材质中，供后续渲染使用
material.descriptorSet = *descriptorSet;
}
纹理内存管理最佳实践
优化纹理内存使用的最佳实践：
- 纹理图集（Texture Atlasing）：将多个小纹理合并为单个大纹理，减少状态切换
- Mipmap 管理：为所有纹理生成并使用 mipmap，提升性能和质量
- 纹理流加载（Texture Streaming）：超大型场景中，仅在需要时加载高分辨率纹理
- 内存预算（Memory Budgeting）：实现纹理预算系统，内存不足时降低纹理质量
- 格式选择：根据纹理内容选择合适格式：
- 带透明通道的颜色纹理：BC7/ASTC
- 无透明通道的颜色纹理：BC1/ETC1
- 法线贴图：BC5/ETC2
- 单通道纹理（粗糙度、金属度等）：BC4/EAC
总结与下一步
本章我们探讨了从 glTF 文件加载 3D 模型并将其组织为场景图的完整流程，涵盖以下内容：
- glTF 格式的结构与优势
- 如何使用 tinygltf 库实现高效解析
- 现代渲染中使用的基于物理的材质系统
- 场景图如何层级化组织对象
- 3D 几何在网格中的表示方式
- 让模型 “活起来” 的动画系统
- 与渲染管线的集成方式
我们的 glTF 加载器创建的完整场景图包含：
- 层级组织的节点
- 绑定到节点的网格
- 定义表面属性的材质
- 可随时间修改节点属性的动画
该结构支持：
- 渲染复杂 3D 场景
- 为角色和对象添加动画
- 应用沿层级传播的变换
- 优化渲染性能
下一章中，我们将探讨如何使用基于物理的渲染技术渲染这些模型，通过真实的光照和材质让加载的资源呈现出逼真的视觉效果。
