[1.3.64] 2026-01-30

- Added non-throwing path resolution functions `tryResolveFilePath()` and `tryResolvePluginAsset()` that return empty paths instead of throwing exceptions when files are not found.

- Refactored `resolveTextureFile()` to use non-throwing path resolution functions, eliminating exception handling for file probing.
- Added overloaded `PlantArchitecture::getPlantInternodeObjectIDs()` that can take a shoot type label string in order to only get object IDs for that shoot type.

- Refactored ray tracing architecture with backend abstraction layer to enable future support for OptiX 7.7 and Vulkan backends while maintaining backward compatibility with OptiX 6.5. This is a major overhaul, but should be fully backward compatible - please report any errors you encounter.
- Added type-safe buffer indexing utilities (`BufferIndexing.h`, `IndexTypes.h`) to eliminate manual index calculations and prevent indexing errors in multi-dimensional GPU buffers.

Author: bnbailey-psl

core/include/global.h

@@ -1174,6 +1174,17 @@ namespace helios {
      */
     [[nodiscard]] std::filesystem::path resolvePluginAsset(const std::string &pluginName, const std::string &assetPath);
 
+    //! Attempt to resolve a plugin asset path without throwing exceptions
+    /**
+     * Similar to resolvePluginAsset() but returns an empty path instead of throwing on failure.
+     * Useful for probing whether a plugin asset exists.
+     *
+     * \param[in] pluginName Name of the plugin (e.g., "plantarchitecture")
+     * \param[in] assetPath Path relative to plugin directory (e.g., "assets/textures/leaf.png")
+     * \return Absolute canonical path to the asset if found, empty path otherwise
+     * \ingroup functions
+     */
+    [[nodiscard]] std::filesystem::path tryResolvePluginAsset(const std::string &pluginName, const std::string &assetPath);
 
     //! Resolve file path using standard Helios resolution hierarchy
     /**
@@ -1189,6 +1200,17 @@ namespace helios {
      */
     [[nodiscard]] std::filesystem::path resolveFilePath(const std::string &filename);
 
+    //! Attempt to resolve a file path without throwing exceptions
+    /**
+     * Similar to resolveFilePath() but returns an empty path instead of throwing on failure.
+     * Useful for probing whether a file exists at various locations.
+     *
+     * \param[in] filename File name with or without path (e.g., "texture.jpg" or "models/texture.jpg")
+     * \return Absolute canonical path to the file if found, empty path otherwise
+     * \ingroup functions
+     */
+    [[nodiscard]] std::filesystem::path tryResolveFilePath(const std::string &filename);
+
     //! Resolve spectral data file path
     /**
      * \param[in] spectraFile Spectral data filename with or without path (e.g., "camera_spectral_library.xml")

core/src/Context.cpp

@@ -498,6 +498,11 @@ std::vector<uint> Context::getAllUUIDs() const {
         }
         cached_all_uuids.push_back(UUID);
     }
+
+    // Sort UUIDs for consistent ordering across platforms
+    // (std::unordered_map iteration order is platform-dependent)
+    std::sort(cached_all_uuids.begin(), cached_all_uuids.end());
+
     all_uuids_cache_valid = true;
     return cached_all_uuids;
 }

core/src/global.cpp

@@ -2692,20 +2692,30 @@ std::filesystem::path helios::resolveAssetPath(const std::string &relativePath)
     return resolveFilePath(relativePath);
 }
 
+std::filesystem::path helios::tryResolvePluginAsset(const std::string &pluginName, const std::string &assetPath) {
+    std::string pluginAssetPath = "plugins/" + pluginName + "/" + assetPath;
+    return tryResolveFilePath(pluginAssetPath);
+}
+
 std::filesystem::path helios::resolvePluginAsset(const std::string &pluginName, const std::string &assetPath) {
     std::string pluginAssetPath = "plugins/" + pluginName + "/" + assetPath;
     return resolveFilePath(pluginAssetPath);
 }
 
 
-std::filesystem::path helios::resolveFilePath(const std::string &filename) {
+std::filesystem::path helios::tryResolveFilePath(const std::string &filename) {
+    // Non-throwing version for probing file existence
+    if (filename.empty()) {
+        return {};
+    }
+
     // 1. If absolute path, validate and return
     std::filesystem::path filepath(filename);
     if (filepath.is_absolute()) {
         if (std::filesystem::exists(filepath)) {
             return std::filesystem::canonical(filepath);
         } else {
-            helios_runtime_error("ERROR (helios::resolveFilePath): Absolute file path " + filename + " does not exist.");
+            return {};
         }
     }
 
@@ -2723,7 +2733,28 @@ std::filesystem::path helios::resolveFilePath(const std::string &filename) {
         return std::filesystem::canonical(buildDirPath);
     }
 
-    // File not found in either location - provide clear error message
+    // File not found in any location
+    return {};
+}
+
+std::filesystem::path helios::resolveFilePath(const std::string &filename) {
+    // Handle empty string case - return current working directory
+    if (filename.empty()) {
+        return std::filesystem::current_path();
+    }
+
+    // Try to resolve using the non-throwing version first
+    std::filesystem::path result = tryResolveFilePath(filename);
+
+    if (!result.empty()) {
+        return result;
+    }
+
+    // File not found - provide clear error message
+    std::filesystem::path currentDirPath = std::filesystem::current_path() / filename;
+    std::string buildDir = getBuildDirectory();
+    std::filesystem::path buildDirPath = std::filesystem::path(buildDir) / filename;
+
     helios_runtime_error("ERROR (helios::resolveFilePath): Could not locate asset file: " + filename + " (checked: " + currentDirPath.string() + " and " + buildDirPath.string() + "). " +
                          "Ensure file exists relative to current directory or HELIOS_BUILD path.");
     return {}; // This line should never be reached due to helios_runtime_error throwing

doc/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+# [1.3.64] 2026-01-30
+
+## Core
+- Added non-throwing path resolution functions `tryResolveFilePath()` and `tryResolvePluginAsset()` that return empty paths instead of throwing exceptions when files are not found.
+
+## Plant Architecture
+- Refactored `resolveTextureFile()` to use non-throwing path resolution functions, eliminating exception handling for file probing.
+- Added overloaded `PlantArchitecture::getPlantInternodeObjectIDs()` that can take a shoot type label string in order to only get object IDs for that shoot type.
+
+## Radiation
+- Refactored ray tracing architecture with backend abstraction layer to enable future support for OptiX 7.7 and Vulkan backends while maintaining backward compatibility with OptiX 6.5. This is a major overhaul, but should be fully backward compatible - please report any errors you encounter.
+- Added type-safe buffer indexing utilities (`BufferIndexing.h`, `IndexTypes.h`) to eliminate manual index calculations and prevent indexing errors in multi-dimensional GPU buffers.
+
 # [1.3.63] 2026-01-21
 
 ## Core

plugins/plantarchitecture/include/PlantArchitecture.h

@@ -2656,6 +2656,15 @@ class PlantArchitecture {
      */
     [[nodiscard]] std::vector<uint> getPlantInternodeObjectIDs(uint plantID) const;
 
+    //! Get object IDs for internode (Tube) objects matching a specified shoot type label
+    /**
+     * \param[in] plantID ID of the plant instance.
+     * \param[in] shoot_type_label Label of the shoot type to filter internodes by.
+     * \return Vector of object IDs for all internodes matching the specified shoot type label.
+     * \note Throws a helios_runtime_error if the plant does not exist or if no shoots with the specified shoot type label are found.
+     */
+    [[nodiscard]] std::vector<uint> getPlantInternodeObjectIDs(uint plantID, const std::string &shoot_type_label) const;
+
     //! Get object IDs for all petiole (Tube) objects for a given plant
     /**
      * \param[in] plantID ID of the plant instance.

plugins/plantarchitecture/src/PlantArchitecture.cpp

@@ -137,17 +137,15 @@ std::string PlantArchitecture::resolveTextureFile(const std::string &texture_fil
     }
 
     // Try resolving as a general file path (handles already-resolved paths and paths relative to cwd)
-    try {
-        return helios::resolveFilePath(texture_file).string();
-    } catch (const std::runtime_error &) {
-        // Continue to plugin-specific resolution
+    std::filesystem::path resolved_path = helios::tryResolveFilePath(texture_file);
+    if (!resolved_path.empty()) {
+        return resolved_path.string();
     }
 
     // Try resolving as a plugin asset path
-    try {
-        return helios::resolvePluginAsset("plantarchitecture", texture_file).string();
-    } catch (const std::runtime_error &) {
-        // Continue to fallback
+    resolved_path = helios::tryResolvePluginAsset("plantarchitecture", texture_file);
+    if (!resolved_path.empty()) {
+        return resolved_path.string();
     }
 
     // If path doesn't have "assets/" prefix, try appropriate asset subdirectory based on file extension
@@ -159,10 +157,9 @@ std::string PlantArchitecture::resolveTextureFile(const std::string &texture_fil
         std::string subdirectory = (extension == ".obj" || extension == ".mtl") ? "assets/obj/" : "assets/textures/";
         std::string assets_path = subdirectory + filename;
 
-        try {
-            return helios::resolvePluginAsset("plantarchitecture", assets_path).string();
-        } catch (const std::runtime_error &) {
-            // Fall through to error
+        resolved_path = helios::tryResolvePluginAsset("plantarchitecture", assets_path);
+        if (!resolved_path.empty()) {
+            return resolved_path.string();
         }
     }
 
@@ -4423,6 +4420,32 @@ std::vector<uint> PlantArchitecture::getPlantInternodeObjectIDs(uint plantID) co
     return objIDs;
 }
 
+std::vector<uint> PlantArchitecture::getPlantInternodeObjectIDs(uint plantID, const std::string &shoot_type_label) const {
+    if (plant_instances.find(plantID) == plant_instances.end()) {
+        helios_runtime_error("ERROR (PlantArchitecture::getPlantInternodeObjectIDs): Plant with ID of " + std::to_string(plantID) + " does not exist.");
+    }
+
+    std::vector<uint> objIDs;
+
+    auto &shoot_tree = plant_instances.at(plantID).shoot_tree;
+
+    bool shoot_type_found = false;
+    for (auto &shoot: shoot_tree) {
+        if (shoot->shoot_type_label == shoot_type_label) {
+            shoot_type_found = true;
+            if (context_ptr->doesObjectExist(shoot->internode_tube_objID)) {
+                objIDs.push_back(shoot->internode_tube_objID);
+            }
+        }
+    }
+
+    if (!shoot_type_found) {
+        helios_runtime_error("ERROR (PlantArchitecture::getPlantInternodeObjectIDs): No shoots with shoot type label '" + shoot_type_label + "' exist for plant with ID " + std::to_string(plantID) + ".");
+    }
+
+    return objIDs;
+}
+
 std::vector<uint> PlantArchitecture::getPlantPetioleObjectIDs(uint plantID) const {
     if (plant_instances.find(plantID) == plant_instances.end()) {
         helios_runtime_error("ERROR (PlantArchitecture::getPlantPetioleObjectIDs): Plant with ID of " + std::to_string(plantID) + " does not exist.");

plugins/plantarchitecture/tests/selfTest.cpp

@@ -2388,6 +2388,61 @@ DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - multiple instances")
     DOCTEST_CHECK(std::find(tomato_labels.begin(), tomato_labels.end(), "mainstem") != tomato_labels.end());
 }
 
+DOCTEST_TEST_CASE("PlantArchitecture getPlantInternodeObjectIDs with shoot type filter") {
+    Context context;
+    PlantArchitecture plantarchitecture(&context);
+
+    // Build a bean plant (has two shoot types: "unifoliate" and "trifoliate")
+    plantarchitecture.loadPlantModelFromLibrary("bean");
+    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0.0);
+
+    // Get all internode object IDs without filter
+    std::vector<uint> all_internodes = plantarchitecture.getPlantInternodeObjectIDs(plantID);
+    DOCTEST_CHECK(all_internodes.size() > 0);
+
+    // Get internode object IDs for "unifoliate" shoot type
+    std::vector<uint> unifoliate_internodes = plantarchitecture.getPlantInternodeObjectIDs(plantID, "unifoliate");
+    DOCTEST_CHECK(unifoliate_internodes.size() > 0);
+
+    // Get internode object IDs for "trifoliate" shoot type
+    std::vector<uint> trifoliate_internodes = plantarchitecture.getPlantInternodeObjectIDs(plantID, "trifoliate");
+    DOCTEST_CHECK(trifoliate_internodes.size() > 0);
+
+    // Verify that filtered results are subsets of all internodes
+    for (uint objID : unifoliate_internodes) {
+        DOCTEST_CHECK(std::find(all_internodes.begin(), all_internodes.end(), objID) != all_internodes.end());
+    }
+    for (uint objID : trifoliate_internodes) {
+        DOCTEST_CHECK(std::find(all_internodes.begin(), all_internodes.end(), objID) != all_internodes.end());
+    }
+
+    // Verify no overlap between unifoliate and trifoliate internodes
+    for (uint objID : unifoliate_internodes) {
+        DOCTEST_CHECK(std::find(trifoliate_internodes.begin(), trifoliate_internodes.end(), objID) == trifoliate_internodes.end());
+    }
+
+    // Verify that sum of filtered internodes equals total internodes
+    DOCTEST_CHECK(unifoliate_internodes.size() + trifoliate_internodes.size() == all_internodes.size());
+}
+
+DOCTEST_TEST_CASE("PlantArchitecture getPlantInternodeObjectIDs with shoot type filter - error cases") {
+    std::string error_message;
+    {
+        capture_cerr cerr_buffer;
+        Context context;
+        PlantArchitecture plantarchitecture(&context);
+
+        plantarchitecture.loadPlantModelFromLibrary("bean");
+        uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0.0);
+
+        // Should throw for non-existent shoot type
+        DOCTEST_CHECK_THROWS(static_cast<void>(plantarchitecture.getPlantInternodeObjectIDs(plantID, "nonexistent_shoot_type")));
+
+        // Should throw for invalid plant ID
+        DOCTEST_CHECK_THROWS(static_cast<void>(plantarchitecture.getPlantInternodeObjectIDs(9999, "unifoliate")));
+    }
+}
+
 int PlantArchitecture::selfTest(int argc, char **argv) {
     return helios::runDoctestWithValidation(argc, argv);
 }

plugins/radiation/CMakeLists.txt

@@ -14,10 +14,14 @@ add_library(radiation STATIC
     "src/RadiationCamera.cpp"
     "src/CameraCalibration.cpp"
     "src/LensFlare.cpp"
+    "src/RayTracingTypes.cpp"
+    "src/backends/OptiX6Backend.cpp"
+    "src/backends/BackendFactory.cpp"
     "tests/selfTest.cpp"
 )
 
 target_include_directories(radiation PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/lib/json" )
+target_include_directories(radiation PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/backends")
 
 find_package(CUDAToolkit REQUIRED)
 set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})