Math 截锥剔除，实现

我目前正在尝试（再次）为我的世界实现截锥剔除。我的世界由大小为16x256x16（x，y，z）的块组成：

chunkc

保存整个

chunk

的坐标，例如

[0,0，-2]

。因此，为了得到块边界框，我必须将这些坐标乘以每个块的大小，以得到AABB的最小位置，并将大小添加到每个组件，以获得AABB的最大位置。然后我将这个AABB与平截头体进行对比

平截头体实现：

struct Frustum {
    enum {
        LEFT, /// Used to access the planes array.
        RIGHT, /// ditto
        BOTTOM, /// ditto
        TOP, /// ditto
        NEAR, /// ditto
        FAR /// ditto
    }

    Plane[6] planes; /// Holds all 6 planes of the frustum.

    @safe pure nothrow:

    @property ref Plane left() { return planes[LEFT]; }
    @property ref Plane right() { return planes[RIGHT]; }
    @property ref Plane bottom() { return planes[BOTTOM]; }
    @property ref Plane top() { return planes[TOP]; }
    @property ref Plane near() { return planes[NEAR]; }
    @property ref Plane far() { return planes[FAR]; }

    /// Constructs the frustum from a model-view-projection matrix.
    /// Params:
    /// mvp = a model-view-projection matrix
    this(mat4 mvp) {
        planes = [
            // left
            Plane(mvp[0][3] + mvp[0][0], // note: matrices are row-major
                mvp[1][3] + mvp[1][0],
                mvp[2][3] + mvp[2][0],
                mvp[3][3] + mvp[3][0]),

            // right
            Plane(mvp[0][3] - mvp[0][0],
                mvp[1][3] - mvp[1][0],
                mvp[2][3] - mvp[2][0],
                mvp[3][3] - mvp[3][0]),

            // bottom
            Plane(mvp[0][3] + mvp[0][1],
                mvp[1][3] + mvp[1][1],
                mvp[2][3] + mvp[2][1],
                mvp[3][3] + mvp[3][1]),
            // top
            Plane(mvp[0][3] - mvp[0][1],
                mvp[1][3] - mvp[1][1],
                mvp[2][3] - mvp[2][1],
                mvp[3][3] - mvp[3][1]),
            // near
            Plane(mvp[0][3] + mvp[0][2],
                mvp[1][3] + mvp[1][2],
                mvp[2][3] + mvp[2][2],
                mvp[3][3] + mvp[3][2]),
            // far
            Plane(mvp[0][3] - mvp[0][2],
                mvp[1][3] - mvp[1][2],
                mvp[2][3] - mvp[2][2],
                mvp[3][3] - mvp[3][2])
        ];

        normalize();
    }

    /// Constructs the frustum from 6 planes.
    /// Params:
    /// planes = the 6 frustum planes in the order: left, right, bottom, top, near, far.
    this(Plane[6] planes) {
        this.planes = planes;
        normalize();
    }

    private void normalize() {
        foreach(ref e; planes) {
            e.normalize();
        }
    }

    /// Checks if the $(I aabb) intersects with the frustum.
    /// Returns OUTSIDE (= 0), INSIDE (= 1) or INTERSECT (= 2).
    int intersects(AABB aabb) {
        vec3 hextent = aabb.half_extent;
        vec3 center = aabb.center;

        int result = INSIDE;
        foreach(plane; planes) {
            float d = dot(center, plane.normal);
            float r = dot(hextent, abs(plane.normal));

            if(d + r < -plane.d) {
                // outside
                return OUTSIDE;
            }
            if(d - r < -plane.d) {
            result = INTERSECT;
            }
        }

        return result;
    }

    /// Returns true if the $(I aabb) intersects with the frustum or is inside it.
    bool opBinaryRight(string s : "in")(AABB aabb) {
        return intersects(aabb) > 0;
    }
}

struct AABBT(type) {
        alias type at; /// Holds the internal type of the AABB.
        alias Vector!(at, 3) vec3; /// Convenience alias to the corresponding vector type.

        vec3 min = vec3(0.0f, 0.0f, 0.0f); /// The minimum of the AABB (e.g. vec3(0, 0, 0)).
        vec3 max = vec3(0.0f, 0.0f, 0.0f); /// The maximum of the AABB (e.g. vec3(1, 1, 1)).

        @safe pure nothrow:

        /// Constructs the AABB.
        /// Params:
        /// min = minimum of the AABB
        /// max = maximum of the AABB
        this(vec3 min, vec3 max) {
            this.min = min;
            this.max = max;
        }

        /// Constructs the AABB around N points (all points will be part of the AABB).
        static AABBT from_points(vec3[] points) {
            AABBT res;

            foreach(v; points) {
                res.expand(v);
            }

            return res;
        }

        /// Expands the AABB by another AABB.
        void expand(AABBT b) {
            if (min.x > b.min.x) min.x = b.min.x;
            if (min.y > b.min.y) min.y = b.min.y;
            if (min.z > b.min.z) min.z = b.min.z;
            if (max.x < b.max.x) max.x = b.max.x;
            if (max.y < b.max.y) max.y = b.max.y;
            if (max.z < b.max.z) max.z = b.max.z;
        }

        /// Expands the AABB, so that $(I v) is part of the AABB.
        void expand(vec3 v) {
            if (v.x > max.x) max.x = v.x;
            if (v.y > max.y) max.y = v.y;
            if (v.z > max.z) max.z = v.z;
            if (v.x < min.x) min.x = v.x;
            if (v.y < min.y) min.y = v.y;
            if (v.z < min.z) min.z = v.z;
        }


        /// Returns true if the AABBs intersect.
        /// This also returns true if one AABB lies inside another.
        bool intersects(AABBT box) const {
            return (min.x < box.max.x && max.x > box.min.x) &&
                (min.y < box.max.y && max.y > box.min.y) &&
                (min.z < box.max.z && max.z > box.min.z);
        }

