[1.3.70] 2026-03-19

- `deletePlantInstance()` now cleans up hidden prototype primitives from the Context when all plant instances have been deleted, preventing orphaned hidden primitives and materials that could never be freed. Added optional `include_hidden` parameter to `getAllPlantUUIDs()` to allow querying hidden prototype primitives.

- CMake now verifies that the CUDA language can actually be enabled (e.g., Visual Studio MSBuild integration is installed) before attempting a GPU build in the radiation, collision detection, and energy balance plugins, preventing cryptic build failures when the CUDA toolkit is installed without Visual Studio integration.
- Bundled Vulkan SDK headers and glslang 16.2.0 shader compiler source with the radiation plugin.

Author: bnbailey-psl

doc/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+# [1.3.70] 2026-03-19
+
+## Plant Architecture
+- `deletePlantInstance()` now cleans up hidden prototype primitives from the Context when all plant instances have been deleted, preventing orphaned hidden primitives and materials that could never be freed. Added optional `include_hidden` parameter to `getAllPlantUUIDs()` to allow querying hidden prototype primitives.
+
+## Radiation
+- Fixed camera pixel label UUID mapping where the CPU-side conversion from internal primitive indices to Helios UUIDs produced incorrect labels when `buildGeometryData` reordered primitives by parent object. The GPU intersection programs already store actual UUIDs directly, so the redundant conversion was removed.
+
+## Build System
+- CMake now verifies that the CUDA language can actually be enabled (e.g., Visual Studio MSBuild integration is installed) before attempting a GPU build in the radiation, collision detection, and energy balance plugins, preventing cryptic build failures when the CUDA toolkit is installed without Visual Studio integration.
+- Bundled Vulkan SDK headers and glslang 16.2.0 shader compiler source with the radiation plugin.
+
 # [1.3.69] 2026-03-16
 
 ## Core

doc/UserGuide.dox

@@ -235,6 +235,8 @@
 
   The NVIDIA CUDA library is required to build the Aerial LiDAR plugin. For the radiation model, CUDA enables the OptiX backend (which is the preferred backend on NVIDIA systems), but is not required if you use the Vulkan backend instead. Consult this page for help choosing the right CUDA version based on your C++ compiler and GPU compute capability: \ref ChoosingCUDA.
 
+  \note <b>Install Visual Studio before the CUDA Toolkit.</b> The CUDA installer copies MSBuild integration files (<tt>.props</tt>, <tt>.targets</tt>, <tt>.xml</tt>) into Visual Studio's <tt>BuildCustomizations</tt> directory. If Visual Studio is not installed first, these files are placed only in the CUDA Toolkit directory and CMake will fail with "No CUDA toolset found." If you have already installed CUDA before Visual Studio, you can fix this by reinstalling the CUDA Toolkit (or by manually copying the files from <tt>C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v1X.X\\extras\\visual_studio_integration\\MSBuildExtensions\\</tt> into your Visual Studio <tt>BuildCustomizations</tt> directory).
+
   The latest CUDA version can be downloaded here: <a href="https://developer.nvidia.com/cuda-downloads">https://developer.nvidia.com/cuda-downloads</a> (note that if you installed Visual Studio 2019 instead of 2022, you'll need to install CUDA 10.2 instead of the latest version). Download the base CUDA Toolkit installer for your Windows OS. Installing from the "exe (network)" type will result in a smaller file being downloaded. Click through the installer and accept all the default options. By default, it should have installed to 'C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v1X.X\\', where v1X.X is the version that you installed. You can verify this installation location using the file browser.
 
   In order to use CUDA within CLion, you need to tell it where to find the CUDA toolkit. To do this, open up the settings in CLion, and go to "Build, Execution, Deployment" and then to CMake. Click the icon next to the "Environment" field to edit environmental variables. Find the variable named "Path", and double click to edit it. At the end of the list of directories, add the path to the CUDA bin folder, i.e., 'C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v1X.X\\bin;'. Make sure there is a semicolon before and after the path, and that you replace the v1X.X with your actual CUDA version. It is important to hit the return key, which should cause the Path variable list to turn blue. When you hit OK, the Path variable should be listed under the Environment field.

plugins/collisiondetection/CMakeLists.txt

@@ -11,6 +11,16 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Mo
 # Try to find CUDA toolkit
 find_package(CUDAToolkit QUIET)
 
