embree_raytracer.h

Go to the documentation of this file.

 
 
#pragma once
#ifndef EMBREE_RAY_TRACER
#define EMBREE_RAY_TRACER
 
#include <rpc.h>
#include <rtcore.h>
 
#include <corecrt_math_defines.h>
#include <vector>
#include <array>
#include <HitStruct.h>
#define _USE_MATH_DEFINES
 
namespace HF::Geometry {
    template <typename T> class MeshInfo;
}
 
namespace HF::RayTracer {
    struct Vector3D {
        double x; double y; double z;
 
        inline Vector3D::Vector3D(double x, double y, double z) {
            this->x = x;
            this->y = y;
            this->z = z;
 
        }
        inline Vector3D operator-(const Vector3D& v2) const {
            return Vector3D{
                x - v2.x,
                y - v2.y,
                z - v2.z
            };
        }
        // Scalar multiplication overload 
        inline Vector3D operator*(const double&a) const {
            return Vector3D{
                a * x,
                a * y,
                a * z
            };
        }
    };
 
    //*! \brief Determine whether this mesh did or did not intersect */
    bool DidIntersect(int mesh_id);
 
    struct RayRequest;
    struct Vertex;
    struct Triangle;
 
    class EmbreeRayTracer {
        RTCDevice device; 
        RTCScene scene;
        RTCIntersectContext context;
        Triangle* triangles;
        Vertex* Vertices;
 
        bool use_precise = false; 
 
        std::vector<RTCGeometry> geometry; //> A list of the geometry being used by RTCScene.
 
    private:
        void SetupScene();
 
        std::array<Vector3D, 3> GetTriangle(unsigned int geomID, unsigned int primID) const;
 
        int InsertGeom(RTCGeometry& geom, int id = -1);
 
    double CalculatePreciseDistance(
            unsigned int geom_id,
            unsigned int prim_id,
            const Vector3D& origin,
            const Vector3D& direction) const;
 
 
        RTCRayHit Intersect_IMPL(
            float x,
            float y,
            float z,
            float dx,
            float dy,
            float dz,
            float max_distance = -1,
            int mesh_id = -1
        );
 
 
        bool Occluded_IMPL(
            float x,
            float y,
            float z,
            float dx,
            float dy,
            float dz,
            float distance = -1,
            int mesh_id = -1
        );
        
 
 
        bool Occluded_IMPL(
            const std::array<float, 3>& origin,
            const std::array<float, 3>& direction,
            float max_dist = -1
        );
 
        RTCGeometry ConstructGeometryFromBuffers(std::vector<Triangle>& tris, std::vector<Vertex>& verts);
 
    public:
        EmbreeRayTracer(bool use_precise = false);
 
 
        EmbreeRayTracer(std::vector<HF::Geometry::MeshInfo<float>>& MI, bool use_precise_intersection = false);
 
        EmbreeRayTracer(HF::Geometry::MeshInfo<float>& MI, bool use_precise = false);
 
 
        EmbreeRayTracer(const EmbreeRayTracer& ERT2);
 
 
        
 
        EmbreeRayTracer(const std::vector<std::array<float, 3>>& geometry);
 
 
        bool AddMesh(std::vector<std::array<float, 3>>& Mesh, int ID, bool Commit = false);
 
 
        bool AddMesh(HF::Geometry::MeshInfo<float>& Mesh, bool Commit);
 
 
        bool AddMesh(std::vector<HF::Geometry::MeshInfo<float>>& Meshes, bool Commit = true);
 
 
        bool PointIntersection(
            std::array<float, 3>& origin,
            const std::array<float, 3>& dir,
            float distance = -1,
            int mesh_id = -1
        );
 
 
        bool PointIntersection(
            float& x,
            float& y,
            float& z,
            float dx,
            float dy,
            float dz,
            float distance = -1,
            int mesh_id = -1
        );
 
 
        std::vector<char> PointIntersections(
            std::vector<std::array<float, 3>>& origins,
            std::vector<std::array<float, 3>>& directions,
            bool use_parallel = true,
            float max_distance = -1,
            int mesh_id = -1
        );
 
 
 
 
        std::vector<char> Occlusions(
            const std::vector<std::array<float, 3>>& origins,
            const std::vector<std::array<float, 3>>& directions,
            float max_distance = -1
            , bool use_parallel = true
        );
 
 
        template <typename return_type = double, class N, class V>
        HitStruct<return_type> Intersect(
            const N& node,
            const V& direction,
            float max_distance = -1.0f, int mesh_id = -0.1f)
        {
            return Intersect<return_type>(node[0], node[1], node[2], direction[0], direction[1], direction[2], max_distance, mesh_id);
        }
 
