87、C++项目实战：游戏引擎（2D渲染）

说实话，做游戏引擎这件事，很多初学者一听就觉得遥不可及。但2D渲染引擎，说白了就是「把图片画到屏幕上」这件事的工程化封装。我当年第一次自己写渲染循环时，屏幕上出现一个移动的方块，那种成就感至今难忘。

今天我们就来拆解一个轻量级2D渲染引擎的核心模块。我会带着你从零搭建一个可用的渲染框架，顺便聊聊那些年我踩过的坑。

一、引擎架构概览

一个2D渲染引擎，核心就三件事：资源管理、渲染管线、游戏循环。我个人习惯把架构分成四层：

• 底层抽象层：封装OpenGL/DirectX/Vulkan的差异
• 资源管理层：纹理、Shader、Mesh的加载与缓存
• 渲染管线层：批次合并、裁剪、渲染状态管理
• 应用层：场景管理、组件系统、输入处理

二、核心模块实现

2.1 纹理加载与缓存

纹理是2D渲染的命根子。我见过太多项目每帧都从硬盘读图片，那性能简直惨不忍睹。正确的做法是：预加载 + 引用计数 + LRU缓存。

class TextureManager {
public:
    std::shared_ptr<Texture> Load(const std::string& path) {
        auto it = cache_.find(path);
        if (it != cache_.end()) {
            return it->second.lock();  // 弱引用提升
        }
        auto tex = std::make_shared<Texture>(path);
        cache_[path] = tex;
        return tex;
    }
    
    void UnloadUnused() {
        for (auto it = cache_.begin(); it != cache_.end(); ) {
            if (it->second.expired()) {
                it = cache_.erase(it);
            } else {
                ++it;
            }
        }
    }
private:
    std::unordered_map<std::string, std::weak_ptr<Texture>> cache_;
};

2.2 渲染批次合并

为什么要做批次合并？你想想看，每次调用 glDrawElements 都有CPU开销。如果1000个精灵各自独立绘制，那就是1000次调用。合并成一批，只需要1次。

我常用的策略是：按纹理排序，按Shader分组。同一纹理的精灵可以合并到一个批次里。

struct RenderBatch {
    const Texture* texture;
    const Shader* shader;
    std::vector<Vertex> vertices;
    std::vector<uint32_t> indices;
};

class BatchRenderer {
public:
    void Submit(const Sprite& sprite) {
        // 查找可合并的批次
        for (auto& batch : batches_) {
            if (batch.texture == sprite.texture &&
                batch.shader == sprite.shader) {
                // 追加顶点数据
                batch.vertices.push_back(...);
                batch.indices.push_back(...);
                return;
            }
        }
        // 创建新批次
        batches_.emplace_back(sprite);
    }
    
    void Flush() {
        for (auto& batch : batches_) {
            batch.Bind();
            glDrawElements(GL_TRIANGLES, batch.indices.size(), 
                          GL_UNSIGNED_INT, nullptr);
        }
        batches_.clear();
    }
private:
    std::vector<RenderBatch> batches_;
};

2.3 游戏循环与帧率控制

游戏循环是引擎的心脏。固定时间步长 vs 可变时间步长，我推荐前者。为什么？因为物理模拟需要稳定的时间增量。

class GameLoop {
public:
    void Run() {
        const double dt = 1.0 / 60.0;  // 固定60FPS
        double accumulator = 0.0;
        auto current_time = std::chrono::high_resolution_clock::now();
        
        while (running_) {
            auto new_time = std::chrono::high_resolution_clock::now();
            double frame_time = std::chrono::duration<double>(new_time - current_time).count();
            current_time = new_time;
            
            accumulator += frame_time;
            
            // 固定步长更新
            while (accumulator >= dt) {
                Update(dt);  // 物理、逻辑更新
                accumulator -= dt;
            }
            
            // 渲染（插值渲染）
            double alpha = accumulator / dt;
            Render(alpha);
        }
    }
private:
    bool running_ = true;
};

三、实战经验总结

模块	常见坑	我的解决方案
纹理管理	重复加载、内存泄漏	弱引用缓存 + 引用计数
批次渲染	批次过多、顶点溢出	按纹理排序 + 动态拆分
游戏循环	帧率不稳定、物理抖动	固定时间步长 + 插值渲染
Shader管理	重复编译、状态混乱	Shader缓存 + 状态栈

四、性能优化建议

• 减少状态切换：OpenGL状态切换很贵。把相同纹理、相同Shader的绘制调用排在一起。
• 使用顶点缓冲对象（VBO）：不要每帧上传顶点数据。用glMapBuffer映射内存，直接写入。
• 视锥裁剪：屏幕外的精灵直接跳过。我见过一个项目渲染10万个精灵，裁剪后只剩2000个，帧率从15飙到120。
• 纹理图集：把多个小纹理合并成一张大图，减少纹理切换。这是2D引擎的经典优化手段。

嗯，2D渲染引擎的核心内容差不多就这些。从架构设计到具体实现，再到性能优化，每一步都有值得深挖的细节。记住：引擎是工具，不是目的。把游戏做好玩，才是最终目标。

---

公众号:蓝海资料掘金营，微信deep3321