+# Verify that the CUDA language can actually be enabled (e.g., VS integration is installed)
+if(CUDAToolkit_FOUND)
+    include(CheckLanguage)
+    check_language(CUDA)
+    if(NOT CMAKE_CUDA_COMPILER)
+        message(STATUS "CUDA toolkit found but CUDA language could not be enabled (missing Visual Studio integration?) - falling back to CPU-only build")
+        set(CUDAToolkit_FOUND FALSE)
+    endif()
+endif()
+
 if(CUDAToolkit_FOUND)
     message(STATUS "CUDA found - building with GPU acceleration")
     set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})

plugins/energybalance/CMakeLists.txt

@@ -10,6 +10,16 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Mo
 # Try to find CUDA toolkit (optional)
 find_package(CUDAToolkit QUIET)
 
+# Verify that the CUDA language can actually be enabled (e.g., VS integration is installed)
+if(CUDAToolkit_FOUND)
+    include(CheckLanguage)
+    check_language(CUDA)
+    if(NOT CMAKE_CUDA_COMPILER)
+        message(STATUS "CUDA toolkit found but CUDA language could not be enabled (missing Visual Studio integration?) - falling back to CPU-only build")
+        set(CUDAToolkit_FOUND FALSE)
+    endif()
+endif()
+
 if(CUDAToolkit_FOUND)
     set(CMAKE_CUDA_COMPILER ${CUDAToolkit_NVCC_EXECUTABLE})
 

plugins/plantarchitecture/doc/PlantArchitecture.dox

@@ -1125,7 +1125,7 @@ The Object IDs and Primitive UUIDs of an entire plant, or organ groups in the pl
     <tr> <td>\ref PlantArchitecture::getPlantFlowerObjectIDs()</td><td>Returns a vector of Object IDs for all flower objects.</td> </tr>
     <tr> <td>\ref PlantArchitecture::getPlantFruitObjectIDs()</td><td>Returns a vector of Object IDs for all fruit objects.</td> </tr>
     <tr> <td colspan=2> **Primitive UUIDs** </td> </tr>
-    <tr> <td>\ref PlantArchitecture::getAllPlantUUIDs()</td><td>Returns a vector of UUIDs for all primitives the entire plant.</td> </tr>
+    <tr> <td>\ref PlantArchitecture::getAllPlantUUIDs(uint, bool)</td><td>Returns a vector of UUIDs for all primitives in the entire plant. Optionally includes hidden prototype primitives when \p include_hidden is set to true.</td> </tr>
 </table>
 
 Note that individual methods to get UUIDs for all organ types are not provided. Instead, the user can query the Object IDs for each organ type and then get the corresponding UUIDs using the Context method \ref helios::Context::getObjectPrimitiveUUIDs().

plugins/plantarchitecture/include/PlantArchitecture.h

