最近在技术社区看到不少关于游戏引擎开发的讨论，很多开发者，无论是刚入行的新人还是有一定经验的程序员，都对“如何从零开始构建一个游戏引擎”这个话题充满好奇与敬畏。确实，引擎开发涉及计算机图形学、物理模拟、音频处理、资源管理、脚本系统等众多复杂领域，听起来像一座难以逾越的高山。但事实上，通过系统性地拆解和逐步实践，理解其核心架构并动手实现一个精简但功能完整的原型是完全可行的。本文将围绕现代游戏引擎的核心模块，从设计理念到具体实现，为你提供一份从入门到实践的完整路线图。无论你是想深入理解游戏底层运行机制，还是为未来的职业发展打下坚实基础，这篇文章都将为你提供清晰的指引和可运行的代码示例。

1. 游戏引擎是什么？我们为什么要造轮子？

在深入代码之前，我们必须先厘清一个根本问题：什么是游戏引擎？简单来说，游戏引擎是为游戏开发提供一系列可复用核心功能与工具的软件框架。它并非一个神秘的黑盒，而是一套精心设计的、用于解决游戏开发中通用问题的解决方案集合。

一个典型的商业引擎（如Unity、Unreal Engine）会包含以下核心子系统：

• 渲染引擎：负责将3D模型、纹理、灯光等数据转换成屏幕上的像素。
• 物理引擎：模拟现实世界中的碰撞、重力、刚体/柔体运动等。
• 音频引擎：管理背景音乐、音效的加载、播放和3D空间化处理。
• 资源管理器：高效加载、缓存和管理图片、模型、音频、配置文件等资产。
• 场景图/实体组件系统（ECS）：组织游戏世界中的对象（实体）及其行为（组件）。
• 脚本系统：允许开发者（或设计师）用高级语言（如C#、Lua）编写游戏逻辑，而无需修改引擎底层C++代码。
• 工具链：关卡编辑器、材质编辑器、动画编辑器等，用于提升内容创作效率。

那么，在已有成熟商业引擎和开源引擎（Godot）的今天，为什么我们还要自己动手写引擎？这绝非简单的“造轮子”，其价值在于：

1. 极致的学习与深度理解：亲手实现一遍渲染管线或物理碰撞检测，比阅读一百篇文档更能让你理解计算机图形学和游戏运行的底层原理。这是成为图形程序员或引擎工程师的必经之路。
2. 无与伦比的定制化与控制力：商业引擎为了通用性，往往非常庞大。如果你的项目有极其特殊的需求（如特定风格的渲染、独特的网络同步模型），一个自研的、轻量级的专用引擎可能是更优选择。
3. 性能与开销的极致优化：你可以完全掌控内存分配、多线程架构、数据布局（例如为你的游戏量身定制的ECS），剔除所有不必要的开销，为目标平台（如移动端、主机）做深度优化。
4. 避免授权费用与平台限制：对于某些商业项目，引擎授权费是一笔不小的开支。自研引擎可以完全掌控产品的分发和盈利模式。

当然，自制引擎的挑战巨大，需要深厚的计算机科学基础、大量的时间投入以及对多个专业领域的掌握。本文的目标不是教你复刻一个Unreal，而是引导你构建一个**“可运行的最小可行产品（MVP）”**，涵盖最核心的模块，让你获得构建复杂系统的一手经验。

2. 环境准备与工具链选择

在开始编码前，选择合适的工具和设定好开发环境至关重要。以下是一个基于C++的现代游戏引擎开发环境推荐，这也是工业界的常见选择。

2.1 核心开发环境

• 操作系统：Windows 10/11， Linux 或 macOS。本文示例将主要使用跨平台友好的方法。
• 编程语言：C++ 17/20。C++因其高性能和对硬件的直接控制能力，仍是游戏引擎开发的首选。需要熟悉现代C++特性（如智能指针、lambda、移动语义）。
• 编译器：
  • Windows: MSVC (随Visual Studio安装) 或 Clang。
  • Linux/macOS: GCC 或 Clang。
