如何平滑 3D 体素世界的块？

在我的（类似 Minecraft）3D 体素世界中，我想要平滑形状以获得更自然的视觉效果。我们首先以 2D 形式来看这个示例。

左边是没有任何平滑处理的世界的样子。地形数据是二进制的，每个体素被渲染为单位大小的立方体。

在中心你可以看到一个朴素的圆形平滑。它只考虑四个直接相邻的块。看起来仍然不是很自然。此外，我希望出现平坦的 45 度斜坡。

在右边你可以看到我提出的平滑算法。为了得出块的形状，它考虑了八个直接和对角邻居。我有C++代码 https://github.com/danijar/voxel-smoothing-2d在线的。下面的代码给出了绘制贝塞尔曲线所沿的控制点。

#include <iostream>

using namespace std;
using namespace glm;


list<list<dvec2>> Points::find(ivec2 block)
{
    // Control points
    list<list<ivec2>> lines;
    list<ivec2> *line = nullptr;

    // Fetch blocks, neighbours start top left and count
    // around the center block clock wise
    int center = m_blocks->get(block);
    int neighs[8];
    for (int i = 0; i < 8; i++) {
        auto coord = blockFromIndex(i);
        neighs[i] = m_blocks->get(block + coord);
    }

    // Iterate over neighbour blocks
    for (int i = 0; i < 8; i++) {
        int current = neighs[i];
        int next = neighs[(i + 1) % 8];
        bool is_side   = (((i + 1) % 2) == 0);
        bool is_corner = (((i + 1) % 2) == 1);

        if (line) {
            // Border between air and ground needs a line
            if (current != center) {
                // Sides are cool, but corners get skipped when they don't
                // stop a line
                if (is_side || next == center)
                    line->push_back(blockFromIndex(i));
            } else if (center || is_side || next == center) {
                // Stop line since we found an end of the border. Always
                // stop for ground blocks here, since they connect over
                // corners so there must be open docking sites
                line = nullptr;
            }
        } else {
            // Start a new line for the border between air and ground that
            // just appeared. However, corners get skipped if they don't
            // end a line.
            if (current != center) {
                lines.emplace_back();
                line = &lines.back();
                line->push_back(blockFromIndex(i));
            }
        }
    }

    // Merge last line with first if touching. Only close around a differing corner for air
    // blocks.
    if (neighs[7] != center && (neighs[0] != center || (!center && neighs[1] != center))) {
        // Skip first corner if enclosed
        if (neighs[0] != center && neighs[1] != center)
            lines.front().pop_front();
        if (lines.size() == 1) {
            // Close circle
            auto first_point = lines.front().front();
            lines.front().push_back(first_point);
        } else {
            // Insert last line into first one
            lines.front().insert(lines.front().begin(), line->begin(), line->end());
            lines.pop_back();
        }
    }

    // Discard lines with too few points
    auto i = lines.begin();
    while (i != lines.end()) {
        if (i->size() < 2)
            lines.erase(i++);
        else
            ++i;
    }

    // Convert to concrete points for output
    list<list<dvec2>> points;
    for (auto &line : lines) {
        points.emplace_back();
        for (auto &neighbour : line)
            points.back().push_back(pointTowards(neighbour));
    }
    return points;
}

glm::ivec2 Points::blockFromIndex(int i)
{
    // Returns first positive representant, we need this so that the
    // conditions below "wrap around"
    auto modulo = [](int i, int n) { return (i % n + n) % n; };

    ivec2 block(0, 0);
    // For two indices, zero is right so skip
    if (modulo(i - 1, 4))
        // The others are either 1 or -1
        block.x = modulo(i - 1, 8) / 4 ? -1 : 1;
    // Other axis is same sequence but shifted
    if (modulo(i - 3, 4))
        block.y = modulo(i - 3, 8) / 4 ? -1 : 1;
    return block;
}

dvec2 Points::pointTowards(ivec2 neighbour)
{
    dvec2 point;
    point.x = static_cast<double>(neighbour.x);
    point.y = static_cast<double>(neighbour.y);

    // Convert from neighbour space into
    // drawing space of the block
    point *= 0.5;
    point += dvec2(.5);

    return point;
}

然而，这仍然是二维的。如何将这个算法转化为三维空间？

你可能应该看看行进立方体算法 http://en.wikipedia.org/wiki/Marching_cubes并从那里开始工作。您可以轻松控制生成的斑点的平滑度：

1. 想象一下，每个体素定义了一个场，其中心具有高密度，当您远离中心时慢慢消失到零。例如，您可以使用一个函数，该函数在体素内为 1，并在两个体素之外变为 0。无论您选择什么具体函数，请确保它仅在有限（最好是小）区域内非零。
2. 对于每个点，将所有场的密度相加。
3. 对这些字段的总和使用移动立方体算法
4. 使用高分辨率网格进行算法

为了改变外观/平滑度，您可以更改密度函数和行进立方体算法的阈值。行进立方体以创建更平滑的网格的可能扩展是以下想法：想象一下，您在立方体的边缘上遇到两个点，其中一个点位于体积内部（阈值之上），另一个点位于体积之外（阈值之下）。在这种情况下，许多行进立方体算法将边界恰好放置在边缘的中间。人们可以计算出精确的边界点——这消除了混叠。

我还建议您在此之后运行网格简化算法。使用行进立方体会导致网格中包含许多不必要的三角形。