@@ -1921,6 +1921,7 @@ class PlantArchitecture {
     //! Delete an existing plant instance
     /**
      * \param[in] plantID ID of the plant instance to be deleted.
+     * \note When all plant instances have been deleted, hidden prototype objects are also cleaned up from the Context.
      */
     void deletePlantInstance(uint plantID);
 
@@ -2653,9 +2654,10 @@ class PlantArchitecture {
     //! Get primitive UUIDs for all primitives in a given plant
     /**
      * \param[in] plantID ID of the plant instance.
-     * \return Vector of primitive UUIDs for all primitives in the plant.
+     * \param[in] include_hidden If true, also include UUIDs of hidden prototype primitives managed by this PlantArchitecture instance (prototypes are shared across all plant instances, not specific to one plant).
+     * \return Vector of primitive UUIDs for all primitives in the plant (and optionally hidden prototypes).
      */
-    [[nodiscard]] std::vector<uint> getAllPlantUUIDs(uint plantID) const;
+    [[nodiscard]] std::vector<uint> getAllPlantUUIDs(uint plantID, bool include_hidden = false) const;
 
     //! Get object IDs for all internode (Tube) objects for a given plant
     /**
@@ -3045,6 +3047,12 @@ class PlantArchitecture {
     // Key is the prototype function pointer; value index is the unique fruit prototype
     std::map<uint (*)(helios::Context *context_ptr, uint subdivisions), std::vector<uint>> unique_fruit_prototype_objIDs;
 
+    //! Get object IDs for all hidden prototype objects managed by this PlantArchitecture instance
+    [[nodiscard]] std::vector<uint> getAllPrototypeObjectIDs() const;
+
+    //! Delete all hidden prototype objects from the Context and clear the prototype maps
+    void deleteAllPrototypes();
+
     bool build_context_geometry_internode = true;
     bool build_context_geometry_petiole = true;
     bool build_context_geometry_peduncle = true;

plugins/plantarchitecture/src/PlantArchitecture.cpp

@@ -4452,8 +4452,59 @@ std::vector<uint> PlantArchitecture::getAllPlantObjectIDs(uint plantID) const {
     return objIDs;
 }
 
-std::vector<uint> PlantArchitecture::getAllPlantUUIDs(uint plantID) const {
-    return context_ptr->getObjectPrimitiveUUIDs(getAllPlantObjectIDs(plantID));
+std::vector<uint> PlantArchitecture::getAllPrototypeObjectIDs() const {
+    std::vector<uint> objIDs;
+    for (const auto &[key, prototype_vec] : unique_leaf_prototype_objIDs) {
+        for (const auto &leaflet_vec : prototype_vec) {
+            for (uint objID : leaflet_vec) {
+                if (context_ptr->doesObjectExist(objID)) {
+                    objIDs.push_back(objID);
+                }
+            }
+        }
+    }
+    for (const auto &[key, prototype_vec] : unique_closed_flower_prototype_objIDs) {
+        for (uint objID : prototype_vec) {
+            if (context_ptr->doesObjectExist(objID)) {
+                objIDs.push_back(objID);
+            }
+        }
+    }
+    for (const auto &[key, prototype_vec] : unique_open_flower_prototype_objIDs) {
+        for (uint objID : prototype_vec) {
+            if (context_ptr->doesObjectExist(objID)) {
+                objIDs.push_back(objID);
+            }
+        }
+    }
+    for (const auto &[key, prototype_vec] : unique_fruit_prototype_objIDs) {
+        for (uint objID : prototype_vec) {
+            if (context_ptr->doesObjectExist(objID)) {
+                objIDs.push_back(objID);
+            }
+        }
+    }
+    return objIDs;
+}
+
+void PlantArchitecture::deleteAllPrototypes() {
+    std::vector<uint> prototype_objIDs = getAllPrototypeObjectIDs();
+    for (uint objID : prototype_objIDs) {
+        context_ptr->deleteObject(objID);
+    }
+    unique_leaf_prototype_objIDs.clear();
+    unique_open_flower_prototype_objIDs.clear();
+    unique_closed_flower_prototype_objIDs.clear();
+    unique_fruit_prototype_objIDs.clear();
+}
+
+std::vector<uint> PlantArchitecture::getAllPlantUUIDs(uint plantID, bool include_hidden) const {
+    std::vector<uint> objIDs = getAllPlantObjectIDs(plantID);
+    if (include_hidden) {
+        std::vector<uint> prototype_objIDs = getAllPrototypeObjectIDs();
+        objIDs.insert(objIDs.end(), prototype_objIDs.begin(), prototype_objIDs.end());
+    }
+    return context_ptr->getObjectPrimitiveUUIDs(objIDs);
 }
 
 std::vector<uint> PlantArchitecture::getPlantInternodeObjectIDs(uint plantID) const {
@@ -4882,6 +4933,10 @@ void PlantArchitecture::deletePlantInstance(uint plantID) {
     context_ptr->deleteObject(getAllPlantObjectIDs(plantID));
 
     plant_instances.erase(plantID);
+
+    if (plant_instances.empty()) {
+        deleteAllPrototypes();
+    }
 }
 
 void PlantArchitecture::deletePlantInstance(const std::vector<uint> &plantIDs) {

plugins/plantarchitecture/tests/selfTest.cpp

@@ -2524,6 +2524,82 @@ DOCTEST_TEST_CASE("PlantArchitecture setProgressCallback") {
     }
 }
 
+DOCTEST_TEST_CASE("getAllPlantUUIDs with include_hidden parameter") {
+    Context context;
+    PlantArchitecture plantarchitecture(&context);
+    plantarchitecture.disableMessages();
+    plantarchitecture.loadPlantModelFromLibrary("bean");
+    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000);
+
+    std::vector<uint> uuids_default = plantarchitecture.getAllPlantUUIDs(plantID);
+    std::vector<uint> uuids_no_hidden = plantarchitecture.getAllPlantUUIDs(plantID, false);
+    std::vector<uint> uuids_with_hidden = plantarchitecture.getAllPlantUUIDs(plantID, true);
+
+    // Default behavior should match explicit false
+    DOCTEST_CHECK(uuids_default.size() == uuids_no_hidden.size());
+
+    // include_hidden=true should return more UUIDs (the hidden prototypes)
+    DOCTEST_CHECK(uuids_with_hidden.size() > uuids_no_hidden.size());
+}
+
+DOCTEST_TEST_CASE("deletePlantInstance cleans up prototypes when all plants deleted") {
+    Context context;
+    PlantArchitecture plantarchitecture(&context);
+    plantarchitecture.disableMessages();
+    plantarchitecture.loadPlantModelFromLibrary("bean");
+
+    uint plantID1 = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000);
+    uint plantID2 = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(1, 0, 0), 5000);
+
+    // Identify hidden prototype UUIDs
+    std::vector<uint> all_uuids = plantarchitecture.getAllPlantUUIDs(plantID1, true);
+    std::vector<uint> visible_uuids = plantarchitecture.getAllPlantUUIDs(plantID1, false);
+    DOCTEST_CHECK(all_uuids.size() > visible_uuids.size());
+
+    // Collect prototype UUIDs (those in all but not in visible)
+    std::set<uint> visible_set(visible_uuids.begin(), visible_uuids.end());
+    std::vector<uint> prototype_uuids;
+    for (uint uuid : all_uuids) {
+        if (visible_set.find(uuid) == visible_set.end()) {
+            prototype_uuids.push_back(uuid);
+        }
+    }
+    DOCTEST_CHECK(prototype_uuids.size() > 0);
+
+    // Delete first plant — prototypes should survive
+    plantarchitecture.deletePlantInstance(plantID1);
+    for (uint uuid : prototype_uuids) {
+        DOCTEST_CHECK(context.doesPrimitiveExist(uuid));
+    }
+
+    // Delete second plant — prototypes should now be cleaned up
+    plantarchitecture.deletePlantInstance(plantID2);
+    for (uint uuid : prototype_uuids) {
+        DOCTEST_CHECK(!context.doesPrimitiveExist(uuid));
+    }
+}
+
+DOCTEST_TEST_CASE("deletePlantInstance preserves prototypes when plants remain") {
+    Context context;
+    PlantArchitecture plantarchitecture(&context);
+    plantarchitecture.disableMessages();
+    plantarchitecture.loadPlantModelFromLibrary("bean");
+
+    uint plantID1 = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000);
+    uint plantID2 = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(1, 0, 0), 5000);
+
+    // Get prototype UUIDs via the second plant
+    std::vector<uint> uuids_with_hidden = plantarchitecture.getAllPlantUUIDs(plantID2, true);
+    std::vector<uint> uuids_without_hidden = plantarchitecture.getAllPlantUUIDs(plantID2, false);
+    DOCTEST_CHECK(uuids_with_hidden.size() > uuids_without_hidden.size());
+
+    // Delete first plant — prototypes should still be accessible for remaining plant
+    plantarchitecture.deletePlantInstance(plantID1);
+
+    std::vector<uint> uuids_after = plantarchitecture.getAllPlantUUIDs(plantID2, true);
+    DOCTEST_CHECK(uuids_after.size() > plantarchitecture.getAllPlantUUIDs(plantID2, false).size());
+}
+
 int PlantArchitecture::selfTest(int argc, char **argv) {
     return helios::runDoctestWithValidation(argc, argv);
 }

plugins/radiation/CMakeLists.txt

@@ -33,6 +33,16 @@ message(STATUS "[Radiation] FORCE_VULKAN_BACKEND = ${FORCE_VULKAN_BACKEND}")
 # Try to find CUDA/OptiX (optional)
 find_package(CUDAToolkit QUIET)
 
+# Verify that the CUDA language can actually be enabled (e.g., VS integration is installed)
+if(CUDAToolkit_FOUND AND NOT FORCE_VULKAN_BACKEND)
+    include(CheckLanguage)
+    check_language(CUDA)
+    if(NOT CMAKE_CUDA_COMPILER)
+        message(STATUS "CUDA toolkit found but CUDA language could not be enabled (missing Visual Studio integration?) - falling back to Vulkan-only build")
+        set(CUDAToolkit_FOUND FALSE)
+    endif()
+endif()
+
 set(HAVE_OPTIX FALSE)
 set(HAVE_OPTIX8 FALSE)
 set(OPTIX_BACKEND_SOURCES "")

plugins/radiation/lib/glslang-16.2.0/glslang-16.2.0/.clang-format

@@ -0,0 +1,13 @@
+Language: Cpp
+IndentWidth: 4
+PointerAlignment: Left
+BreakBeforeBraces: Custom
+BraceWrapping: { AfterFunction: true, AfterControlStatement: false }
+IndentCaseLabels: false
+ReflowComments: false
+ColumnLimit: 120
+AccessModifierOffset: -4
+AlignTrailingComments: true
+AllowShortBlocksOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false