GPRT integration

.github/workflows/ci.yml

@@ -13,9 +13,9 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
-          submodules: true
+          submodules: recursive
 
       - name: Apt dependencies
         shell: bash
@@ -27,7 +27,31 @@ jobs:
                               libnetcdf-dev \
                               libhdf5-dev \
                               libeigen3-dev \
-                              cmake
+                              cmake 
+      - name: Update CMake
+        uses: ssrobins/install-cmake@v1
+        with:
+          version: 3.24.3
+          cache: true
+
+      - name: GPRT Apt Dependencies
+        shell: bash
+        run: |
+          sudo apt install -y \
+          libpthread-stubs0-dev \
+          libx11-xcb-dev \
+          xorg-dev \
+          libxinerama-dev \
+          libglu1-mesa-dev \
+          freeglut3-dev \
+          mesa-common-dev \
+          libglfw3
+
+      - name: Prepare Vulkan SDK
+        uses: humbletim/install-vulkan-sdk@v1.2
+        with:
+          version: 1.4.309.0
+          cache: true
 
       - name: MOAB Clone
         shell: bash
@@ -97,9 +121,10 @@ jobs:
       - name: Build
         shell: bash
         run: |
+          export LD_LIBRARY_PATH=$VULKAN_SDK/lib:$LD_LIBRARY_PATH
           mkdir build
           cd build
-          cmake .. -DCMAKE_PREFIX_PATH="$HOME/LIBMESH;$HOME/MOAB" -DCMAKE_INSTALL_PREFIX=$HOME/opt -DXDG_ENABLE_MOAB=ON -DXDG_ENABLE_LIBMESH=ON
+          cmake .. -DCMAKE_PREFIX_PATH="$HOME/LIBMESH;$HOME/MOAB" -DCMAKE_INSTALL_PREFIX=$HOME/opt -DXDG_ENABLE_MOAB=ON -DXDG_ENABLE_LIBMESH=ON -DXDG_ENABLE_GPRT=ON
           make -j4 install
 
       - name: Test

.gitmodules

@@ -17,3 +17,6 @@
 [submodule "vendor/linalg"]
 	path = vendor/linalg
 	url = git@github.com:sgorsten/linalg.git
+[submodule "vendor/GPRT"]
+	path = vendor/GPRT
+	url = https://github.com/gprt-org/GPRT.git

CMakeLists.txt

