游戏编程模式之双缓冲模式解析-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00156/article/details/148527250

游戏编程模式之双缓冲模式解析

game-programming-patterns Source repo for the book 项目地址: https://gitcode.com/gh_mirrors/ga/game-programming-patterns

双缓冲模式的核心思想

双缓冲模式（Double Buffer）是一种经典的编程模式，主要用于解决状态修改过程中的可见性问题。该模式通过维护两个缓冲区，使得状态修改过程对外部观察者来说表现为一个原子操作。

模式动机

计算机本质上是顺序执行的机器，它们通过将大任务分解为小步骤来工作。但在图形渲染等场景中，我们需要让一系列顺序操作看起来像是瞬间完成的。

图形渲染中的问题

在游戏渲染过程中，如果直接在帧缓冲区上绘制，当视频硬件同时读取该缓冲区时，就会出现"撕裂"现象——用户看到部分已渲染和部分未渲染的画面混合在一起。

剧院场景类比

想象一个剧院有两套舞台设备：

舞台A面向观众展示当前场景
舞台B在暗处准备下一场景

当场景切换时，只需切换灯光，观众就能立即看到新场景，而不会看到舞台布置的过程。这正是双缓冲的核心思想。

模式结构

双缓冲模式包含以下关键组件：

缓冲类：封装可修改的状态缓冲区
当前缓冲区：对外提供只读访问
下一缓冲区：用于进行修改操作
交换操作：原子性地切换两个缓冲区

应用场景

双缓冲模式适用于以下情况：

状态需要增量修改
修改过程中状态可能被访问
需要隐藏修改的中间状态
读取操作不应被写入操作阻塞

实现考量

交换操作的时间成本

缓冲区交换必须是原子操作，且耗时应该远小于状态修改时间，否则就失去了使用双缓冲的意义。

内存开销

双缓冲需要维护两份状态数据，在内存受限的设备上可能成为问题。

代码示例分析

图形渲染实现

首先定义基础的帧缓冲区类：

class Framebuffer {
public:
    Framebuffer() { clear(); }
    
    void clear() {
        for (int i = 0; i < WIDTH * HEIGHT; ++i) {
            pixels_[i] = WHITE;
        }
    }
    
    void draw(int x, int y) {
        pixels_[(WIDTH * y) + x] = BLACK;
    }
    
    const char* getPixels() const {
        return pixels_;
    }

private:
    static const int WIDTH = 160;
    static const int HEIGHT = 120;
    char pixels_[WIDTH * HEIGHT];
};

然后实现双缓冲的场景类：

class Scene {
public:
    Scene() : current_(&buffers_[0]), next_(&buffers_[1]) {}
    
    void draw() {
        next_->clear();
        next_->draw(1, 1);  // 绘制左眼
        next_->draw(4, 1);  // 绘制右眼
        next_->draw(2, 3);  // 绘制嘴巴
        next_->draw(3, 3);
    }
    
    void swap() {
        Framebuffer* temp = current_;
        current_ = next_;
        next_ = temp;
    }
    
    Framebuffer* getBuffer() const {
        return current_;
    }

private:
    Framebuffer buffers_[2];
    Framebuffer* current_;
    Framebuffer* next_;
};

AI行为系统示例

考虑一个喜剧演员互动的AI系统：

class Actor {
public:
    virtual ~Actor() {}
    virtual void update() = 0;
    
    void slap() { slapped_ = true; }
    bool wasSlapped() const { return slapped_; }
    
protected:
    bool slapped_ = false;
};

class Stage {
public:
    void add(Actor* actor) {
        actors_.push_back(actor);
    }
    
    void update() {
        for (auto actor : actors_) {
            actor->update();
        }
        
        for (auto actor : actors_) {
            actor->slapped_ = false;
        }
    }

private:
    std::vector<Actor*> actors_;
};

class Comedian : public Actor {
public:
    void face(Actor* actor) { facing_ = actor; }
    
    void update() override {
        if (wasSlapped()) {
            facing_->slap();
        }
    }

private:
    Actor* facing_;
};

这个例子展示了当多个Actor相互影响时，如果没有双缓冲，更新顺序会影响行为结果。