• 集成开发环境（IDE）：
  • Visual Studio 2022(Windows): 对C++和图形调试支持极佳。
  • CLion(跨平台): 优秀的跨平台C++ IDE，基于CMake。
  • VSCode(跨平台): 轻量级，通过C++插件和CMake Tools可以配置成强大的开发环境。
• 构建系统：CMake。它是管理跨平台C++项目构建的事实标准，能很好地处理依赖和生成各种IDE的项目文件。

2.2 核心依赖库

我们将依赖一些优秀的开源库来搭建基础，避免从零实现所有底层功能：

1. 图形API与窗口管理：
   • GLFW：一个轻量级的、跨平台的库，用于创建窗口、处理输入（键盘、鼠标）和OpenGL上下文。比SDL更专注于OpenGL/Vulkan。
   • OpenGL或Vulkan：渲染API。对于初学者，强烈推荐从OpenGL 3.3+开始，其学习曲线相对平缓，有丰富的学习资源。Vulkan则提供更底层的控制和更高的性能，但复杂度也呈指数级增长。
2. 数学库：GLM(OpenGL Mathematics)。一个完全模仿GLSL语法和功能的C++数学库，提供向量、矩阵、四元数等运算，是图形编程的必备工具。
3. 资产加载：
   • Assimp：强大的模型加载库，支持数十种3D模型格式（.obj, .fbx, .gltf等）。
   • stb_image：单头文件库，用于加载图片（PNG, JPEG, BMP等）为像素数据。
4. 日志与调试：spdlog：一个快速的C++日志库，支持多种输出格式和级别，便于调试。
5. 音频：OpenAL Soft或miniaudio：跨平台的开源音频库，可以处理3D音效。
6. 物理（可选，后期集成）：Bullet Physics或Jolt Physics。初期我们可以实现简单的AABB碰撞检测。

2.3 项目结构规划

一个清晰的项目结构是良好开端。建议如下：

MyGameEngine/ ├── CMakeLists.txt # 项目根CMake配置 ├── engine/ # 引擎核心源码 │ ├── src/ │ │ ├── core/ # 核心系统（日志、内存分配、配置文件） │ │ ├── platform/ # 平台抽象层（窗口、输入、时间） │ │ ├── graphics/ # 渲染系统（渲染器、着色器、材质、网格） │ │ ├── ecs/ # 实体组件系统 │ │ ├── resource/ # 资源管理 │ │ └── audio/ # 音频系统 │ └── include/ # 公共头文件 ├── third_party/ # 第三方库（GLFW, GLM, spdlog等） ├── assets/ # 游戏资产（着色器， 模型， 纹理） │ ├── shaders/ │ ├── models/ │ └── textures/ └── sandbox/ # 测试/游戏项目 ├── src/ └── CMakeLists.txt

3. 引擎核心架构与模块拆解

理解了“做什么”和“用什么做”之后，我们需要设计引擎的架构。现代游戏引擎普遍采用分层和模块化的设计思想。

3.1 核心循环：引擎的心跳

一切始于游戏循环。这是一个无限循环，直到游戏退出。每一帧都顺序执行以下操作：

1. 处理输入：轮询键盘、鼠标、手柄等输入设备的状态。
2. 更新游戏状态：根据输入和时间增量（Delta Time），更新所有实体（位置、动画、物理等）的逻辑。
3. 渲染：将更新后的游戏世界绘制到屏幕上。

// 文件路径：engine/src/core/application.cpp (简化示例) #include “core.h” #include “platform/window.h” #include “platform/input.h” class Application { public: void Run() { Initialize(); while (!m_Window->ShouldClose()) { // 主循环 float deltaTime = CalculateDeltaTime(); // 计算上一帧耗时 // 1. 处理输入 Input::PollEvents(); // 2. 更新 OnUpdate(deltaTime); // 3. 渲染 m_Renderer->BeginFrame(); // 清屏等操作 OnRender(); m_Renderer->EndFrame(); // 交换缓冲区 // 4. 其他帧末操作 m_Window->SwapBuffers(); } Shutdown(); } protected: virtual void OnUpdate(float deltaTime) = 0; virtual void OnRender() = 0; private: std::unique_ptr<Window> m_Window; std::unique_ptr<Renderer> m_Renderer; };

