// Copyright 2009-2021 Intel Corporation // SPDX-License-Identifier: Apache-2.0 #pragma once #include "bvh_node_base.h" namespace embree { /*! Node with unaligned bounds */ template<typename NodeRef, int N> struct OBBNode_t : public BaseNode_t<NodeRef, N> { using BaseNode_t<NodeRef,N>::children; struct Create { __forceinline NodeRef operator() (const FastAllocator::CachedAllocator& alloc) const { OBBNode_t* node = (OBBNode_t*) alloc.malloc0(sizeof(OBBNode_t),NodeRef::byteNodeAlignment); node->clear(); return NodeRef::encodeNode(node); } }; struct Set { __forceinline void operator() (NodeRef node, size_t i, NodeRef child, const OBBox3fa& bounds) const { node.ungetAABBNode()->setRef(i,child); node.ungetAABBNode()->setBounds(i,bounds); } }; /*! Clears the node. */ __forceinline void clear() { naabb.l.vx = Vec3fa(nan); naabb.l.vy = Vec3fa(nan); naabb.l.vz = Vec3fa(nan); naabb.p = Vec3fa(nan); BaseNode_t<NodeRef,N>::clear(); } /*! Sets bounding box. */ __forceinline void setBounds(size_t i, const OBBox3fa& b) { assert(i < N); AffineSpace3fa space = b.space; space.p -= b.bounds.lower; space = AffineSpace3fa::scale(1.0f/max(Vec3fa(1E-19f),b.bounds.upper-b.bounds.lower))*space; naabb.l.vx.x[i] = space.l.vx.x; naabb.l.vx.y[i] = space.l.vx.y; naabb.l.vx.z[i] = space.l.vx.z; naabb.l.vy.x[i] = space.l.vy.x; naabb.l.vy.y[i] = space.l.vy.y; naabb.l.vy.z[i] = space.l.vy.z; naabb.l.vz.x[i] = space.l.vz.x; naabb.l.vz.y[i] = space.l.vz.y; naabb.l.vz.z[i] = space.l.vz.z; naabb.p.x[i] = space.p.x; naabb.p.y[i] = space.p.y; naabb.p.z[i] = space.p.z; } /*! Sets ID of child. */ __forceinline void setRef(size_t i, const NodeRef& ref) { assert(i < N); children[i] = ref; } /*! Returns the extent of the bounds of the ith child */ __forceinline Vec3fa extent(size_t i) const { assert(i<N); const Vec3fa vx(naabb.l.vx.x[i],naabb.l.vx.y[i],naabb.l.vx.z[i]); const Vec3fa vy(naabb.l.vy.x[i],naabb.l.vy.y[i],naabb.l.vy.z[i]); const Vec3fa vz(naabb.l.vz.x[i],naabb.l.vz.y[i],naabb.l.vz.z[i]); return rsqrt(vx*vx + vy*vy + vz*vz); } /*! Returns reference to specified child */ __forceinline NodeRef& child(size_t i) { assert(i<N); return children[i]; } __forceinline const NodeRef& child(size_t i) const { assert(i<N); return children[i]; } /*! output operator */ friend embree_ostream operator<<(embree_ostream o, const OBBNode_t& n) { o << "UnAABBNode { " << n.naabb << " } " << embree_endl; return o; } public: AffineSpace3vf<N> naabb; //!< non-axis aligned bounding boxes (bounds are [0,1] in specified space) }; }