AtomicGameEngine/Source/ThirdParty/embree/include/embree2/rtcore_scene.isph

// ======================================================================== //
// 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 in join mode. When Embree is
 *  using TBB (default), threads that call `rtcCommitJoin` will
 *  participate in the hierarchy build procedure. When Embree is using
 *  the internal tasking system, exclusively threads that call
 *  `rtcCommitJoin` will execute the build procedure. Do not
 *  mix `rtcCommitJoin` with other commit calls. */
void rtcCommitJoin (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 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 rtcIntersect1Ex (RTCScene scene, const uniform RTCIntersectContext* uniform context, 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 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 rtcIntersectEx (RTCScene scene, const uniform RTCIntersectContext* uniform context, 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 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 rtcOccluded1Ex (RTCScene scene, const uniform RTCIntersectContext* uniform context, 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 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 rtcOccludedEx (RTCScene scene, const uniform RTCIntersectContext* uniform context, 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