[PR1] Introduced batch versions of ray_fire() and point_in_volume() with GPRT backend

include/xdg/gprt/ray.h

@@ -0,0 +1,40 @@
+#ifndef _XDG_GPRT_RAY_H
+#define _XDG_GPRT_RAY_H
+
+#include "gprt.h"
+#include "../shared_enums.h"
+
+/*
+ * Double-precision ray and hit structures used by the GPRT backend.
+ *
+ * These types are not inherently GPRT-specific, but we keep them here for now
+ * since GPRT is the only GPU backend. If another GPU backend is added, these
+ * can be reused. Unifying them with the CPU/Embree types is possible, but may
+ * not be worth the added complexity at this stage.
+ */
+
+namespace xdg {
+
+struct dblRay 
+{
+  double3 origin;
+  double3 direction;
+  int volume_mesh_id; // MeshID of the volume this ray will be traced against
+  uint enabled; // Flag to indicate if the ray is active
+  int32_t* exclude_primitives; // Optional for excluding primitives
+  int32_t exclude_count; // Number of excluded primitives
+};
+
+
+struct dblHit 
+{
+  double distance;
+  int surf_id;
+  int primitive_id;
+  PointInVolume piv; // Point in volume check result (0 for outside, 1 for inside)
+};
+
+}
+
+
+#endif 

include/xdg/gprt/ray_tracer.h

@@ -7,17 +7,15 @@
 
 #include "xdg/constants.h"
 #include "xdg/mesh_manager_interface.h"
-#include "xdg/primitive_ref.h"
-#include "xdg/geometry_data.h"
 #include "xdg/ray_tracing_interface.h"
-#include "xdg/ray.h"
 #include "xdg/error.h"