        /// Returns the extent of the AABB (also sometimes called size).
        @property vec3 extent() const {
            return max - min;
        }

        /// Returns the half extent.
        @property vec3 half_extent() const {
            return 0.5 * (max - min);
        }

        /// Returns the area of the AABB.
        @property at area() const {
            vec3 e = extent;
            return 2.0 * (e.x * e.y + e.x * e.z + e.y * e.z);
        }

        /// Returns the center of the AABB.
        @property vec3 center() const {
            return 0.5 * (max + min);
        }

        /// Returns all vertices of the AABB, basically one vec3 per corner.
        @property vec3[] vertices() const {
            return [
                vec3(min.x, min.y, min.z),
                vec3(min.x, min.y, max.z),
                vec3(min.x, max.y, min.z),
                vec3(min.x, max.y, max.z),
                vec3(max.x, min.y, min.z),
                vec3(max.x, min.y, max.z),
                vec3(max.x, max.y, min.z),
                vec3(max.x, max.y, max.z),
            ];
        }

        bool opEquals(AABBT other) const {
            return other.min == min && other.max == max;
        }
    }

    alias AABBT!(float) AABB;

编辑2（示例输入）：

bool intersects2(AABB aabb) {
    foreach(plane; planes) {
        if(plane.a * aabb.min.x + plane.b * aabb.min.y + plane.c * aabb.min.z + plane.d > 0 )
            continue;
        if(plane.a * aabb.max.x + plane.b * aabb.min.y + plane.c * aabb.min.z + plane.d > 0 )
            continue;
        if(plane.a * aabb.min.x + plane.b * aabb.max.y + plane.c * aabb.min.z + plane.d > 0 )
            continue;
        if(plane.a * aabb.max.x + plane.b * aabb.max.y + plane.c * aabb.min.z + plane.d > 0 )
            continue;
        if(plane.a * aabb.min.x + plane.b * aabb.min.y + plane.c * aabb.max.z + plane.d > 0 )
            continue;
        if(plane.a * aabb.max.x + plane.b * aabb.min.y + plane.c * aabb.max.z + plane.d > 0 )
            continue;
        if(plane.a * aabb.min.x + plane.b * aabb.max.y + plane.c * aabb.max.z + plane.d > 0 )
            continue;
        if(plane.a * aabb.max.x + plane.b * aabb.max.y + plane.c * aabb.max.z + plane.d > 0 )
            continue;
        return false;
    }
    return true;
}

这是一个MVP：

[[1.18424,0,0.31849，-331.577]，
[0.111198,1.51016,-0.413468,-88.5585],
[0.251117,-0.274135,-0.933724,214.897],
[0.249864，-0.272768，-0.929067215.82]]

以及可能失败的AABB：

min:（14*16,0,13*16）
最大值：（14*16+16、256、13*16+16）

我发现您初始化

AABB

类的方式有问题。我不知道这是否是导致您出现问题的原因，但无论如何，它都值得修复（以防止有时意外使用损坏的初始化器）

对于默认的

AABB

（这似乎是从_points（）创建一个

开始的），两个角都设置为
（0,0,0）
——因此，以这种方式构造时，每个AABB必须包含原点

如果你必须像这样设置一个默认的
AABB
，你需要设置默认的
min=（无穷大，无穷大，无穷大）
和
max=（-infinity，-infinity，-infinity）
你的点积方法确实有效（做了一个小的测试），但在我看来，你的截头台设置不正确：

Frustum(engine.proj * engine.view)

而不是：

Frustum(engine.model * engine.view * engine.proj)

请注意模型矩阵的顺序和额外乘法，以便创建MVP矩阵。
好的，我现在有答案了。。。我没想到这是一件非常愚蠢的事

我按照“彼得·亚历山大”的建议，试着调试一切。。。我最终发现截头体平面完全错误（左平面和右平面法线指向同一方向），所以我把代码和其他示例代码弄乱了，发现矩阵没有被转置（我将其存储为row major，opengl存储为column.major），所以一个简单的：
mvp.transpose（）
在平截头体中修复我的平截头体

感谢您的帮助。
哪一行没有给出您期望的结果？这是第一个代码，如果您需要一行代码，它不会按应有的方式进行筛选：
if（平截头体中的aabb）
给出错误的结果。对。函数中的哪一行没有给出您期望的结果？你只需要深入研究，找出问题出在哪里，一个函数接一个函数。调试没有什么神奇之处。这就是我过去两天所做的。问题是，在我看来一切都是正确的。因此，我希望有人看到了问题，例如，可能我在错误的空间使用了坐标（我能想到的一件事）其他一切似乎都很好，例如，我还实施了3种不同的方法来确定AABB是在内部还是外部（所有方法都有相同的结果）。我的知识到此为止，这就是为什么我这么问，因为这里有更多的人/其他知识。一切都不可能是正确的。
相交处的一个平面必须返回外部。哪一个？什么是点产品？他们是你所期望的吗？如果没有，为什么没有。谢谢，这应该更改，但不幸的是，这不是问题的解决方案，因为我从未使用过
。从_points
，我打印了AABBs以检查它们是否正确，例如：
[304,0336][320256352]
其中第一个是
min
，第二个是
max
。所以我应该这样设置我的平截头体：
自动平截头体=平截头体（engine.view*engine.proj）
（我的模型矩阵从不改变，它始终是一个单位矩阵）。我试过了，现在几乎每个AABB都被标记为“外部”。因为他使用的是OpenGL，所以转换必须向后执行，因此投影矩阵*视图矩阵。这是因为GL使用列主存储。
Frustum(engine.model * engine.view * engine.proj)