ViewDesignEngine/tests/gpu/test_gpu_acceleration.cpp

/**
 * @file test_gpu_acceleration.cpp
 * @brief GPU 加速模块测试（8 项）
 *
 * 测试覆盖：
 *   1. gpu_available — 检测 CUDA 可用性
 *   2. gpu_marching_cubes — SDF → 网格（球体）
 *   3. gpu_marching_cubes — 低分辨率
 *   4. gpu_marching_cubes — 立方体 SDF
 *   5. gpu_mesh_simplify — 基本简化
 *   6. gpu_mesh_simplify — 微小 target_ratio
 *   7. gpu_boolean_intersect — 两个相交球体
 *   8. gpu_boolean_intersect — 不相交网格
 */

#include "vde/gpu/gpu_acceleration.h"
#include "vde/mesh/marching_cubes.h"
#include "vde/mesh/halfedge_mesh.h"
#include <gtest/gtest.h>
#include <cmath>
#include <memory>

using namespace vde::gpu;
using vde::core::AABB3D;
using vde::core::Point3D;
using vde::core::Vector3D;
using vde::mesh::HalfedgeMesh;

// ── 帮助函数 ─────────────────────────────────────────────────────

/// 创建一个简单球体 SDF 函数
static auto make_sphere_sdf(double cx, double cy, double cz, double r) {
    return [=](double x, double y, double z) -> double {
        return std::sqrt((x - cx) * (x - cx) + (y - cy) * (y - cy) + (z - cz) * (z - cz)) - r;
    };
}

/// 创建立方体 SDF 函数
static auto make_box_sdf(double hx, double hy, double hz) {
    return [=](double x, double y, double z) -> double {
        double dx = std::abs(x) - hx, dy = std::abs(y) - hy, dz = std::abs(z) - hz;
        return std::sqrt(std::max(dx, 0.0) * std::max(dx, 0.0) +
                         std::max(dy, 0.0) * std::max(dy, 0.0) +
                         std::max(dz, 0.0) * std::max(dz, 0.0)) +
               std::min(std::max({dx, dy, dz}), 0.0);
    };
}

/// 快速创建简单三角网格（正四面体）
static HalfedgeMesh make_tetrahedron(double ox, double oy, double oz, double s) {
    HalfedgeMesh mesh;
    std::vector<Point3D> verts = {
        {ox, oy + s, oz},
        {ox - s * 0.866, oy, oz - s * 0.5},
        {ox + s * 0.866, oy, oz - s * 0.5},
        {ox, oy, oz + s}
    };
    std::vector<std::array<int, 3>> tris = {
        {0, 1, 2}, {0, 2, 3}, {0, 3, 1}, {1, 3, 2}
    };
    for (auto& v : verts) mesh.add_vertex(v);
    for (auto& t : tris) mesh.add_face({t[0], t[1], t[2]});
    return mesh;
}

/// 验证网格基本有效性
static void expect_valid_mesh(const HalfedgeMesh& mesh) {
    EXPECT_GT(mesh.num_vertices(), 0u);
    EXPECT_GT(mesh.num_faces(), 0u);
    EXPECT_GT(mesh.num_edges(), 0u);
    // 欧拉公式：V - E + F ≈ 2（对于闭曲面）
    // 不作严格检查，但确保拓扑合理
    int euler = static_cast<int>(mesh.num_vertices()) -
                static_cast<int>(mesh.num_edges()) +
                static_cast<int>(mesh.num_faces());
    EXPECT_GE(euler, 0) << "Euler characteristic should be non-negative";
}

// ======================================================================
//  测试 1：gpu_available
// ======================================================================
TEST(GpuAcceleration, GpuAvailable) {
    // 无论 CUDA 是否可用，函数必须不崩溃并返回布尔值
    bool avail = gpu_available();
    EXPECT_TRUE(avail == true || avail == false);
#if VDE_USE_CUDA
    // CUDA 编译时开启 → 运行时至少应无错误
    // （CUDA 设备可能为 0，但调用不崩溃）
    SUCCEED() << "CUDA compiled in, runtime detection: " << (avail ? "YES" : "NO");
#else
    EXPECT_FALSE(avail) << "Without CUDA build, gpu_available must return false";
#endif
}

