CE_BVH.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME: CE_BVH.h ( CE Library, C++)
 *
 * COMMENTS: BVH class that runs on the GPU.
 */

 #ifndef __CE_BVH__
 #define __CE_BVH__
 
#include "CE_Context.h"
#include "CE_Array.h"
#include "CE_BufferDevice.h"

#include <UT/UT_UniquePtr.h>
#include <UT/UT_ValArray.h>

namespace tinybvh
{
    class BVH_GPU;
}

class CE_API CE_BVH
{
public:
    CE_BVH();
    ~CE_BVH();
    
    enum class PrimType
    {
        TRI,
        QUAD,
        TET,
        POINT
    };

    void build(const CE_Int32Array &trisingrp,
               const cl::Buffer &primptsidx,
               const cl::Buffer &primpts,
               const cl::Buffer &P,
               PrimType primtype = PrimType::TRI,
               bool refitTets = true);

    /// Convenience overload for point BVH — no prim connectivity needed.
    void buildPoints(const CE_Int32Array &pts, const cl::Buffer &P);

    /// Build a valid but empty point BVH.  All traversal queries return zero
    /// results immediately (the root node's child AABBs are at infinity so
    /// the distance check in BVH_TRAVERSE_BEGIN exceeds any finite threshold).
    /// All four kernel buffers (nodes, verts, idx, pts) are non-null so they
    /// can be bound to kernel arguments without error.
    void buildEmpty();

    void refit(const CE_Int32Array &trisingrp,
               const cl::Buffer &primptsidx,
               const cl::Buffer &primpts,
               const cl::Buffer &P);

    void clear();

    bool isBuilt() const;

    const cl::Buffer &nodeBuffer() const
            { return myBVHNodes.buffer(); }

    const cl::Buffer &verticesBuffer() const
            { return myVertices.buffer(); }

    const cl::Buffer &primIdxBuffer() const
            { return myPrimIdx.buffer(); }

    // For point BVH only: the selected point indices (subset→full mapping).
    // Empty for non-point BVH types. Passed to traverse_k_nearest_points
    // so it can translate BVH subset indices to full geometry point indices.
    const cl::Buffer &ptsBuffer() const
            { return myPts.buffer(); }

private:
    
    void updateVertices(const CE_Int32Array &tris,
                        const cl::Buffer &primptsidx,
                        const cl::Buffer &primpts,
                        const cl::Buffer &P);

    void buildDepthIndex(bool reverse = true);

    // These are copies of the tinybvh structs
    // that we need to know the size of, but we
    // don't want to include tinybvh.h in our
    // include files.
#ifdef _MSC_VER
    struct __declspec (align(16)) cebvhvec4
#else
    struct __attribute__((aligned(16))) cebvhvec4
#endif    
    {
        union { struct { float x, y, z, w; }; float cell[4]; };
    };

    struct cebvhvec3
    {
        union { struct { float x, y, z; }; float cell[3]; };
    };

    struct ceBVHNode
    {
        cebvhvec3 lmin; uint32_t left;
        cebvhvec3 lmax; uint32_t right;
        cebvhvec3 rmin; uint32_t triCount;
        cebvhvec3 rmax; uint32_t firstTri; // total: 64 bytes
    };

    UT_UniquePtr<tinybvh::BVH_GPU>              myBVH;
    CE_BufferDevice<ceBVHNode>                  myBVHNodes;
    CE_BufferDevice<cebvhvec4>                  myVertices;
    CE_UInt32Array                              myPrimIdx;
    CE_Int32Array                               myPts;  // point BVH only
    UT_IntArray                                 myDepthCounts;
    CE_Int32Array                               mySingleDepthCounts;
    CE_Int32Array                               mySingleDepthOffsets;
    CE_Int32Array                               myDepthIndex;
    cl::NDRange                                 myRefitRange;
    PrimType                                    myPrimType;
};

#endif