bool should_draw_chunk(glm::vec2 chunk_world_offset, glm::vec2 chunk_size, const Camera3D::Frustum& view_frustum) {
    glm::vec2 min = chunk_world_offset;
    glm::vec2 max = chunk_world_offset + chunk_size;

    std::array<glm::vec3, 4> corners = {
        glm::vec3(min.x, 0.0f, min.y),
        glm::vec3(min.x, 0.0f, max.y),
        glm::vec3(max.x, 0.0f, min.y),
        glm::vec3(max.x, 0.0f, max.y),
        /* glm::vec3(min.x, -10.0f, min.y),
        glm::vec3(min.x, -10.0f, max.y),
        glm::vec3(max.x, -10.0f, min.y),
        glm::vec3(max.x, -10.0f, max.y) */
    };

    auto plane_test = [&](const Camera3D::Plane& plane) {
        // If all corners are outside this plane, the chunk is culled
        for (auto& c : corners) {
            float dist = glm::dot(plane.normal, c) - plane.distance;
            if (dist >= 0.0f) {
                return true; // at least one corner inside
            }
        }
        return false; // all outside
    };

    if (!plane_test(view_frustum.left_face))  return false;
    if (!plane_test(view_frustum.right_face)) return false;
    if (!plane_test(view_frustum.near_face))  return false;
    if (!plane_test(view_frustum.far_face))   return false;

    return true;
}




Camera3D::Camera3D(u32 width, u32 height, glm::vec3 position, glm::mat4 projection, float fov_y, float near, float far)
: projection(projection), width(width), height(height), position(position), yaw(glm::radians(-90.0f)), pitch(0.0f), fov_y(fov_y), near(near), far(far) {}

Camera3D::Frustum Camera3D::create_frustum() const {
    Frustum frustum;
    const float halfVSide = far * std::tanf(fov_y * 0.5f);
    const float halfHSide = halfVSide * (float(width) / float(height));
    const glm::vec3 forward = get_forward();
    const glm::vec3 right = glm::cross(forward, up);
    const glm::vec3 frontMultFar = far * forward;

    frustum.near_face = { position + near * forward, forward };
    frustum.far_face = { position + frontMultFar, -forward };
    frustum.right_face = { position,
                            glm::cross(frontMultFar - right * halfHSide, up) };
    frustum.left_face = { position,
                            glm::cross(up,frontMultFar + right * halfHSide) };
    frustum.top_face = { position,
                            glm::cross(right, frontMultFar - up * halfVSide) };
    frustum.bottom_face = { position,
                            glm::cross(frontMultFar + up * halfVSide, right) };

    return frustum;
}




struct Plane {
    glm::vec3 normal = { 0.0f, 1.0f, 0.0f };
    float distance = 0.0f;

    Plane() {}

    Plane(const glm::vec3& point, const glm::vec3& normal)
    : normal(glm::normalize(normal)), distance(glm::dot(this->normal, point)) {}
};

struct Frustum {
    Plane top_face;
    Plane bottom_face;

    Plane right_face;q
    Plane left_face;

    Plane far_face;
    Plane near_face;
};