关键点：deltaTime（帧时间差）至关重要。它使得游戏更新与帧率解耦，确保在60FPS或144FPS的机器上，角色的移动速度是一致的。

3.2 实体组件系统：组织游戏对象的范式

传统的继承层次（如GameObject -> Actor -> Enemy -> BossEnemy）在复杂游戏中会变得僵化。ECS是一种更灵活的组合模式：

• 实体（Entity）：一个唯一的ID，代表游戏世界中的一个“事物”，它本身不包含数据或行为。
• 组件（Component）：纯粹的数据结构。例如TransformComponent（位置、旋转、缩放）、RenderComponent（网格、材质）、PhysicsComponent（刚体）。
• 系统（System）：包含逻辑的函数或类，负责处理拥有特定组件组合的实体。例如MovementSystem遍历所有拥有TransformComponent和VelocityComponent的实体，更新它们的位置。

// 文件路径：engine/include/ecs/ecs.h (极度简化的概念示例) using Entity = uint32_t; struct TransformComponent { glm::vec3 position; glm::vec3 rotation; glm::vec3 scale; }; struct RenderComponent { MeshHandle mesh; MaterialHandle material; }; class MovementSystem { public: void Update(float deltaTime, ComponentManager& cm) { auto view = cm.View<TransformComponent, VelocityComponent>(); for (auto [entity, transform, velocity] : view) { transform.position += velocity.linear * deltaTime; } } };

ECS的优势在于数据局部性好（适合缓存）、逻辑清晰、易于扩展（添加新行为只需添加新组件和系统）。

3.3 渲染系统：从数据到像素

渲染是引擎中最复杂的部分之一。一个基础的OpenGL渲染管线包括：

1. 顶点数据：传递模型的顶点位置、法线、纹理坐标等。
2. 顶点着色器：处理每个顶点，进行模型-视图-投影变换。
3. 图元装配与光栅化：将顶点连接成三角形，并确定哪些像素被覆盖。
4. 片段着色器：计算每个像素的最终颜色（采样纹理、计算光照）。
5. 测试与混合：深度测试（解决遮挡）、模板测试、颜色混合。

我们需要创建抽象来管理这些对象：

• Shader类：编译和链接着色器程序，提供Uniform设置接口。
• VertexBuffer/IndexBuffer类：管理GPU上的顶点和索引数据。
• VertexArray类：绑定顶点缓冲的布局（属性指针）。
• Texture类：加载和管理纹理。
• Renderer类：高级抽象，封装绘制命令（DrawIndexed等）。

// 文件路径：engine/src/graphics/shader.cpp (片段) Shader::Shader(const std::string& vertPath, const std::string& fragPath) { // 1. 从文件读取GLSL源码 std::string vertSrc = ReadFile(vertPath); std::string fragSrc = ReadFile(fragPath); const char* vSrc = vertSrc.c_str(); const char* fSrc = fragSrc.c_str(); // 2. 编译顶点着色器 GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vSrc, nullptr); glCompileShader(vertexShader); CheckCompileErrors(vertexShader, “VERTEX”); // 3. 编译片段着色器 (类似代码省略) // 4. 链接着色器程序 m_RendererID = glCreateProgram(); glAttachShader(m_RendererID, vertexShader); glAttachShader(m_RendererID, fragmentShader); glLinkProgram(m_RendererID); CheckCompileErrors(m_RendererID, “PROGRAM”); // 5. 清理中间对象 glDeleteShader(vertexShader); glDeleteShader(fragmentShader); } void Shader::SetMat4(const std::string& name, const glm::mat4& matrix) { glUniformMatrix4fv(glGetUniformLocation(m_RendererID, name.c_str()), 1, GL_FALSE, &matrix[0][0]); }

3.4 资源管理：生命周期的掌控者

游戏资产（纹理、模型、音频）通常远大于内存容量，必须动态加载和卸载。一个基本的资源管理器应提供：

• 引用计数或智能指针管理：确保资源在不再被使用时释放。
• 异步加载：防止加载大资源时卡住主线程。
• 缓存：避免同一资源被重复加载。
• 句柄系统：使用不透明的TextureHandle、ModelHandle来引用资源，而不是原始指针，提高安全性和灵活性。

