// ======================================================================== // // Copyright 2009-2017 Intel Corporation // // // // Licensed under the Apache License, Version 2.0 (the "License"); // // you may not use this file except in compliance with the License. // // You may obtain a copy of the License at // // // // http://www.apache.org/licenses/LICENSE-2.0 // // // // Unless required by applicable law or agreed to in writing, software // // distributed under the License is distributed on an "AS IS" BASIS, // // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // // See the License for the specific language governing permissions and // // limitations under the License. // // ======================================================================== // #ifndef __RTCORE_SCENE_ISPH__ #define __RTCORE_SCENE_ISPH__ /*! \ingroup embree_kernel_api */ /*! \{ */ /*! forward declarations for ray structures */ struct RTCRay1; struct RTCRay; struct RTCRayNp; /*! scene flags */ enum RTCSceneFlags { /* dynamic type flags */ RTC_SCENE_STATIC = (0 << 0), //!< specifies static scene RTC_SCENE_DYNAMIC = (1 << 0), //!< specifies dynamic scene /* acceleration structure flags */ RTC_SCENE_COMPACT = (1 << 8), //!< use memory conservative data structures RTC_SCENE_COHERENT = (1 << 9), //!< optimize data structures for coherent rays (enabled by default) RTC_SCENE_INCOHERENT = (1 << 10), //!< optimize data structures for in-coherent rays RTC_SCENE_HIGH_QUALITY = (1 << 11), //!< create higher quality data structures /* traversal algorithm flags */ RTC_SCENE_ROBUST = (1 << 16) //!< use more robust traversal algorithms }; /*! enabled algorithm flags */ enum RTCAlgorithmFlags { RTC_INTERSECT_UNIFORM = (1 << 0), //!< enables the uniform rtcIntersect1 and uniform rtcOccluded1 functions for this scene RTC_INTERSECT_VARYING = (1 << 1) | (1 << 2) | (1 << 3), //!< enables the varying rtcIntersect and varying rtcOccluded functions for this scene RTC_INTERPOLATE = (1 << 4), //!< enables the rtcInterpolate function for this scene RTC_INTERSECT_STREAM = (1 << 5), //!< enables the rtcIntersectN and rtcOccludedN functions for this scene }; /*! intersection flags */ enum RTCIntersectFlags { RTC_INTERSECT_COHERENT = 0, //!< optimize for coherent rays RTC_INTERSECT_INCOHERENT = 1 //!< optimize for incoherent rays }; /*! intersection context passed to intersect/occluded calls */ struct RTCIntersectContext { RTCIntersectFlags flags; //!< intersection flags void* userRayExt; //!< can be used to pass extended ray data to callbacks }; /*! \brief Defines an opaque scene type */ typedef uniform struct __RTCScene {}* uniform RTCScene; /*! Creates a new scene. WARNING: This function is deprecated, use rtcDeviceNewScene instead. */ RTCORE_DEPRECATED RTCScene rtcNewScene (uniform RTCSceneFlags flags, uniform RTCAlgorithmFlags aflags); /*! Creates a new scene. */ RTCScene rtcDeviceNewScene (RTCDevice device, uniform RTCSceneFlags flags, uniform RTCAlgorithmFlags aflags); /*! \brief Type of progress callback function. */ typedef unmasked uniform bool (*uniform RTCProgressMonitorFunc)(void* uniform ptr, const uniform double n); RTCORE_DEPRECATED typedef unmasked uniform bool (*uniform RTC_PROGRESS_MONITOR_FUNCTION)(void* uniform ptr, const uniform double n); /*! \brief Sets the progress callback function which is called during hierarchy build. */ void rtcSetProgressMonitorFunction(RTCScene scene, RTCProgressMonitorFunc func, void* uniform ptr); /*! Commits the geometry of the scene. After initializing or modifying * geometries, commit has to get called before tracing * rays. */ void rtcCommit (RTCScene scene); /*! Commits the geometry of the scene. The calling threads will be * used internally as a worker threads on some implementations. The * function will wait until 'numThreads' threads have called this * function and all threads return from the function after the scene * commit is finished. The application threads will not be used as * worker threads when the TBB tasking system is enabled (which is * the default). On CPUs, we recommend also using TBB inside your * application to share threads. We recommend using the * rtcCommitThread feature to share threads on the Xeon Phi * coprocessor. */ void rtcCommitThread(RTCScene scene, uniform unsigned int threadID, uniform unsigned int numThreads); /*! Returns to AABB of the scene. rtcCommit has to get called * previously to this function. */ void rtcGetBounds(RTCScene scene, uniform RTCBounds& bounds_o); /*! Returns linear AABBs of the scene. The result bounds_o gets filled * with AABBs for time 0 and time 1. rtcCommit has to get called * previously to this function. */ void rtcGetLinearBounds(RTCScene scene, uniform RTCBounds* uniform bounds_o); /*! Intersects a uniform ray with the scene. This function can only be * called for scenes with the RTC_INTERSECT_UNIFORM flag set. The ray * has to be aligned to 16 bytes. */ void rtcIntersect1 (RTCScene scene, uniform RTCRay1& ray); /*! Intersects a varying ray with the scene. This function can only be * called for scenes with the RTC_INTERSECT_VARYING flag set. The * valid mask and ray have both to be aligned to sizeof(varing float) * bytes. */ void rtcIntersect (RTCScene scene, varying RTCRay& ray); /*! Intersects a stream of M rays in AOS layout with the scene. This * function can only be called for scenes with the RTC_INTERSECT_STREAM * flag set. The stride specifies the offset between rays in * bytes. */ void rtcIntersect1M (RTCScene scene, const uniform RTCIntersectContext* uniform context, uniform RTCRay1* uniform rays, const uniform size_t M, const uniform size_t stride); /*! Intersects a stream of pointers to M rays with the scene. This * function can only be called for scenes with the * RTC_INTERSECT_STREAM flag set. */ void rtcIntersect1Mp (RTCScene scene, const uniform RTCIntersectContext* uniform context, uniform RTCRay1** uniform rays, const uniform size_t M); /*! Intersects a stream of M ray packets in SOA format with the scene. This * function can only be called for scenes with the RTC_INTERSECT_STREAM * flag set. The stride specifies the offset between rays in * bytes. */ void rtcIntersectVM (RTCScene scene, const uniform RTCIntersectContext* uniform context, varying RTCRay* uniform rays, const uniform size_t M, const uniform size_t stride); /*! Intersects a stream of M ray packets of size N in SOA format with the * scene. This function can only be called for scenes with the * RTC_INTERSECT_STREAM flag set. The stride specifies the offset between * ray packets in bytes. */ void rtcIntersectNM (RTCScene scene, const uniform RTCIntersectContext* uniform context, struct RTCRayN* uniform rays, const uniform size_t N, const uniform size_t M, const uniform size_t stride); /*! Intersects a stream of M ray packets of size N in SOA format with * the scene. This function can only be called for scenes with the * RTC_INTERSECT_STREAM flag set. The stride specifies the offset between * ray packets in bytes. In contrast to the rtcIntersectNM function * this function accepts a separate data pointer for each component * of the ray packet. */ void rtcIntersectNp (RTCScene scene, const uniform RTCIntersectContext* uniform context, const uniform RTCRayNp& rays, const uniform size_t N); /*! Tests if a uniform ray is occluded by the scene. This function can * only be called for scenes with the RTC_INTERSECT_UNIFORM flag * set. The ray has to be aligned to 16 bytes. */ void rtcOccluded1 (RTCScene scene, uniform RTCRay1& ray); /*! Tests if a varying ray is occluded by the scene. This function can * only be called for scenes with the RTC_INTERSECT_VARYING flag * set. The valid mask and ray have both to be aligned to * sizeof(varing float) bytes. */ void rtcOccluded (RTCScene scene, varying RTCRay& ray); /*! Tests if a stream of M rays in AOS layout is occluded by the * scene. This function can only be called for scenes with the * RTC_INTERSECT_STREAM flag set. The stride specifies the offset between * rays in bytes.*/ void rtcOccluded1M (RTCScene scene, const uniform RTCIntersectContext* uniform context, uniform RTCRay1* uniform rays, const uniform size_t M, const uniform size_t stride); /*! Tests if a stream of pointers to M rays in AOS layout is occluded by the * scene. This function can only be called for scenes with the * RTC_INTERSECT_STREAM flag set. */ void rtcOccluded1Mp (RTCScene scene, const uniform RTCIntersectContext* uniform context, uniform RTCRay1** uniform rays, const uniform size_t M); /*! Tests if a stream of M ray packets in SOA format is occluded by the * scene. This function can only be called for scenes with the * RTC_INTERSECT_STREAM flag set. The stride specifies the offset between * rays in bytes.*/ void rtcOccludedVM (RTCScene scene, const uniform RTCIntersectContext* uniform context, varying RTCRay* uniform rays, const uniform size_t M, const uniform size_t stride); /*! Tests if a stream of M ray packets of size N in SOA format is * occluded by the scene. This function can only be called for scenes * with the RTC_INTERSECT_STREAM flag set. The stride specifies the offset * between rays in bytes.*/ void rtcOccludedNM (RTCScene scene, const uniform RTCIntersectContext* uniform context, struct RTCRayN* uniform rays, const uniform size_t N, const uniform size_t M, const uniform size_t stride); /*! Tests if a stream of M ray packets of size N in SOA format is * occluded by the scene. This function can only be called for scenes * with the RTC_INTERSECT_STREAM flag set. The stride specifies the offset * between rays in bytes. In contrast to the rtcOccludedNM function * this function accepts a separate data pointer for each component * of the ray packet. */ void rtcOccludedNp (RTCScene scene, const uniform RTCIntersectContext* uniform context, const uniform RTCRayNp& rays, const uniform size_t N); /*! Deletes the geometry again. */ void rtcDeleteScene (RTCScene scene); /*! @} */ #endif