153 lines
7.1 KiB
Plaintext
153 lines
7.1 KiB
Plaintext
// ======================================================================== //
|
|
// Copyright 2009-2015 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 RTCRaySOA;
|
|
|
|
/*! 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), //!< enables the varying rtcIntersect and varying rtcOccluded functions for this scene
|
|
RTC_INTERPOLATE = (1 << 4) //!< enables the rtcInterpolate function for this scene
|
|
};
|
|
|
|
/*! layout flags for ray streams */
|
|
enum RTCRayNFlags
|
|
{
|
|
RTC_RAYN_DEFAULT = (1 << 0)
|
|
};
|
|
|
|
|
|
/*! \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 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, RTC_PROGRESS_MONITOR_FUNCTION 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);
|
|
|
|
/*! 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 N rays in AOS layout with the scene. This
|
|
* function can only be called for scenes with the RTC_INTERSECTN
|
|
* flag set. The stride specifies the offset between rays in
|
|
* bytes. */
|
|
void rtcIntersectN (RTCScene scene, uniform RTCRay* uniform rayN, const uniform size_t N, const uniform size_t stride, const uniform size_t flags);
|
|
|
|
/*! Intersects one or multiple streams of N rays in compact SOA layout with the scene. This
|
|
* function can only be called for scenes with the RTC_INTERSECTN
|
|
* flag set. 'streams' specifies the number of dense SOA ray
|
|
* streams, and 'stride' the offset in bytes between those. */
|
|
void rtcIntersectN_SOA (RTCScene scene, uniform RTCRaySOA& rayN, const uniform size_t N, const uniform size_t streams, const uniform size_t offset, const uniform size_t flags);
|
|
|
|
|
|
/*! 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 N rays on AOS layout is occluded by the
|
|
* scene. This function can only be called for scenes with the
|
|
* RTC_INTERSECTN flag set. The stride specifies the offset between
|
|
* rays in bytes.*/
|
|
void rtcOccludedN (RTCScene scene, uniform RTCRay* uniform rayN, const uniform size_t N, const uniform size_t stride, const uniform size_t flags);
|
|
|
|
/*! Intersects one or multiple streams of N rays in compact SOA layout with the scene. This
|
|
* function can only be called for scenes with the RTC_INTERSECTN
|
|
* flag set. 'streams' specifies the number of dense SOA ray
|
|
* streams, and 'stride' the offset in bytes between those. */
|
|
void rtcOccludedN_SOA (RTCScene scene, uniform RTCRaySOA& rayN, const uniform size_t N, const uniform size_t streams, const uniform size_t offset, const uniform size_t flags);
|
|
|
|
/*! Deletes the geometry again. */
|
|
void rtcDeleteScene (RTCScene scene);
|
|
|
|
/*! @} */
|
|
|
|
#endif
|