// ======================================================================
//  测试 2：gpu_marching_cubes — 球体 SDF
// ======================================================================
TEST(GpuAcceleration, MarchingCubesSphere) {
    auto sdf = make_sphere_sdf(0, 0, 0, 1.0);
    AABB3D bounds({-1.5, -1.5, -1.5}, {1.5, 1.5, 1.5});

    HalfedgeMesh mesh = gpu_marching_cubes(sdf, bounds, 32);

    expect_valid_mesh(mesh);

    // 球体应当构成闭曲面
    EXPECT_GE(mesh.num_faces(), 50u) << "Low-res sphere should have at least 50 faces";

    // 所有顶点应大致在球体表面上
    for (size_t i = 0; i < mesh.num_vertices(); ++i) {
        const auto& p = mesh.vertex(i);
        double dist = std::sqrt(p.x() * p.x() + p.y() * p.y() + p.z() * p.z());
        EXPECT_NEAR(dist, 1.0, 0.15) << "Vertex " << i << " distance from origin";
    }
}

// ======================================================================
//  测试 3：gpu_marching_cubes — 低分辨率
// ======================================================================
TEST(GpuAcceleration, MarchingCubesLowRes) {
    auto sdf = make_sphere_sdf(0, 0, 0, 1.0);
    AABB3D bounds({-1.2, -1.2, -1.2}, {1.2, 1.2, 1.2});

    HalfedgeMesh mesh = gpu_marching_cubes(sdf, bounds, 8);

    // 极低分辨率仍有输出
    EXPECT_GT(mesh.num_vertices(), 0u);
    EXPECT_GT(mesh.num_faces(), 0u);
}

// ======================================================================
//  测试 4：gpu_marching_cubes — 立方体 SDF
// ======================================================================
TEST(GpuAcceleration, MarchingCubesBox) {
    auto sdf = make_box_sdf(1.0, 0.5, 0.3);
    AABB3D bounds({-1.5, -1.0, -0.8}, {1.5, 1.0, 0.8});

    HalfedgeMesh mesh = gpu_marching_cubes(sdf, bounds, 24);

    expect_valid_mesh(mesh);

    // 检查包围盒尺寸与预期一致
    auto bb = mesh.bounds();
    double max_dim = std::max({bb.extent().x(), bb.extent().y(), bb.extent().z()});
    EXPECT_GT(max_dim, 0.5);
    EXPECT_LT(max_dim, 4.0);
}

// ======================================================================
//  测试 5：gpu_mesh_simplify — 基本简化
// ======================================================================
TEST(GpuAcceleration, MeshSimplifyBasic) {
    auto sdf = make_sphere_sdf(0, 0, 0, 1.0);
    AABB3D bounds({-1.5, -1.5, -1.5}, {1.5, 1.5, 1.5});

    HalfedgeMesh original = gpu_marching_cubes(sdf, bounds, 32);
    size_t orig_faces = original.num_faces();
    EXPECT_GT(orig_faces, 0u);

    // 简化为 50% 面数
    HalfedgeMesh simplified = gpu_mesh_simplify(original, 0.5f);

    expect_valid_mesh(simplified);

    // 简化后面数应减少
    EXPECT_LE(simplified.num_faces(), orig_faces)
        << "Simplified mesh should have ≤ original face count";
}