        template <typename return_type = double, typename numeric1 = double, typename numeric2 = double>
        HitStruct<return_type> Intersect(
                numeric1 x, numeric1 y, numeric1 z,
                numeric2 dx, numeric2 dy, numeric2 dz,
                float distance = -1.0f, int mesh_id = -1)
        {
            // create output value
            HitStruct<return_type> out_struct;
 
            // Cast the ray
            auto result = Intersect_IMPL(
                x,y,z,
                dx,dy,dz, distance, mesh_id
            );
 
            // If an intersection occured, update the struct. 
            if (DidIntersect(result.hit.geomID))
            {
                // Use a precise ray intersection if required
                if (!(this->use_precise))
                    out_struct.distance = result.ray.tfar;
                else
                    out_struct.distance = CalculatePreciseDistance(
                        result.hit.geomID,
                        result.hit.primID,
                        Vector3D(x,y,z),
                        Vector3D(dx,dy,dz)
                    );
                out_struct.meshid = result.hit.geomID;
            }
 
            return out_struct;
        }
 
 
        template <typename N, typename V, typename return_type>
        bool IntersectOutputArguments(
            const N& node,
            const V& direction,
            return_type& out_distance,
            int& out_meshid,
            float max_distance = -1.0f)
        {
            HitStruct<return_type> result = Intersect<return_type>(node, direction, max_distance);
            if (result.DidHit()) {
                out_distance = result.distance;
                out_meshid = result.meshid;
                return true;
            }
            else
                return false;
        }
        
        template <typename return_type, typename N, typename V>
        inline std::vector<HitStruct<return_type>> Intersections(
            const N & nodes,
            const V & directions,
            float max_distance = -1.0f,
            const bool use_parallel = false)
        {
            const int n = nodes.size();
 
            std::vector<HitStruct<return_type>> results (nodes.size());
 
            #pragma omp parallel for schedule(dynamic, 256) if (use_parallel)
            for (int i = 0; i < n; i++) {// Use custom triangle intesection if required
                const auto& node = nodes[i];
                const auto& direction = directions[i];
                results[i] = Intersect<return_type>(node, direction);
            }
            return results;
        }
 
        template <typename N, typename V>
        bool Occluded(
            const N& origin,
            const V& direction,
            float max_distance = -1.0f,
            int mesh_id = -1
        ) {
            return Occluded_IMPL(
                origin[0], origin[1], origin[2],
                direction[0], direction[1], direction[2],
                max_distance, mesh_id
            );
        }
 
 
        template <typename numeric1, typename numeric2, typename dist_type = float>
        bool Occluded(
            numeric1 x, numeric1 y, numeric1 z,
            numeric2 dx, numeric2 dy, numeric2 dz,
            dist_type max_distance = -1.0,
            int mesh_id = -1
        ) {
            return Occluded_IMPL(
                x,y,z,
                dx,dy,dz,
                max_distance, mesh_id
            );
        }
 
 
        void operator=(const EmbreeRayTracer& ERT2);
 
 
        ~EmbreeRayTracer();
    };
 
    double RayTriangleIntersection(
        const Vector3D& origin,
        const Vector3D& direction,
        const Vector3D& v1,
        const Vector3D& v2,
        const Vector3D& v3);
}
#endif