@@ -5,6 +5,7 @@ option(XDG_ENABLE_MOAB    "Enable support for the MOAB mesh library"          ON
 option(XDG_ENABLE_MFEM    "Enable support for the MFEM mesh library"         OFF)
 option(XDG_ENABLE_LIBMESH "Enable support for the libMesh mesh library"      OFF)
 option(XDG_ENABLE_EMBREE  "Enable support for the Embree ray tracing library" ON)
+option(XDG_ENABLE_GPRT    "Enable support for the GPRT ray tracing library"  OFF)
 option(XDG_BUILD_TESTS    "Enable C++ unit testing"                           ON)
 option(XDG_BUILD_TOOLS    "Enable tools and miniapps"                         ON)
 
@@ -93,6 +94,21 @@ add_subdirectory(vendor/argparse)
 set(INDICATORS_INSTALL ON CACHE STRING "Ensure indicators targets are provided")
 add_subdirectory(vendor/indicators)
 
+# Ensure at least one ray tracing backend is enabled
+if (NOT XDG_ENABLE_EMBREE AND NOT XDG_ENABLE_GPRT)
+  message(FATAL_ERROR
+    "No ray tracing backend enabled. Enable at least one of:\n"
+    "  -DXDG_ENABLE_EMBREE=ON\n"
+    "  -DXDG_ENABLE_GPRT=ON")
+endif()
+
+
+# GPRT
+set(GPRT_BUILD_SHARED ON  CACHE BOOL "Build GPRT as a shared library" FORCE)
+if (XDG_ENABLE_GPRT)
+  add_subdirectory(vendor/GPRT)
+endif() 
+
 list(APPEND xdg_sources
 src/geometry/measure.cpp
 src/geometry/plucker.cpp
@@ -114,6 +130,16 @@ src/embree/ray_tracer.cpp
 )
 endif()
 
+if (XDG_ENABLE_GPRT)
+list(APPEND xdg_sources
+src/gprt/ray_tracer.cpp
+)
+list(APPEND xdg_device_codes
+dbl_deviceCode
+)
+
+endif()
+
 if (XDG_ENABLE_LIBMESH)
 list(APPEND xdg_sources
 src/libmesh/mesh_manager.cpp
@@ -202,6 +228,11 @@ if (XDG_ENABLE_EMBREE)
   target_compile_definitions(xdg PUBLIC XDG_ENABLE_EMBREE)
 endif()
 
+if (XDG_ENABLE_GPRT)
+  target_compile_definitions(xdg PUBLIC XDG_ENABLE_GPRT)
+  target_link_options(xdg INTERFACE -Wl,--unresolved-symbols=ignore-in-shared-libs)
+endif()
+
 # ==========================
 # Link ray tracing libraries
 # ==========================
@@ -210,6 +241,22 @@ if (XDG_ENABLE_EMBREE)
   target_link_libraries(xdg embree fmt::fmt)
 endif()
 
+if (XDG_ENABLE_GPRT)
+  # Compile device code for each slang file (currently only dbl_deviceCode.slang)
+  foreach(device_code ${xdg_device_codes})
+    embed_devicecode(
+    OUTPUT_TARGET
+    ${device_code}
+    HEADERS
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/xdg/gprt/shared_structs.h
+    SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/gprt/${device_code}.slang
+    )
+    target_link_libraries(xdg ${device_code})
+  endforeach()
+target_link_libraries(xdg $<BUILD_INTERFACE:gprt>)
+endif()
+
 # ===================
 # Link mesh libraries
 # ===================
@@ -235,6 +282,24 @@ install(TARGETS xdg
   INCLUDES DESTINATION include
 )
 
+# Install GPRT Targets from shared library
+if (TARGET gprt)
+  install(TARGETS gprt
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    )
+endif()
+
+# Install targets for each slang file compiled (currently only dbl_deviceCode)
+foreach(device_code ${xdg_device_codes})
+  install(TARGETS ${device_code}
+    EXPORT xdg-targets
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  )
+endforeach()
+
 install(EXPORT xdg-targets
   FILE XDGTargets.cmake
   NAMESPACE xdg::

include/xdg/constants.h

@@ -6,6 +6,10 @@
 #include <limits>
 #include <string>
 
+#include "fmt/format.h"
+
+#include "xdg/shared_enums.h"
+
 namespace xdg {
 
 constexpr double INFTY {std::numeric_limits<double>::max()};
@@ -63,7 +67,7 @@ static const std::map<MeshLibrary, std::string> MESH_LIB_TO_STR =
 static const std::map<RTLibrary, std::string> RT_LIB_TO_STR =
 {
   {RTLibrary::EMBREE, "EMBREE"},
-  {RTLibrary::GPRT, "GPRT"},
+  {RTLibrary::GPRT, "GPRT"}
 };
 
 // Mesh identifer type
@@ -111,9 +115,6 @@ static Property VOID_MATERIAL {PropertyType::MATERIAL, "void"};
 // Enumerator for different ray fire types
 enum class RayFireType { VOLUME, POINT_CONTAINMENT, ACCUMULATE_HITS, FIND_VOLUME };
 
-//
-enum class HitOrientation { ANY, EXITING, ENTERING };
-
 // Enumerator for different element types (maybe we want more here?)
 enum class SurfaceElementType {
   TRI = 0,
@@ -127,4 +128,22 @@ enum class VolumeElementType {
 
 } // namespace xdg
 
+namespace fmt {
+  template <>
+struct formatter<xdg::RTLibrary> : fmt::formatter<std::string> {
+  auto format(xdg::RTLibrary lib, fmt::format_context& ctx) {
+    return fmt::formatter<std::string>::format(xdg::RT_LIB_TO_STR.at(lib), ctx);
+  }
+};
+
+template <>
+struct formatter<xdg::MeshLibrary> : fmt::formatter<std::string> {
+  auto format(xdg::MeshLibrary lib, fmt::format_context& ctx) {
+    return fmt::formatter<std::string>::format(xdg::MESH_LIB_TO_STR.at(lib), ctx);
+  }
+};
+
+
+}
+
 #endif // include guard

include/xdg/embree/ray_tracer.h

@@ -21,6 +21,8 @@ class EmbreeRayTracer : public RayTracer {
 public:
   EmbreeRayTracer();
   ~EmbreeRayTracer();
+  RTLibrary library() const override { return RTLibrary::EMBREE; }
+
   void init() override;
   RTCScene create_embree_scene();
 
@@ -38,6 +40,7 @@ class EmbreeRayTracer : public RayTracer {
 
   MeshID find_element(TreeID tree, const Position& point) const override;
 
+
   // Query Methods
   bool point_in_volume(TreeID scene,
                       const Position& point,
@@ -88,6 +91,7 @@ class EmbreeRayTracer : public RayTracer {
                                                                              MeshID surface,
                                                                              RTCScene& volume_scene,
                                                                              int& storage_offset);
+  // Global Tree IDs
   RTCScene global_surface_scene_ {nullptr};
   RTCScene global_element_scene_ {nullptr};
 

include/xdg/gprt/ray_tracer.h

@@ -0,0 +1,132 @@
+#ifndef _XDG_GPRT_BASE_RAY_TRACING_INTERFACE_H
+#define _XDG_GPRT_BASE_RAY_TRACING_INTERFACE_H
+
+#include <memory>
+#include <vector>
+#include <unordered_map>
+
+#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 {
+
+class GPRTRayTracer : public RayTracer {
+  public:
+    GPRTRayTracer();
+    ~GPRTRayTracer();
+    RTLibrary library() const override { return RTLibrary::GPRT; }
+
+    void set_geom_data(const std::shared_ptr<MeshManager> mesh_manager);
+    void init() override;
+
+    // Setup the different shader programs for use with this ray tracer
+    void setup_shaders();
+
+    MeshID find_element(const Position& point) const override
+    {
+      fatal_error("Element trees not currently supported with GPRT ray tracer");
+      return ID_NONE;
+    };
+
+    MeshID find_element(TreeID tree, const Position& point) const override {
+      fatal_error("Element trees not currently supported with GPRT ray tracer");
+      return ID_NONE;
+    };
+
+    std::pair<TreeID, TreeID>
+    register_volume(const std::shared_ptr<MeshManager>& mesh_manager, 
+                    MeshID volume) override;
+
+    TreeID create_surface_tree(const std::shared_ptr<MeshManager>& mesh_manager, 
+                               MeshID volume) override;
+
+    TreeID create_element_tree(const std::shared_ptr<MeshManager>& mesh_manager, 
+                               MeshID volume) override;
+
+    void create_global_surface_tree() override;
+
+    void create_global_element_tree() override
+    {
+      warning("Global element trees not currently supported with GPRT ray tracer");
+      return;
+    };
+
+    bool point_in_volume(TreeID scene,
+                        const Position& point,
+                        const Direction* direction = nullptr,
+                        const std::vector<MeshID>* exclude_primitives = nullptr) const 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;
+
+    void closest(TreeID scene,
+                const Position& origin,
+                double& dist,
+                MeshID& triangle) override {};
+    void closest(TreeID scene,
+                const Position& origin,
+                double& dist) override {};
+
+    bool occluded(TreeID scene,
+                  const Position& origin,
+                  const Direction& direction,
+                  double& dist) const override {
+      fatal_error("Occlusion queries are not currently supported with GPRT ray tracer");
+      return false;
+    }
+
+  private:
+    // GPRT objects 
+    GPRTContext context_;
+    GPRTProgram deviceCode_; // device code for float precision shaders
+    GPRTModule module_; // device code module for single precision shaders
+    GPRTAccel world_; 
+    GPRTBuildParams buildParams_; //<! Build parameters for acceleration structures
+
+    // Shader programs
+    GPRTRayGenOf<dblRayGenData> rayGenProgram_; 
+    GPRTRayGenOf<dblRayGenData> rayGenPointInVolProgram_;
+    GPRTMissOf<void> missProgram_; 
+    GPRTComputeOf<DPTriangleGeomData> aabbPopulationProgram_; //<! AABB population program for double precision rays
+
+    // Buffers 
+    GPRTBufferOf<dblRayInput> rayInputBuffer_; //<! Ray buffer for ray generation
+    GPRTBufferOf<dblRayOutput> rayOutputBuffer_; //<! Ray output buffer for ray generation
+    GPRTBufferOf<int32_t> excludePrimitivesBuffer_; //<! Buffer for excluded primitives
+
+    // Geometry Type and Instances
+    std::vector<gprt::Instance> globalBlasInstances_; //<! List of every BLAS instance stored in this ray tracer
+    GPRTGeomTypeOf<DPTriangleGeomData> trianglesGeomType_; //<! Geometry type for triangles
+
+    // Ray Generation parameters
+    size_t numRays = 1; //<! Number of rays to be cast
+    uint32_t numRayTypes_ = 1; // <! Number of ray types. Allows multiple shaders to be set to the same geometery
+
+    // Mesh-to-Scene maps 
+    std::map<MeshID, GPRTGeomOf<DPTriangleGeomData>> surface_to_geometry_map_; //<! Map from mesh surface to embree geometry
+
+    // 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
+
+    // Global Tree IDs
+    GPRTAccel global_surface_accel_ {nullptr};
+    GPRTAccel global_element_accel_ {nullptr}; 
+
+  };
+
+} // namespace xdg
+
+#endif // include guard