// 文件路径：engine/include/resource/resource_manager.h (概念示例) template<typename T> class ResourceCache { public: using Handle = std::shared_ptr<T>; // 简单使用shared_ptr作为句柄 Handle Load(const std::string& path) { auto it = m_Cache.find(path); if (it != m_Cache.end()) { return it->second; // 返回缓存 } // 否则，加载资源 auto resource = std::make_shared<T>(); if (resource->LoadFromFile(path)) { m_Cache[path] = resource; return resource; } return nullptr; // 加载失败 } void UnloadUnused() { for (auto it = m_Cache.begin(); it != m_Cache.end(); ) { if (it->second.use_count() == 1) { // 只有缓存管理器持有引用 it = m_Cache.erase(it); } else { ++it; } } } private: std::unordered_map<std::string, Handle> m_Cache; };

4. 完整实战：构建一个“三角形渲染器”引擎

让我们将上述概念整合，创建一个最小化的、能渲染一个彩色三角形的“引擎”。这个项目将涵盖窗口创建、OpenGL上下文初始化、着色器管理和基本渲染循环。

4.1 项目初始化与CMake配置

首先，在项目根目录创建CMakeLists.txt，配置项目并获取第三方库。

# 文件路径：MyGameEngine/CMakeLists.txt cmake_minimum_required(VERSION 3.20) project(MyGameEngine VERSION 0.1.0 LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) # 添加引擎子目录 add_subdirectory(engine) # 添加测试沙盒子目录 add_subdirectory(sandbox)

# 文件路径：MyGameEngine/engine/CMakeLists.txt # 引擎库的CMake配置 # 1. 使用FetchContent获取GLFW和GLM (现代CMake推荐方式) include(FetchContent) FetchContent_Declare( glfw GIT_REPOSITORY https://github.com/glfw/glfw.git GIT_TAG 3.3.8 ) FetchContent_MakeAvailable(glfw) FetchContent_Declare( glm GIT_REPOSITORY https://github.com/g-truc/glm.git GIT_TAG 0.9.9.8 ) FetchContent_MakeAvailable(glm) # 2. 创建引擎库目标 add_library(MyEngine STATIC src/core/application.cpp src/core/log.cpp src/platform/window.cpp src/platform/input.cpp src/graphics/renderer.cpp src/graphics/shader.cpp src/graphics/vertex_array.cpp # ... 其他源文件 ) # 3. 包含头文件目录 target_include_directories(MyEngine PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include ${glm_SOURCE_DIR} # GLM是头文件库 ) # 4. 链接依赖库 target_link_libraries(MyEngine PUBLIC glfw) # 链接GLFW # OpenGL库在大多数系统上不需要显式链接，GLFW会处理

4.2 实现平台层：窗口与输入

创建窗口并处理基本输入事件。

// 文件路径：engine/include/platform/window.h #pragma once #include <string> struct GLFWwindow; namespace Engine { class Window { public: Window(const std::string& title, int width, int height); ~Window(); bool ShouldClose() const; void SwapBuffers(); void PollEvents(); // 获取底层GLFW窗口指针（供其他系统如输入、OpenGL使用） GLFWwindow* GetNativeWindow() const { return m_Window; } private: GLFWwindow* m_Window; int m_Width, m_Height; std::string m_Title; }; }

// 文件路径：engine/src/platform/window.cpp #include “platform/window.h” #include “core/log.h” #include <GLFW/glfw3.h> namespace Engine { Window::Window(const std::string& title, int width, int height) : m_Title(title), m_Width(width), m_Height(height) { // 初始化GLFW if (!glfwInit()) { LOG_CRITICAL(“Failed to initialize GLFW”); return; } // 配置OpenGL上下文 glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); #ifdef __APPLE__ glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // macOS需要 #endif // 创建窗口 m_Window = glfwCreateWindow(width, height, title.c_str(), nullptr, nullptr); if (!m_Window) { LOG_CRITICAL(“Failed to create GLFW window”); glfwTerminate(); return; } // 设置当前上下文 glfwMakeContextCurrent(m_Window); LOG_INFO(“Window ‘{0}’ created ({1}x{2})”, title, width, height); } Window::~Window() { glfwDestroyWindow(m_Window); glfwTerminate(); } bool Window::ShouldClose() const { return glfwWindowShouldClose(m_Window); } void Window::SwapBuffers() { glfwSwapBuffers(m_Window); } void Window::PollEvents() { glfwPollEvents(); } }