-#include "gprt/gprt.h"
+
 #include "shared_structs.h"
 
 extern GPRTProgram dbl_deviceCode;
 namespace xdg {
 
+// Ray generation types corresponding to different queries for GPRT
 enum class RayGenType {
   RAY_FIRE,
   POINT_IN_VOLUME,
@@ -26,17 +24,16 @@ enum class RayGenType {
 };
 
 struct gprtRayHit {
-  size_t capacity = 1; // Max number of rays allocated 
-  size_t size = 0;     // Current number of active rays 
+  DeviceRayHitBuffers view; // external facing POD for rayhit buffers
+  size_t size = 0; // Current number of active rays 
 
   GPRTBufferOf<dblRay> ray = nullptr;
   GPRTBufferOf<dblHit> hit = nullptr;
-  dblRay* devRayAddr = nullptr;
-  dblHit* devHitAddr = nullptr;
 
-  bool is_valid() const { return capacity > 0 && ray && hit && devRayAddr && devHitAddr; }
+  bool is_valid() const { 
+    return view.capacity > 0 && ray && hit && view.rayDevPtr && view.hitDevPtr; 
+  }
 };
-
 class GPRTRayTracer : public RayTracer {
   public:
     GPRTRayTracer();
@@ -79,19 +76,38 @@ class GPRTRayTracer : public RayTracer {
     };
 
     bool point_in_volume(TreeID scene,
-                        const Position& point,
-                        const Direction* direction = nullptr,
-                        const std::vector<MeshID>* exclude_primitives = nullptr) const override;
+                         const Position& point,
+                         const Direction* direction = nullptr,
+                         const std::vector<MeshID>* exclude_primitives = nullptr) const override;
+
+    void point_in_volume(TreeID tree,
+                         const Position* points,
+                         const size_t num_points,
+                         uint8_t* results,
+                         const Direction* directions = nullptr, 
+                         std::vector<MeshID>* exclude_primitives = nullptr) override;
 
     std::pair<double, MeshID> ray_fire(TreeID scene,
-                                      const Position& origin,
-                                      const Direction& direction,
-                                      const double dist_limit = INFTY,
-                                      HitOrientation orientation = HitOrientation::EXITING,
-                                      std::vector<MeshID>* const exclude_primitives = nullptr) override;
+                                       const Position& origin,
+                                       const Direction& direction,
+                                       const double dist_limit = INFTY,
+                                       HitOrientation orientation = HitOrientation::EXITING,
+                                       std::vector<MeshID>* const exclude_primitives = nullptr) override;
+    void ray_fire(TreeID tree,
+                  const Position* origins,
+                  const Direction* directions,
+                  const size_t num_rays,
+                  double* hitDistances,
+                  MeshID* surfaceIDs,
+                  const double dist_limit = INFTY,
+                  HitOrientation orientation = HitOrientation::EXITING,
+                  std::vector<MeshID>* const exclude_primitives = nullptr) override;
 
     std::pair<double, MeshID> closest(TreeID scene,
-                                      const Position& origin) override {};
+                                      const Position& origin) override {
+      fatal_error("Closest queries are not currently supported with GPRT ray tracer");
+      return {INFTY, ID_NONE};
+    };
 
     bool occluded(TreeID scene,
                   const Position& origin,
@@ -100,9 +116,16 @@ class GPRTRayTracer : public RayTracer {
       fatal_error("Occlusion queries are not currently supported with GPRT ray tracer");
       return false;
     }
-
+
+    void check_rayhit_buffer_capacity(const size_t N) override;
+
+    // Return GPRT context to attatch "external" shaders to same context (required since GPRT doesn't support VK_EXTERNAL_MEMORY_EXTENSION yet)  
+    GPRTContext context()
+    {
+      return context_;
+    }
+
   private:
-    void check_ray_buffer_capacity(size_t N);
 
     // GPRT objects 
     GPRTContext context_;
@@ -133,7 +156,25 @@ class GPRTRayTracer : public RayTracer {
 
     // Internal GPRT Mappings
     std::unordered_map<SurfaceTreeID, GPRTAccel> surface_volume_tree_to_accel_map; // Map from XDG::TreeID to GPRTAccel for volume TLAS
-    std::vector<GPRTAccel> blas_handles_; // Store BLAS handles so that they can be explicitly referenced in destructor
+    std::unordered_map<SurfaceTreeID, MeshID> surface_tree_to_volume_map_;
+    std::vector<SurfaceAccelerationStructure> tlas_handles_; // Host side storage of TLAS device addresses
+    GPRTBufferOf<SurfaceAccelerationStructure> tlas_handle_buffer_; // Device buffer for TLAS addresses
+    std::vector<int> meshid_to_sense_; // Host-side MeshID -> sense map
+    GPRTBufferOf<int> meshid_to_sense_buffer_ {nullptr}; // Device buffer for MeshID -> sense map
+    bool initialized_ {false}; // flag to indicate if init() has been called
+
+    void update_tlas_table_(); // Update the TLAS table (MeshID -> SurfaceAccelerationStructure) buffer on the device
+    void update_meshid_to_sense_(); // Update the MeshID -> sense (+1/-1) buffer on the device
+
+    // Helper to upload data to device buffer, resizing buffer as needed
+    template <typename T>
+    void upload_device_buffer_(GPRTBufferOf<T>& buf, const std::vector<T>& host_data)
+    {
+      gprtBufferResize<T>(context_, buf, host_data.size(), false);
+      gprtBufferMap(buf);
+        std::copy(host_data.begin(), host_data.end(), gprtBufferGetHostPointer(buf));
+      gprtBufferUnmap(buf);
+    }
 
     // Global Tree IDs
     GPRTAccel global_surface_accel_ {nullptr};
@@ -142,5 +183,4 @@ class GPRTRayTracer : public RayTracer {
   };
 
 } // namespace xdg
-
-#endif // include guard
+#endif // include guard

include/xdg/gprt/shared_structs.h

@@ -1,32 +1,15 @@
+#ifndef XDG_GPRT_SHARED_STRUCTS_H
+#define XDG_GPRT_SHARED_STRUCTS_H
+
 #include "gprt.h"
 #include "../shared_enums.h"
+#include "ray.h"
 
 struct GPRTPrimitiveRef
 {
   int id; // ID of the primitive
-  int sense;
-};
-
-struct dblRay 
-{
-  double3 origin;
-  double3 direction;
-  double tMin; // Minimum distance for ray intersection
-  double tMax; // Maximum distance for ray intersection
-  int32_t* exclude_primitives; // Optional for excluding primitives
-  int32_t exclude_count;           // Number of excluded primitives
-  xdg::HitOrientation hitOrientation;
-  int volume_tree; // TreeID of the volume being queried
-  SurfaceAccelerationStructure volume_accel; // The volume accel 
 };
 
-struct dblHit 
-{
-  double distance;
-  int surf_id;
-  int primitive_id;
-  xdg::PointInVolume piv; // Point in volume check result (0 for outside, 1 for inside)
-};
 
 /* variables for double precision triangle mesh geometry */
 struct DPTriangleGeomData {
@@ -35,20 +18,17 @@ struct DPTriangleGeomData {
   uint3 *index;  // index buffer
   double3 *normals; // normals buffer
   int surf_id;
-  int2 vols;
-  int forward_vol;
-  int reverse_vol;
-  dblRay *ray; // double precision rays
+  int* meshid_to_sense; // MeshID -> sense (+1 forward, -1 reverse)
+  xdg::dblRay *ray; // double precision rays
   xdg::HitOrientation hitOrientation;
-  int forward_tree; // TreeID of the forward volume
-  int reverse_tree; // TreeID of the reverse volume
   GPRTPrimitiveRef* primitive_refs;
   int num_faces; // Number of faces in the geometry
 };
 
 struct dblRayGenData {
-  dblRay *ray;
-  dblHit *hit;
+  xdg::dblRay *ray;
+  xdg::dblHit *hit;
+  SurfaceAccelerationStructure* meshid_to_accel_address; // MeshID->TLAS address table to recover volume to trace against
 };
 
 /* A small structure of constants that can change every frame without rebuilding the
@@ -57,4 +37,7 @@ struct dblRayGenData {
 struct dblRayFirePushConstants {
   double tMax;
   double tMin;
+  xdg::HitOrientation hitOrientation;
 };
+
+#endif

include/xdg/ray_tracing_interface.h

@@ -4,16 +4,46 @@
 #include <memory>
 #include <vector>
 #include <unordered_map>
+#include <functional>
 
+#include "xdg/error.h"
 #include "xdg/constants.h"
 #include "xdg/embree_interface.h"
 #include "xdg/mesh_manager_interface.h"
 #include "xdg/primitive_ref.h"
 #include "xdg/geometry_data.h"
 
+
 namespace xdg
 {
 
+struct dblHit; // forward declaration for dblHit
+
+/**
+ * @brief Device ray/hit buffer descriptor
+ *
+ * This structure provides access to device-allocated ray and hit buffers
+ * in a backend-agnostic way. The buffers contain XDG's standard ray and hit
+ * data structures (dblRay and dblHit), regardless of which compute backend
+ * is being used.
+ *
+ * Key design principle:
+ * - Device pointers are opaque (void*)
+ * - The data layout is always the XDG types dblRay and dblHit
+ * - Downstream code can write to these buffers (hopefully) using any compute API
+ *
+ * For type-safe access in downstream code:
+ * - Cast rayDevPtr to (dblRay*) when using C++ or kernels
+ * - Cast hitDevPtr to (dblHit*) when reading hit results
+ */
+struct DeviceRayHitBuffers {
+  void* rayDevPtr;
+  void* hitDevPtr;
+  size_t capacity; // Number of rays the buffer can hold
+  size_t rayStride; // Bytes between ray elements - sizeof(dblRay)
+  size_t hitStride; // Bytes between hit elements - sizeof(dblHit)
+};
+
 class RayTracer {
 public:
   // Constructors/Destructors
@@ -73,12 +103,41 @@ class RayTracer {
    */
   virtual void create_global_element_tree() = 0;
 
-  // Query Methods
+  /**
+   * @brief Check whether a point lies in a specified volume
+   *
+   * This method performs a check to see whether a given point is inside a volume provided.
+   * It computes this by firing a ray from the point and checking whether or not the ray is Entering or Exiting
+   * the volume boundary. If no direction is provided, a default direction will be used.
+   * Note - zero length direction vectors are not explicitly checked for internally and should be avoided to avoid causing undefined behavior.
+   * 
+   * @param[in] tree The TreeID of the volume we are querying against
+   * @param[in] point The point to be queried
+   * @param[in] direction (optional) direction to launch a ray in a specified direction - must be non-zero length
+   * @param[in] exclude_primitives (optional) vector of surface element MeshIDs to exclude from intersection tests
+   * @return Boolean result of point in volume check
+   */ 
   virtual bool point_in_volume(TreeID tree,
                        const Position& point,
                        const Direction* direction = nullptr,
                        const std::vector<MeshID>* exclude_primitives = nullptr) const = 0;
-
+
+  /**
+   * @brief Fire a ray against a given volume and return the first hit
+   *
+   * This method fires a ray from a given origin in a specified direction against the surfaces of a volume.
+   * It returns the distance to the closest hit and the MeshID of the surface hit. The user can specify
+   * a distance limit and whether Entering/Exiting hits should be rejected.
+   * Note - zero length direction vectors are not explicitly checked for internally and should be avoided to avoid causing undefined behavior.
+   *
+   * @param[in] tree The TreeID of the volume we are querying against
+   * @param[in] origin An array of Position objects representing the starting points of the rays
+   * @param[in] direction (optional) Direction object to launch a ray in a specified direction
+   * @param[in] dist_limit (optional) maximum distance to consider for intersections
+   * @param[in] orientation (optional) flag to consider whether Entering/Exiting hits should be rejected. Defaults to EXITING
+   * @param[in] exclude_primitives (optional) vector of surface element MeshIDs to exclude from intersection tests
+   * @return A pair containing the distance to the closest hit and the MeshID of the surface hit
+   */ 
   virtual std::pair<double, MeshID> ray_fire(TreeID tree,
                                      const Position& origin,
                                      const Direction& direction,
@@ -123,6 +182,40 @@ class RayTracer {
   int num_registered_surface_trees() const { return surface_trees_.size(); };
   int num_registered_element_trees() const { return element_trees_.size(); };
 
+
+  // GPU Ray Tracing Support
+
+  virtual void point_in_volume(TreeID tree,
+                               const Position* points,
+                               const size_t num_points,
+                               uint8_t* results,
+                               const Direction* directions = nullptr,
+                               std::vector<MeshID>* exclude_primitives = nullptr) 
+  {
+    fatal_error("GPU ray tracing not supported with this RayTracer backend");
+  }
+
+  virtual void ray_fire(TreeID tree,
+                        const Position* origins,
+                        const Direction* directions,
+                        const size_t num_rays,
+                        double* hitDistances,
+                        MeshID* surfaceIDs,
+                        const double dist_limit = INFTY,
+                        HitOrientation orientation = HitOrientation::EXITING,
+                        std::vector<MeshID>* const exclude_primitives = nullptr)
+  {
+    fatal_error("GPU ray tracing not supported with this RayTracer backend");
+  }
+
+  /**
+   * @brief Check whether the current ray buffer capacity is sufficient for the number of rays requested
+   * @param[in] num_rays The number of rays to be processed
+   */
+  virtual void check_rayhit_buffer_capacity(const size_t num_rays) {
+    fatal_error("GPU ray tracing not supported with this RayTracer backend");
+  }
+
 protected:
   // Common functions across RayTracers
   const double bounding_box_bump(const std::shared_ptr<MeshManager> mesh_manager, MeshID volume_id); // return a bump value based on the size of a bounding box (minimum 1e-3). Should this be a part of mesh_manager?
@@ -150,4 +243,4 @@ class RayTracer {
 } // namespace xdg
 
 
-#endif // include guard
+#endif // include guard