BVHBuilder.h

Go to the documentation of this file.

 
#ifndef BVH_BUILDER_H
#define BVH_BUILDER_H
 
#include "RayTracingTypes.h"
#include "global.h"
#include <vector>
#include <cstdint>
 
namespace helios {
 
    struct BVHNode {
        float aabb_min[3]; 
        float aabb_max[3]; 
        uint32_t left_child; 
        uint32_t right_child; 
        uint32_t prim_count; 
        uint32_t prim_type; 
        uint32_t first_prim; 
        uint32_t split_axis; 
    };
 
    static_assert(sizeof(BVHNode) == 48, "BVHNode must be exactly 48 bytes");
 
    struct CWBVH_Node {
        float p[3]; 
        uint32_t e_packed; 
 
        // Quantized child AABBs (48 bytes total)
        uint8_t qmin_x[8];
        uint8_t qmin_y[8];
        uint8_t qmin_z[8];
        uint8_t qmax_x[8];
        uint8_t qmax_y[8];
        uint8_t qmax_z[8];
 
        // Metadata (16 bytes)
        uint8_t imask; 
        uint8_t meta[7]; 
        uint32_t base_index_child; 
        uint32_t base_index_triangle; 
 
        // Extended leaf data (48 bytes) - per-child primitive info
        uint32_t child_first_prim[8]; 
        uint8_t child_prim_count[8]; 
        uint8_t child_prim_type[8]; 
    };
 
    static_assert(sizeof(CWBVH_Node) == 128, "CWBVH_Node must be exactly 128 bytes");
 
    struct AABB {
        helios::vec3 min;
        helios::vec3 max;
 
        void expand(const AABB &other) {
            min.x = std::min(min.x, other.min.x);
            min.y = std::min(min.y, other.min.y);
            min.z = std::min(min.z, other.min.z);
            max.x = std::max(max.x, other.max.x);
            max.y = std::max(max.y, other.max.y);
            max.z = std::max(max.z, other.max.z);
        }
 
        float surfaceArea() const {
            helios::vec3 d = max - min;
            return 2.0f * (d.x * d.y + d.y * d.z + d.z * d.x);
        }
 
        helios::vec3 centroid() const {
            return (min + max) * 0.5f;
        }
    };
 
    struct PrimitiveRef {
        uint32_t prim_index; 
        uint32_t prim_type; 
        AABB bounds; 
    };
 
    class BVHBuilder {
    public:
        std::vector<BVHNode> build(const RayTracingGeometry &geometry);
 
        const std::vector<uint32_t> &getPrimitiveIndices() const {
            return primitive_indices;
        }
 
        std::vector<CWBVH_Node> convertToCWBVH(const std::vector<BVHNode> &bvh2_nodes);
 
    private:
        struct BuildNode {
            AABB bounds; 
            BuildNode *left = nullptr; 
            BuildNode *right = nullptr; 
            uint32_t first_prim_offset = 0; 
            uint32_t prim_count = 0; 
            uint32_t prim_type = 0; 
            uint32_t split_axis = 0; 
        };
 
        // Temporary data during construction
        std::vector<PrimitiveRef> primitive_refs; 
        std::vector<uint32_t> primitive_indices; 
        std::vector<BuildNode *> allocated_nodes; 
 
        const RayTracingGeometry *geometry = nullptr; 
        std::vector<uint32_t> type_offsets; 
 
        // BVH construction parameters
        static constexpr uint32_t MAX_PRIMS_PER_LEAF = 4; 
        static constexpr uint32_t MAX_DEPTH = 32; 
        static constexpr uint32_t NUM_BINS = 16; 
 
        AABB computePrimitiveAABB(uint32_t prim_index, uint32_t prim_type) const;
 
        AABB computePatchAABB(uint32_t prim_index) const;
 
        AABB computeTriangleAABB(uint32_t prim_index) const;
 
        AABB computeDiskAABB(uint32_t prim_index) const;
 
        AABB computeTileAABB(uint32_t prim_index) const;
 
        AABB computeVoxelAABB(uint32_t prim_index) const;
 
        AABB computeBBoxAABB(uint32_t prim_index) const;
 
        helios::vec3 transformPoint(const float *transform, const helios::vec3 &point) const;
 
        BuildNode *recursiveBuild(std::vector<PrimitiveRef> &refs, uint32_t start, uint32_t end, uint32_t depth);
 
        bool partitionSAH(std::vector<PrimitiveRef> &refs, uint32_t start, uint32_t end, const AABB &bounds, uint32_t &mid, uint32_t &axis);
 
        BuildNode *createLeaf(std::vector<PrimitiveRef> &refs, uint32_t start, uint32_t end);
 
        uint32_t flattenTree(BuildNode *node, std::vector<BVHNode> &nodes);
 
        void cleanup();
 
        // ========== CWBVH Conversion Methods ==========
 
        BuildNode *reconstructTree(const std::vector<BVHNode> &bvh2_nodes, uint32_t node_idx = 0);
 
        struct BVH8Node {
            AABB aabb;
            BuildNode *children[8]; // Points to BVH2 BuildNodes
            bool is_leaf[8];
            uint32_t first_prim[8];
            uint32_t prim_count[8];
            uint32_t prim_type[8];
 
            BVH8Node() {
                for (int i = 0; i < 8; i++) {
                    children[i] = nullptr;
                    is_leaf[i] = false;
                    first_prim[i] = 0;
                    prim_count[i] = 0;
                    prim_type[i] = 0;
                }
            }
        };
 
        BVH8Node *collapseToBVH8(BuildNode *bvh2_node, int depth = 0);
 
        void assignChildrenToOctants(BVH8Node *node8, std::vector<BuildNode *> &children);
 
        void compressNode(const BVH8Node *src, CWBVH_Node &dst);
 
        uint32_t flattenBVH8(BVH8Node *root, std::vector<CWBVH_Node> &cwbvh_nodes);
 
        // Temporary storage for CWBVH conversion
        std::vector<BVH8Node *> allocated_bvh8_nodes;
    };
 
} // namespace helios
 
#endif // BVH_BUILDER_H