4.3 实现渲染层：着色器与顶点数组

创建着色器程序和定义三角形顶点数据。

// 文件路径：engine/src/graphics/shader.cpp (完整版) #include “graphics/shader.h” #include “core/log.h” #include <fstream> #include <sstream> #include <glad/glad.h> // 需要先初始化GLAD namespace Engine { static std::string ReadFile(const std::string& filepath) { std::ifstream in(filepath, std::ios::in | std::ios::binary); if (in) { std::string contents; in.seekg(0, std::ios::end); contents.resize(in.tellg()); in.seekg(0, std::ios::beg); in.read(&contents[0], contents.size()); in.close(); return contents; } LOG_ERROR(“Could not open file ‘{0}’”, filepath); return “”; } Shader::Shader(const std::string& vertexSrc, const std::string& fragmentSrc) { // 编译链接着色器 (代码同3.3节，略) // ... 假设已实现 m_RendererID = CreateProgram(vertexSrc, fragmentSrc); } Shader::~Shader() { glDeleteProgram(m_RendererID); } void Shader::Bind() const { glUseProgram(m_RendererID); } void Shader::Unbind() const { glUseProgram(0); } }

// 文件路径：sandbox/assets/shaders/basic.vert #version 330 core layout (location = 0) in vec3 aPos; layout (location = 1) in vec3 aColor; out vec3 ourColor; void main() { gl_Position = vec4(aPos, 1.0); ourColor = aColor; }

// 文件路径：sandbox/assets/shaders/basic.frag #version 330 core in vec3 ourColor; out vec4 FragColor; void main() { FragColor = vec4(ourColor, 1.0); }

4.4 创建测试沙盒应用

现在，我们创建一个使用引擎库的简单应用来渲染三角形。

// 文件路径：sandbox/src/main.cpp #include “engine/core/application.h” #include “engine/graphics/shader.h” #include “engine/graphics/vertex_array.h” #include “engine/graphics/buffer.h” #include <glad/glad.h> #include <GLFW/glfw3.h> #include <glm/glm.hpp> class SandboxApp : public Engine::Application { public: SandboxApp() : Engine::Application(“My First Game Engine”, 800, 600) { // 初始化GLAD (必须在创建OpenGL上下文之后) if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { LOG_CRITICAL(“Failed to initialize GLAD”); return; } // 定义三角形的顶点数据 (位置 + 颜色) float vertices[] = { // 位置 // 颜色 -0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, // 左下，红色 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, // 右下，绿色 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f // 顶部，蓝色 }; // 1. 创建顶点缓冲对象 (VBO) m_VertexBuffer = Engine::VertexBuffer::Create(vertices, sizeof(vertices)); // 2. 设置顶点缓冲布局 Engine::BufferLayout layout = { { Engine::ShaderDataType::Float3, “aPos” }, { Engine::ShaderDataType::Float3, “aColor” } }; m_VertexBuffer->SetLayout(layout); // 3. 创建顶点数组对象 (VAO) 并添加VBO m_VertexArray = Engine::VertexArray::Create(); m_VertexArray->AddVertexBuffer(m_VertexBuffer); // (这个三角形不需要索引缓冲) // 4. 创建着色器 m_Shader = Engine::Shader::CreateFromFiles( “assets/shaders/basic.vert”, “assets/shaders/basic.frag” ); } void OnUpdate(float deltaTime) override { // 每帧更新逻辑（本例中为空） } void OnRender() override { // 设置清屏颜色 glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); // 使用着色器并绑定顶点数组 m_Shader->Bind(); m_VertexArray->Bind(); // 绘制三角形 glDrawArrays(GL_TRIANGLES, 0, 3); } private: Engine::Ref<Engine::Shader> m_Shader; Engine::Ref<Engine::VertexArray> m_VertexArray; Engine::Ref<Engine::VertexBuffer> m_VertexBuffer; }; // 应用入口点 Engine::Application* Engine::CreateApplication() { return new SandboxApp(); }

