NurbsPerformer/include/device/Nurbs/nurbs_surface.cuh

//
// Created by 14727 on 2022/12/9.
//

#ifndef NURBSEVALUATOR_NURBS_SURFACE_CUH
#define NURBSEVALUATOR_NURBS_SURFACE_CUH

#include <vector>
#include "cuda_runtime.h"
#include "bvh.cuh"

namespace NurbsSurface {
    const int POINT_SIZE = 4;
    /**
     * 曲线计算的核函数
     * @param d_pointSize 点的大小(3: [x, y, z] | 4：[x, y, z, w])
     */
    __global__ static void
    g_evaluate(float *res, const float *d_nTexture_u, const float *d_nTexture_v, const float *d_points,
               int d_pointsCnt_u, int d_pointsCnt_v, int d_pointSize, float d_lastKnot_u, float d_lastKnot_v,
               int d_sampleCnt_u, int d_sampleCnt_v);

    __global__ static void
    g_derivative(float *derivatives, float *normals, const float *derTexture_u, const float *derTexture_v,
                 const float *nTexture_u, const float *nTexture_v, const float *d_points, int d_pointsCnt_u,
                 int d_pointsCnt_v, int d_pointSize, float d_lastKnot_u, float d_lastKnot_v, int d_sampleCnt_u,
                 int d_sampleCnt_v);

    __global__ static void
    g_curvature(const float *derivatives, int sampleCnt_u, int sampleCnt_v, float lastKnot_u, float lastKnot_v,
                float *ms, float *k);

    class Surface {
    private:
        std::vector<std::vector<std::vector<float>>> controlPoints;
        float *d_points;
        std::vector<float> knots_u;
        std::vector<float> knots_v;
        float *d_knots_u;
        float *d_knots_v;
        bool recordTime;

        float *d_nTexture_u;   // u方向指向度为p时的device中的nurbs基函数矩阵
        float *d_nTexture_v;   // v方向指向度为p时的device中的nurbs基函数矩阵
        float *d_nTexture1_u;   // u方向指向度为p-1时的device中的nurbs基函数矩阵
        float *d_nTexture1_v;   // v方向指向度为p-1时的device中的nurbs基函数矩阵

        float *d_evaluationRes;  // evaluation结果
        float *d_derivatives;  // 一阶导计算结果
        float *d_normals;
        float *d_k;  // 最大曲率

    public:
        BVH bvh;
        BVH gauss_map;
        /**
         * 构造函数
         * @param controlPoints 控制点矩阵[pointsCnt_u][pointsCnt_v][3]
         * @param knots_u u方向knots
         * @param knots_v v方向knots
         */
        __host__ explicit Surface(std::vector<std::vector<std::vector<float>>> controlPoints,
                                  std::vector<float> knots_u, std::vector<float> knots_v);

        /**
         * 供外部CPU程序使用的、负责调用gpu并行计算的方法
         * @param sampleCnt_u u方向采样数目
         * @param sampleCnt_v v方向采样数目
         * @return 由 map 组成的vector{<<u, v>, {x, y, z}>}
         */
        __host__ std::vector<std::vector<std::vector<float>>>
        evaluate(int sampleCnt_u_, int sampleCnt_v_);

        /**
         * 供外部CPU程序使用的、负责调用gpu并行计算切向量的方法
         */
        __host__ void derivative(int sampleCnt_u, int sampleCnt_v);

        /**
         * 供外部CPU程序使用的、负责调用gpu并行计算二阶导的方法
         */
        __host__ void curvature(int sampleCnt_u, int sampleCnt_v);

        /**
         * 供外部CPU程序使用的、负责调用gpu并行计算BVH的方法
         */
        __host__ void buildBHV(int layerCnt, bool useK = false);

        /**
         * 供外部CPU程序使用的、负责调用gpu并行计算Gauss Map Tree的方法
         */
        __host__ void buildGaussMap(int layerCnt);


        void setRecordTime(bool r);

        ~Surface();

    };

    __host__ void recursiveGetOverlapLeafNodes(const BVH &bvh1, const BVH &bvh2, int idx1, int idx2,
                                                      std::vector<std::pair<int, int>> &pairs);

    __host__ std::vector<std::pair<int, int>> getOverlappedLeafNodes(const BVH &bvh1, const BVH &bvh2);

    /**
     * 判断两个曲面的Gauss Map在指定的、各自的参数范围内有没有交
     * @param idxRange_u1 第一个gauss map的参数u范围对应的u方向上的采样网格的格子下标范围
     * @param idxRange_v1 第一个gauss map的参数v范围对应的u方向上的采样网格的格子下标范围
     * @param idxRange_u2 第而个gauss map的参数u范围对应的u方向上的采样网格的格子下标范围
     * @param idxRange_v2 第二个gauss map的参数v范围对应的u方向上的采样网格的格子下标范围
     * @return true:gauss map的包围盒有交集，说明gauss map<可能>有重合；false: gauss map一定没有重合
     */
    __host__ bool isGaussMapsOverlapped(const BVH &gm1, const BVH &gm2, std::pair<int, int> idxRange_u1,
                                               std::pair<int, int> idxRange_v1, std::pair<int, int> idxRange_u2,
                                               std::pair<int, int> idxRange_v2);
    /**
     * 判断两个曲面的Gauss Map在指定的、各自的参数范围内有没有交
     * @param range_u1 第一个gauss map的参数u范围
     * @param range_v1 第一个gauss map的参数v范围
     * @param range_u2 第二个gauss map的参数u范围
     * @param range_v2 第二个gauss map的参数v范围
     * @param paramRange_u1 第一个gauss map的参数u定义域
     * @param paramRange_v1 第一个gauss map的参数v定义域
     * @param paramRange_u2 第二个gauss map的参数u定义域
     * @param paramRange_v2 第二个gauss map的参数v定义域
     * @return true:gauss map的包围盒有交集，说明gauss map<可能>有重合；false: gauss map一定没有重合
     */
    __host__ bool isGaussMapsOverlapped(const BVH &gm1, const BVH &gm2, std::pair<float, float> range_u1,
                                               std::pair<float, float> range_v1, std::pair<float, float> range_u2,
                                               std::pair<float, float> range_v2, std::pair<float, float> paramRange_u1,
                                               std::pair<float, float> paramRange_v1,
                                               std::pair<float, float> paramRange_u2,
                                               std::pair<float, float> paramRange_v2);
}


#endif //NURBSEVALUATOR_NURBS_SURFACE_CUH