EIC code displayed by LXR master/​include/​orange/​detail/​BvhData.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-10-27 09:40:38

 //------------------------------- -*- C++ -*- -------------------------------//
 // Copyright Celeritas contributors: see top-level COPYRIGHT file for details
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 //---------------------------------------------------------------------------//
 //! \file orange/detail/BvhData.hh
 //! \todo move to orange/BvhTreeData
 //---------------------------------------------------------------------------//
 #pragma once
 
 #include "corecel/Types.hh"
 #include "corecel/cont/EnumArray.hh"
 #include "corecel/data/Collection.hh"
 #include "geocel/BoundingBox.hh"  // IWYU pragma: keep
 
 #include "../OrangeTypes.hh"
 
 namespace celeritas
 {
 namespace detail
 {
 //---------------------------------------------------------------------------//!
 // The maximum depth of the BVH tree (single leaf node is 1)
 inline constexpr size_type max_bvh_depth = 18;
 
 //---------------------------------------------------------------------------//
 /*!
  * Data for a single internal node in a Bounding Volume Hierarchy.
  *
  * As a convention, a node's LEFT edge corresponds to the half space that is
  * less than the partition value. In other words, the LEFT bounding plane
  * position is the far right boundary of the left side of the tree, and the
  * RIGHT bounding plane position is the far left boundary of the right side of
  * the tree. Since the halfspaces created by the bounding planes may overlap,
  * the LEFT bounding plane position could be either left or right of the RIGHT
  * bounding plane position.
  */
 struct BvhInternalNode
 {
     struct Edge
     {
         //! The child node connected to this edge
         BvhNodeId child;
         //! Bbox created by clipping an inf bbox with the bounding planes
         //! between this edge (inclusive) and the root.
         FastBBox bbox;
     };
 
     enum class Side
     {
         left,
         right,
         size_
     };
 
     Axis axis;  //!< Axis that the partition is performed on
     EnumArray<Side, Edge> edges;  //!< Left/right edges
 
     explicit CELER_FUNCTION operator bool() const
     {
         return this->edges[Side::left].child && this->edges[Side::right].child;
     }
 };
 
 //---------------------------------------------------------------------------//
 /*!
  * Data for a single leaf node in a Bounding Volume Hierarchy.
  */
 struct BvhLeafNode
 {
     ItemRange<LocalVolumeId> vol_ids;
 
     explicit CELER_FUNCTION operator bool() const { return !vol_ids.empty(); }
 };
 
 //---------------------------------------------------------------------------//
 /*!
  * Bounding Volume Hierarchy tree.
  *
  * Infinite bounding boxes are not included in the tree itself. They are stored
  * separately and checked after traversing the tree.
  */
 struct BvhTreeRecord
 {
     //// TYPES ////
     struct Metadata
     {
         //! The number of finite bounding boxes in the tree
         size_type num_finite_bboxes{};
         //! The number of infinite bounding boxes, i.e., those not included in
         //! the tree itself.
         size_type num_infinite_bboxes{};
         //! The depth of the most embedded leaf node. This has a value of 1
         //! when the root node is a leaf.
         size_type depth{};
     };
 
     //// DATA ////
 
     //! All bounding boxes managed by the BVH
     ItemMap<LocalVolumeId, FastBBoxId> bboxes;
 
     //! Internal (branch) nodes, the first being the root
     ItemRange<BvhInternalNode> internal_nodes;
 
     //! Leaf nodes
     ItemRange<BvhLeafNode> leaf_nodes;
 
     //! Local volumes that have infinite bounding boxes
     ItemRange<LocalVolumeId> inf_vol_ids;
 
     //! The metadata for this tree
     Metadata metadata;
 
     //// METHODS ////
 
     explicit CELER_FUNCTION operator bool() const
     {
         if (!internal_nodes.empty())
         {
             return !bboxes.empty() && !leaf_nodes.empty();
         }
         else
         {
             // Degenerate single leaf node case. This occurs when a tree
             // contains either:
             // a) a single volume
             // b) multiple non-partitionable volumes,
             // b) only infinite volumes.
             return !bboxes.empty() && leaf_nodes.size() == 1;
         }
     }
 };
 
 //---------------------------------------------------------------------------//
 /*!
  * Persistent data used by all BVH trees.
  */
 template<Ownership W, MemSpace M>
 struct BvhTreeData
 {
     template<class T>
     using Items = Collection<T, W, M>;
 
     // Low-level storage
     Items<FastBBox> bboxes;
     Items<LocalVolumeId> local_volume_ids;
     Items<detail::BvhInternalNode> internal_nodes;
     Items<detail::BvhLeafNode> leaf_nodes;
 
     //! True if assigned
     explicit CELER_FUNCTION operator bool() const
     {
         // Note that internal_nodes may be empty for single-node trees
         return !bboxes.empty() && !local_volume_ids.empty()
                && !leaf_nodes.empty();
     }
 
     //! Assign from another set of data
     template<Ownership W2, MemSpace M2>
     BvhTreeData& operator=(BvhTreeData<W2, M2> const& other)
     {
         bboxes = other.bboxes;
         local_volume_ids = other.local_volume_ids;
         internal_nodes = other.internal_nodes;
         leaf_nodes = other.leaf_nodes;
 
         CELER_ENSURE(static_cast<bool>(*this) == static_cast<bool>(other));
         return *this;
     }
 };
 
 //---------------------------------------------------------------------------//
 }  // namespace detail
 }  // namespace celeritas

This page was automatically generated by the 2.3.7 LXR engine. The LXR team