4.5 编译与运行

1. 在项目根目录创建build文件夹。
2. 进入build，运行cmake ..生成构建文件。
3. 运行cmake --build .(或打开生成的.sln文件在Visual Studio中编译)。
4. 将sandbox/assets文件夹复制到build/sandbox/Debug(或Release) 目录下，确保着色器文件路径正确。
5. 运行生成的可执行文件。

如果一切顺利，你将看到一个带有红、绿、蓝三色的三角形在深青色背景的窗口中央旋转（如果添加了旋转逻辑）或静止显示。恭喜，你已经拥有了一个可以运行的、最基础的图形渲染引擎框架！

5. 常见问题与排查思路

在引擎开发过程中，你会遇到无数错误。以下是一些初期常见问题及其解决方法。

6. 最佳实践与工程建议

当你迈出第一步后，以下建议能帮助你将这个“玩具引擎”逐步进化成一个更健壮、可维护的系统。

6.1 代码组织与架构

• 清晰的模块边界：严格分离平台层、核心层、渲染层、资源层等。模块间通过定义良好的接口通信，避免直接依赖具体实现。
• 使用现代C++特性：善用RAII管理资源（如OpenGL对象），使用智能指针（std::unique_ptr,std::shared_ptr）自动管理内存，使用移动语义避免不必要的拷贝。
• 统一的错误处理：建立一套日志系统（如集成spdlog），定义不同的日志级别（Trace, Debug, Info, Warn, Error, Critical）。断言(assert)用于捕捉开发阶段的编程错误。
• 数据驱动设计：将游戏对象、关卡布局、材质属性等定义为数据文件（如JSON, XML）。引擎读取这些数据来构建世界，使策划和美术能独立工作，无需重新编译代码。

6.2 渲染优化

• 批处理与合批：将使用相同着色器和纹理的多个物体合并到一个绘制调用中，大幅减少CPU到GPU的通信开销。
• 状态管理：减少OpenGL状态切换（如切换着色器、绑定纹理）。可以实现一个状态机，只在状态确实改变时才提交更改。
• 顶点缓冲对象（VBO）与索引缓冲对象（IBO）：始终使用它们来传递顶点数据，而不是立即模式(glBegin/glEnd)。
• 视锥体裁剪：在提交渲染命令前，剔除摄像机视锥体外的物体。

6.3 资源与内存管理

• 实现资源热重载：在开发时，监听资源文件改动，自动重新加载纹理、着色器，极大提升迭代速度。
• 使用内存池/分配器：针对频繁创建销毁的小对象（如实体、组件），使用自定义分配器来减少内存碎片和提高分配速度。
• ** profiling 与调试**：集成性能分析工具（如Tracy， Remotery），实时查看CPU/GPU耗时、内存占用，精准定位性能瓶颈。

6.4 生产环境考量

• 支持多平台：从项目早期就考虑跨平台（Windows, Linux, macOS）。将平台相关代码（窗口、文件系统、线程）抽象到独立的模块中。
• 完善的工具链：引擎的强大离不开工具。考虑开发简单的场景编辑器、材质编辑器、动画编辑器，哪怕最初只是读取JSON的界面。
• 脚本系统集成：使用Lua或自己实现一个简单的虚拟机，将游戏逻辑与引擎C++代码分离。这允许策划和脚本程序员更安全、更高效地修改游戏行为。
• 文档与示例：为你引擎的每个主要系统编写清晰的文档，并提供丰富的示例代码。这是吸引其他开发者使用和贡献的关键。

游戏引擎开发是一场马拉松，而非短跑。不要试图一开始就构建一个庞然大物。从渲染一个三角形开始，然后添加立方体、加载一个模型、实现基础光照、加入简单的物理碰撞。每完成一个功能，你对整个系统的理解就会加深一层。这个过程中积累的关于计算机图形学、软件架构、性能优化的知识，是无价的。当你最终看到自己构建的系统运行起一个简单的游戏场景时，那种成就感是使用现成引擎无法比拟的。