Unity设计模式-双缓冲

Unity设计模式-双缓冲

定义当前缓冲区与后台缓冲区。当要从缓冲区读取数据时，总是从当前缓冲区读取。当要往缓冲区写入数据时，则总是在后台缓冲区上进行。当改动完成后，则执行交换操作来将当前缓冲区与后台缓冲区进行瞬时地交换。

双缓冲在图形领域应用非常成熟，使用两个缓冲区，一个用于当前显示的帧，另一个用于绘制新帧。通过在这两个缓冲区之间切换，显卡可以实现平滑的动画效果，减少闪烁和撕裂现象。

现代显卡通常使用三重缓冲等多缓冲技术。

不论是双缓冲还是多缓冲，所要解决的都是对状态同时修改与访问产生了冲突这一问题。

本篇思路受灵感来源：Habrador/Unity-Programming-Patterns: A collection of open source programming patterns in Unity with examples when to use them (github.com)

本文将实现一个细胞自动机生成地牢，并使用双缓冲解决遇到的边读边写问题。

差代码

这里是一个程序化的洞穴生成器。

代码来源于：[Unity] Procedural Cave Generation (E01. Cellular Automata) - YouTube

本身思路很好。

1. 先随机生成。
2. 再计算一个格子周边有几个墙，如果周围墙面数量少，置为道路。此过程称为smooth。
3. smooth n次直到生成最终的地图。

这种算法又叫细胞自动机Cellular automaton，是一种离散模型。它有无限个有规律，坚硬的方格构成，每个均处于一种有限状态。

每格处于t时的状态由t-1时的邻域的态决定。每一格的邻居都是已被固定的。每格军遵守统一规则一齐演进。

就形式而言，细胞自动机有三个特征：

• 平行计算Parallel computation:每一个细胞个体都同时同步地改变
• 局部的Local：细胞的状态变化只受周遭细胞的影响
• 一致性的Homogeneous：所有细胞均受同样的规则支配。

算法没问题，但正如热评第一说的，这个代码实现存在bug。

这是一种很好的技术，但在实现方面存在问题。细胞自动机规则应该并行应用。这通常通过双缓冲来实现。处理每个单元格时，它会使用周围单元格的当前状态来确定其新状态。当计算每个新状态时，它被存储在第二个数组中。处理完所有单元格后，第二个数组将成为下一次迭代的当前状态。（原文的实现方案）因为您在迭代运行时更改当前状态，所以未处理的单元格将无法访问已处理单元格的当前真实状态。这会导致地图出现强烈的对角线偏差。

我跑了下demo，确实是的，可以看到生成的地图总是对角线方向的。

我稍微改了下实现，主要是

1. 引入协程，让smooth过程可见。
2. 性能优化，生成地图的时候不重新分配内存。
3. 加入图片保存功能，生成的图片存到本地。

摘录部分代码如下：

 void SmoothMapStep()
{
    for (int x = 0; x < width; x++)
    {
        for (int y = 0; y < height; y++)
        {
            // 检查8方向，如果周围的墙的数量大于4，那么就是墙，否则就是路
            int neighbourWallTiles = GetSurroundingWallCount(x, y);

            if (neighbourWallTiles > 4)
                map[x, y] = 1;
            else if (neighbourWallTiles < 4)
                map[x, y] = 0;

        }
    }
}

int GetSurroundingWallCount(int gridX, int gridY)
{
    int wallCount = 0;
    for (int neighbourX = gridX - 1; neighbourX <= gridX + 1; neighbourX++)
    {
        for (int neighbourY = gridY - 1; neighbourY <= gridY + 1; neighbourY++)
        {
            if (neighbourX >= 0 && neighbourX < width && neighbourY >= 0 && neighbourY < height)
            {
                if (neighbourX != gridX || neighbourY != gridY)
                {
                    wallCount += map[neighbourX, neighbourY];
                }
            }
            else
            {
                wallCount++;
            }
        }
    }

    return wallCount;
}

好代码

引入双缓冲修复上述问题。

摘录部分关键代码：

IEnumerator SmoothMap()
{
    for (int i = 0; i < smoothStep; i++)
    {
        SmoothMapStep();
        // 用新缓冲区来显示地图
        UpdateDisplayTexture(bufferNew);
        // 这一帧执行完毕，交换缓冲区
        (bufferNew, bufferOld) = (bufferOld, bufferNew);
        yield return new WaitForSeconds(STEP_DURATION);
    }
    _smoothMapCoroutine = null;
    byte[] bytes = _texture.EncodeToPNG();
    System.IO.File.WriteAllBytes(_imgPath, bytes);
}

void SmoothMapStep()
{
    for (int x = 0; x < width; x++)
    {
        for (int y = 0; y < height; y++)
        {
            // 检查8方向，如果周围的墙的数量大于4，那么就是墙，否则就是路
            int neighbourWallTiles = GetSurroundingWallCount(x, y);
            // 计算结果写入新缓冲区
            if (neighbourWallTiles > 4)
                bufferNew[x, y] = 1;
            else if (neighbourWallTiles < 4)
                bufferNew[x, y] = 0;

        }
    }
}

int GetSurroundingWallCount(int gridX, int gridY)
{
    int wallCount = 0;
    for (int neighbourX = gridX - 1; neighbourX <= gridX + 1; neighbourX++)
    {
        for (int neighbourY = gridY - 1; neighbourY <= gridY + 1; neighbourY++)
        {
            if (neighbourX >= 0 && neighbourX < width && neighbourY >= 0 && neighbourY < height)
            {
                if (neighbourX != gridX || neighbourY != gridY)
                {
                    // 从旧缓冲区取值进行计算
                    wallCount += bufferOld[neighbourX, neighbourY];
                }
            }
            else
            {
                wallCount++;
            }
        }
    }

    return wallCount;
}

引入双缓冲后，每格的状态严格由t-1时相邻格的状态决定，而不会像之前那样在运行中边读边写产生偏差。

我见

与其说双缓冲是一种设计模式，更不如说它是一种“处理边读边写”的解决方案。

源码

相关代码已上传至https://github.com/nickpansh/Unity-Design-Pattern

其他设计模式

专题 | Unity3D游戏开发中的设计模式 | 问渠 (wenqu.site)