// ======================================================================
//  测试 6：gpu_mesh_simplify — 极低 target_ratio
// ======================================================================
TEST(GpuAcceleration, MeshSimplifyTinyRatio) {
    auto sdf = make_sphere_sdf(0, 0, 0, 1.0);
    AABB3D bounds({-1.5, -1.5, -1.5}, {1.5, 1.5, 1.5});

    HalfedgeMesh original = gpu_marching_cubes(sdf, bounds, 20);
    ASSERT_GT(original.num_faces(), 10u);

    // target_ratio = 0.1 (极低比例)
    HalfedgeMesh simplified = gpu_mesh_simplify(original, 0.1f);

    // 不应崩溃且至少保留一些面
    EXPECT_GT(simplified.num_vertices(), 3u);
    EXPECT_GT(simplified.num_faces(), 1u);
    EXPECT_LT(simplified.num_faces(), original.num_faces());
}

// ======================================================================
//  测试 7：gpu_boolean_intersect — 两个相交球体
// ======================================================================
TEST(GpuAcceleration, BooleanIntersectIntersecting) {
    // 两个相交球体（中心相距 1.0，半径各 1.2）
    auto sdf_a = make_sphere_sdf(-0.5, 0, 0, 1.2);
    auto sdf_b = make_sphere_sdf(0.5, 0, 0, 1.2);
    AABB3D bounds({-2.0, -1.5, -1.5}, {2.0, 1.5, 1.5});

    HalfedgeMesh mesh_a = gpu_marching_cubes(sdf_a, bounds, 24);
    HalfedgeMesh mesh_b = gpu_marching_cubes(sdf_b, bounds, 24);

    ASSERT_GT(mesh_a.num_faces(), 0u);
    ASSERT_GT(mesh_b.num_faces(), 0u);

    HalfedgeMesh result = gpu_boolean_intersect(mesh_a, mesh_b);

    // 交集存在 → 非空输出
    EXPECT_GT(result.num_vertices(), 0u) << "Intersection of overlapping spheres should not be empty";
}

// ======================================================================
//  测试 8：gpu_boolean_intersect — 不相交网格
// ======================================================================
TEST(GpuAcceleration, BooleanIntersectDisjoint) {
    // 两个远距离球体（中心相距 10，半径各 1）
    auto sdf_a = make_sphere_sdf(-5, 0, 0, 1.0);
    auto sdf_b = make_sphere_sdf(5, 0, 0, 1.0);
    AABB3D bounds({-6.5, -1.5, -1.5}, {6.5, 1.5, 1.5});

    HalfedgeMesh mesh_a = gpu_marching_cubes(sdf_a, bounds, 20);
    HalfedgeMesh mesh_b = gpu_marching_cubes(sdf_b, bounds, 20);

    ASSERT_GT(mesh_a.num_faces(), 0u);
    ASSERT_GT(mesh_b.num_faces(), 0u);

    HalfedgeMesh result = gpu_boolean_intersect(mesh_a, mesh_b);

    // 不相交 → 空输出（0 顶点或 0 面）
    // 不要求严格为 0，但不应有大量三角形
    EXPECT_LE(result.num_faces(), mesh_a.num_faces() / 2u)
        << "Disjoint meshes should have few or no intersection faces";
}

// ======================================================================
//  额外测试：空网格安全
// ======================================================================
TEST(GpuAcceleration, EmptyMeshSafety) {
    HalfedgeMesh empty;

    // simplify 空网格不崩溃
    HalfedgeMesh r1 = gpu_mesh_simplify(empty, 0.5f);
    EXPECT_EQ(r1.num_vertices(), 0u);
    EXPECT_EQ(r1.num_faces(), 0u);

    // boolean intersect 空网格不崩溃
    auto sdf = make_sphere_sdf(0, 0, 0, 1.0);
    AABB3D bounds({-1.5, -1.5, -1.5}, {1.5, 1.5, 1.5});
    HalfedgeMesh sphere = gpu_marching_cubes(sdf, bounds, 16);

    HalfedgeMesh r2 = gpu_boolean_intersect(empty, sphere);
    EXPECT_EQ(r2.num_faces(), 0u);

    HalfedgeMesh r3 = gpu_boolean_intersect(sphere, empty);
    EXPECT_EQ(r3.num_faces(), 0u);
}