2021-05-20 10:49:33 +00:00
// Copyright 2009-2021 Intel Corporation
2020-12-19 13:50:20 +00:00
// SPDX-License-Identifier: Apache-2.0
# define RTC_EXPORT_API
# include "default.h"
# include "device.h"
# include "scene.h"
# include "context.h"
2022-11-24 14:45:59 +00:00
# include "../geometry/filter.h"
2020-12-19 13:50:20 +00:00
# include "../../include/embree3/rtcore_ray.h"
using namespace embree ;
RTC_NAMESPACE_BEGIN ;
/* mutex to make API thread safe */
2021-05-20 10:49:33 +00:00
static MutexSys g_mutex ;
2020-12-19 13:50:20 +00:00
RTC_API RTCDevice rtcNewDevice ( const char * config )
{
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcNewDevice ) ;
Lock < MutexSys > lock ( g_mutex ) ;
Device * device = new Device ( config ) ;
return ( RTCDevice ) device - > refInc ( ) ;
RTC_CATCH_END ( nullptr ) ;
return ( RTCDevice ) nullptr ;
}
RTC_API void rtcRetainDevice ( RTCDevice hdevice )
{
Device * device = ( Device * ) hdevice ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcRetainDevice ) ;
RTC_VERIFY_HANDLE ( hdevice ) ;
Lock < MutexSys > lock ( g_mutex ) ;
device - > refInc ( ) ;
RTC_CATCH_END ( nullptr ) ;
}
RTC_API void rtcReleaseDevice ( RTCDevice hdevice )
{
Device * device = ( Device * ) hdevice ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcReleaseDevice ) ;
RTC_VERIFY_HANDLE ( hdevice ) ;
Lock < MutexSys > lock ( g_mutex ) ;
device - > refDec ( ) ;
RTC_CATCH_END ( nullptr ) ;
}
RTC_API ssize_t rtcGetDeviceProperty ( RTCDevice hdevice , RTCDeviceProperty prop )
{
Device * device = ( Device * ) hdevice ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetDeviceProperty ) ;
RTC_VERIFY_HANDLE ( hdevice ) ;
Lock < MutexSys > lock ( g_mutex ) ;
return device - > getProperty ( prop ) ;
RTC_CATCH_END ( device ) ;
return 0 ;
}
RTC_API void rtcSetDeviceProperty ( RTCDevice hdevice , const RTCDeviceProperty prop , ssize_t val )
{
Device * device = ( Device * ) hdevice ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetDeviceProperty ) ;
const bool internal_prop = ( size_t ) prop > = 1000000 & & ( size_t ) prop < 1000004 ;
if ( ! internal_prop ) RTC_VERIFY_HANDLE ( hdevice ) ; // allow NULL device for special internal settings
Lock < MutexSys > lock ( g_mutex ) ;
device - > setProperty ( prop , val ) ;
RTC_CATCH_END ( device ) ;
}
RTC_API RTCError rtcGetDeviceError ( RTCDevice hdevice )
{
Device * device = ( Device * ) hdevice ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetDeviceError ) ;
if ( device = = nullptr ) return Device : : getThreadErrorCode ( ) ;
else return device - > getDeviceErrorCode ( ) ;
RTC_CATCH_END ( device ) ;
return RTC_ERROR_UNKNOWN ;
}
RTC_API void rtcSetDeviceErrorFunction ( RTCDevice hdevice , RTCErrorFunction error , void * userPtr )
{
Device * device = ( Device * ) hdevice ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetDeviceErrorFunction ) ;
RTC_VERIFY_HANDLE ( hdevice ) ;
device - > setErrorFunction ( error , userPtr ) ;
RTC_CATCH_END ( device ) ;
}
RTC_API void rtcSetDeviceMemoryMonitorFunction ( RTCDevice hdevice , RTCMemoryMonitorFunction memoryMonitor , void * userPtr )
{
Device * device = ( Device * ) hdevice ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetDeviceMemoryMonitorFunction ) ;
device - > setMemoryMonitorFunction ( memoryMonitor , userPtr ) ;
RTC_CATCH_END ( device ) ;
}
RTC_API RTCBuffer rtcNewBuffer ( RTCDevice hdevice , size_t byteSize )
{
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcNewBuffer ) ;
RTC_VERIFY_HANDLE ( hdevice ) ;
Buffer * buffer = new Buffer ( ( Device * ) hdevice , byteSize ) ;
return ( RTCBuffer ) buffer - > refInc ( ) ;
RTC_CATCH_END ( ( Device * ) hdevice ) ;
return nullptr ;
}
RTC_API RTCBuffer rtcNewSharedBuffer ( RTCDevice hdevice , void * ptr , size_t byteSize )
{
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcNewSharedBuffer ) ;
RTC_VERIFY_HANDLE ( hdevice ) ;
Buffer * buffer = new Buffer ( ( Device * ) hdevice , byteSize , ptr ) ;
return ( RTCBuffer ) buffer - > refInc ( ) ;
RTC_CATCH_END ( ( Device * ) hdevice ) ;
return nullptr ;
}
RTC_API void * rtcGetBufferData ( RTCBuffer hbuffer )
{
Buffer * buffer = ( Buffer * ) hbuffer ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetBufferData ) ;
RTC_VERIFY_HANDLE ( hbuffer ) ;
return buffer - > data ( ) ;
RTC_CATCH_END2 ( buffer ) ;
return nullptr ;
}
RTC_API void rtcRetainBuffer ( RTCBuffer hbuffer )
{
Buffer * buffer = ( Buffer * ) hbuffer ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcRetainBuffer ) ;
RTC_VERIFY_HANDLE ( hbuffer ) ;
buffer - > refInc ( ) ;
RTC_CATCH_END2 ( buffer ) ;
}
RTC_API void rtcReleaseBuffer ( RTCBuffer hbuffer )
{
Buffer * buffer = ( Buffer * ) hbuffer ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcReleaseBuffer ) ;
RTC_VERIFY_HANDLE ( hbuffer ) ;
buffer - > refDec ( ) ;
RTC_CATCH_END2 ( buffer ) ;
}
RTC_API RTCScene rtcNewScene ( RTCDevice hdevice )
{
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcNewScene ) ;
RTC_VERIFY_HANDLE ( hdevice ) ;
Scene * scene = new Scene ( ( Device * ) hdevice ) ;
return ( RTCScene ) scene - > refInc ( ) ;
RTC_CATCH_END ( ( Device * ) hdevice ) ;
return nullptr ;
}
RTC_API RTCDevice rtcGetSceneDevice ( RTCScene hscene )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetSceneDevice ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
return ( RTCDevice ) scene - > device - > refInc ( ) ; // user will own one additional device reference
RTC_CATCH_END2 ( scene ) ;
return ( RTCDevice ) nullptr ;
}
RTC_API void rtcSetSceneProgressMonitorFunction ( RTCScene hscene , RTCProgressMonitorFunction progress , void * ptr )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetSceneProgressMonitorFunction ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
Lock < MutexSys > lock ( g_mutex ) ;
scene - > setProgressMonitorFunction ( progress , ptr ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcSetSceneBuildQuality ( RTCScene hscene , RTCBuildQuality quality )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetSceneBuildQuality ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
if ( quality ! = RTC_BUILD_QUALITY_LOW & &
quality ! = RTC_BUILD_QUALITY_MEDIUM & &
quality ! = RTC_BUILD_QUALITY_HIGH )
2021-05-04 09:07:12 +00:00
// -- GODOT start --
// throw std::runtime_error("invalid build quality");
abort ( ) ;
// -- GODOT end --
2020-12-19 13:50:20 +00:00
scene - > setBuildQuality ( quality ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcSetSceneFlags ( RTCScene hscene , RTCSceneFlags flags )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetSceneFlags ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
scene - > setSceneFlags ( flags ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API RTCSceneFlags rtcGetSceneFlags ( RTCScene hscene )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetSceneFlags ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
return scene - > getSceneFlags ( ) ;
RTC_CATCH_END2 ( scene ) ;
return RTC_SCENE_FLAG_NONE ;
}
RTC_API void rtcCommitScene ( RTCScene hscene )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcCommitScene ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
scene - > commit ( false ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcJoinCommitScene ( RTCScene hscene )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcJoinCommitScene ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
scene - > commit ( true ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcGetSceneBounds ( RTCScene hscene , RTCBounds * bounds_o )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetSceneBounds ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
BBox3fa bounds = scene - > bounds . bounds ( ) ;
bounds_o - > lower_x = bounds . lower . x ;
bounds_o - > lower_y = bounds . lower . y ;
bounds_o - > lower_z = bounds . lower . z ;
bounds_o - > align0 = 0 ;
bounds_o - > upper_x = bounds . upper . x ;
bounds_o - > upper_y = bounds . upper . y ;
bounds_o - > upper_z = bounds . upper . z ;
bounds_o - > align1 = 0 ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcGetSceneLinearBounds ( RTCScene hscene , RTCLinearBounds * bounds_o )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetSceneBounds ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
if ( bounds_o = = nullptr )
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " invalid destination pointer " ) ;
if ( scene - > isModified ( ) )
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
bounds_o - > bounds0 . lower_x = scene - > bounds . bounds0 . lower . x ;
bounds_o - > bounds0 . lower_y = scene - > bounds . bounds0 . lower . y ;
bounds_o - > bounds0 . lower_z = scene - > bounds . bounds0 . lower . z ;
bounds_o - > bounds0 . align0 = 0 ;
bounds_o - > bounds0 . upper_x = scene - > bounds . bounds0 . upper . x ;
bounds_o - > bounds0 . upper_y = scene - > bounds . bounds0 . upper . y ;
bounds_o - > bounds0 . upper_z = scene - > bounds . bounds0 . upper . z ;
bounds_o - > bounds0 . align1 = 0 ;
bounds_o - > bounds1 . lower_x = scene - > bounds . bounds1 . lower . x ;
bounds_o - > bounds1 . lower_y = scene - > bounds . bounds1 . lower . y ;
bounds_o - > bounds1 . lower_z = scene - > bounds . bounds1 . lower . z ;
bounds_o - > bounds1 . align0 = 0 ;
bounds_o - > bounds1 . upper_x = scene - > bounds . bounds1 . upper . x ;
bounds_o - > bounds1 . upper_y = scene - > bounds . bounds1 . upper . y ;
bounds_o - > bounds1 . upper_z = scene - > bounds . bounds1 . upper . z ;
bounds_o - > bounds1 . align1 = 0 ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcCollide ( RTCScene hscene0 , RTCScene hscene1 , RTCCollideFunc callback , void * userPtr )
{
Scene * scene0 = ( Scene * ) hscene0 ;
Scene * scene1 = ( Scene * ) hscene1 ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcCollide ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene0 ) ;
RTC_VERIFY_HANDLE ( hscene1 ) ;
if ( scene0 - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene got not committed " ) ;
if ( scene1 - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene got not committed " ) ;
if ( scene0 - > device ! = scene1 - > device ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scenes are from different devices " ) ;
auto nUserPrims0 = scene0 - > getNumPrimitives ( Geometry : : MTY_USER_GEOMETRY , false ) ;
auto nUserPrims1 = scene1 - > getNumPrimitives ( Geometry : : MTY_USER_GEOMETRY , false ) ;
if ( scene0 - > numPrimitives ( ) ! = nUserPrims0 & & scene1 - > numPrimitives ( ) ! = nUserPrims1 ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scenes must only contain user geometries with a single timestep " ) ;
# endif
scene0 - > intersectors . collide ( scene0 , scene1 , callback , userPtr ) ;
RTC_CATCH_END ( scene0 - > device ) ;
}
inline bool pointQuery ( Scene * scene , RTCPointQuery * query , RTCPointQueryContext * userContext , RTCPointQueryFunction queryFunc , void * userPtr )
{
bool changed = false ;
if ( userContext - > instStackSize > 0 )
{
const AffineSpace3fa transform = AffineSpace3fa_load_unaligned ( ( AffineSpace3fa * ) userContext - > world2inst [ userContext - > instStackSize - 1 ] ) ;
float similarityScale = 0.f ;
const bool similtude = similarityTransform ( transform , & similarityScale ) ;
assert ( ( similtude & & similarityScale > 0 ) | | ( ! similtude & & similarityScale = = 0.f ) ) ;
PointQuery query_inst ;
query_inst . p = xfmPoint ( transform , Vec3fa ( query - > x , query - > y , query - > z ) ) ;
query_inst . radius = query - > radius * similarityScale ;
query_inst . time = query - > time ;
PointQueryContext context_inst ( scene , ( PointQuery * ) query ,
similtude ? POINT_QUERY_TYPE_SPHERE : POINT_QUERY_TYPE_AABB ,
queryFunc , userContext , similarityScale , userPtr ) ;
changed = scene - > intersectors . pointQuery ( ( PointQuery * ) & query_inst , & context_inst ) ;
}
else
{
PointQueryContext context ( scene , ( PointQuery * ) query ,
POINT_QUERY_TYPE_SPHERE , queryFunc , userContext , 1.f , userPtr ) ;
changed = scene - > intersectors . pointQuery ( ( PointQuery * ) query , & context ) ;
}
return changed ;
}
RTC_API bool rtcPointQuery ( RTCScene hscene , RTCPointQuery * query , RTCPointQueryContext * userContext , RTCPointQueryFunction queryFunc , void * userPtr )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcPointQuery ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
RTC_VERIFY_HANDLE ( userContext ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene got not committed " ) ;
if ( ( ( size_t ) query ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " query not aligned to 16 bytes " ) ;
if ( ( ( size_t ) userContext ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " context not aligned to 16 bytes " ) ;
# endif
return pointQuery ( scene , query , userContext , queryFunc , userPtr ) ;
RTC_CATCH_END2_FALSE ( scene ) ;
}
RTC_API bool rtcPointQuery4 ( const int * valid , RTCScene hscene , RTCPointQuery4 * query , struct RTCPointQueryContext * userContext , RTCPointQueryFunction queryFunc , void * * userPtrN )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcPointQuery4 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene got not committed " ) ;
if ( ( ( size_t ) valid ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 16 bytes " ) ;
if ( ( ( size_t ) query ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " query not aligned to 16 bytes " ) ;
# endif
STAT ( size_t cnt = 0 ; for ( size_t i = 0 ; i < 4 ; i + + ) cnt + = ( ( int * ) valid ) [ i ] = = - 1 ; ) ;
STAT3 ( point_query . travs , cnt , cnt , cnt ) ;
bool changed = false ;
PointQuery4 * query4 = ( PointQuery4 * ) query ;
PointQuery query1 ;
for ( size_t i = 0 ; i < 4 ; i + + ) {
if ( ! valid [ i ] ) continue ;
query4 - > get ( i , query1 ) ;
changed | = pointQuery ( scene , ( RTCPointQuery * ) & query1 , userContext , queryFunc , userPtrN ? userPtrN [ i ] : NULL ) ;
query4 - > set ( i , query1 ) ;
}
return changed ;
RTC_CATCH_END2_FALSE ( scene ) ;
}
RTC_API bool rtcPointQuery8 ( const int * valid , RTCScene hscene , RTCPointQuery8 * query , struct RTCPointQueryContext * userContext , RTCPointQueryFunction queryFunc , void * * userPtrN )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcPointQuery8 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene got not committed " ) ;
if ( ( ( size_t ) valid ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 16 bytes " ) ;
if ( ( ( size_t ) query ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " query not aligned to 16 bytes " ) ;
# endif
STAT ( size_t cnt = 0 ; for ( size_t i = 0 ; i < 4 ; i + + ) cnt + = ( ( int * ) valid ) [ i ] = = - 1 ; ) ;
STAT3 ( point_query . travs , cnt , cnt , cnt ) ;
bool changed = false ;
PointQuery8 * query8 = ( PointQuery8 * ) query ;
PointQuery query1 ;
for ( size_t i = 0 ; i < 8 ; i + + ) {
if ( ! valid [ i ] ) continue ;
query8 - > get ( i , query1 ) ;
changed | = pointQuery ( scene , ( RTCPointQuery * ) & query1 , userContext , queryFunc , userPtrN ? userPtrN [ i ] : NULL ) ;
query8 - > set ( i , query1 ) ;
}
return changed ;
RTC_CATCH_END2_FALSE ( scene ) ;
}
RTC_API bool rtcPointQuery16 ( const int * valid , RTCScene hscene , RTCPointQuery16 * query , struct RTCPointQueryContext * userContext , RTCPointQueryFunction queryFunc , void * * userPtrN )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcPointQuery16 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene got not committed " ) ;
if ( ( ( size_t ) valid ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 16 bytes " ) ;
if ( ( ( size_t ) query ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " query not aligned to 16 bytes " ) ;
# endif
STAT ( size_t cnt = 0 ; for ( size_t i = 0 ; i < 4 ; i + + ) cnt + = ( ( int * ) valid ) [ i ] = = - 1 ; ) ;
STAT3 ( point_query . travs , cnt , cnt , cnt ) ;
bool changed = false ;
PointQuery16 * query16 = ( PointQuery16 * ) query ;
PointQuery query1 ;
for ( size_t i = 0 ; i < 16 ; i + + ) {
if ( ! valid [ i ] ) continue ;
PointQuery query1 ; query16 - > get ( i , query1 ) ;
changed | = pointQuery ( scene , ( RTCPointQuery * ) & query1 , userContext , queryFunc , userPtrN ? userPtrN [ i ] : NULL ) ;
query16 - > set ( i , query1 ) ;
}
return changed ;
RTC_CATCH_END2_FALSE ( scene ) ;
}
RTC_API void rtcIntersect1 ( RTCScene hscene , RTCIntersectContext * user_context , RTCRayHit * rayhit )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcIntersect1 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) rayhit ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 16 bytes " ) ;
# endif
STAT3 ( normal . travs , 1 , 1 , 1 ) ;
IntersectContext context ( scene , user_context ) ;
scene - > intersectors . intersect ( * rayhit , & context ) ;
# if defined(DEBUG)
( ( RayHit * ) rayhit ) - > verifyHit ( ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcIntersect4 ( const int * valid , RTCScene hscene , RTCIntersectContext * user_context , RTCRayHit4 * rayhit )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcIntersect4 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) valid ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 16 bytes " ) ;
if ( ( ( size_t ) rayhit ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit not aligned to 16 bytes " ) ;
# endif
STAT ( size_t cnt = 0 ; for ( size_t i = 0 ; i < 4 ; i + + ) cnt + = ( ( int * ) valid ) [ i ] = = - 1 ; ) ;
STAT3 ( normal . travs , cnt , cnt , cnt ) ;
IntersectContext context ( scene , user_context ) ;
# if !defined(EMBREE_RAY_PACKETS)
2022-11-24 14:45:59 +00:00
RayHit4 * ray4 = ( RayHit4 * ) rayhit ;
2020-12-19 13:50:20 +00:00
for ( size_t i = 0 ; i < 4 ; i + + ) {
if ( ! valid [ i ] ) continue ;
2021-05-20 10:49:33 +00:00
RayHit ray1 ; ray4 - > get ( i , ray1 ) ;
2020-12-19 13:50:20 +00:00
scene - > intersectors . intersect ( ( RTCRayHit & ) ray1 , & context ) ;
2021-05-20 10:49:33 +00:00
ray4 - > set ( i , ray1 ) ;
2020-12-19 13:50:20 +00:00
}
# else
scene - > intersectors . intersect4 ( valid , * rayhit , & context ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcIntersect8 ( const int * valid , RTCScene hscene , RTCIntersectContext * user_context , RTCRayHit8 * rayhit )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcIntersect8 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) valid ) & 0x1F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 32 bytes " ) ;
if ( ( ( size_t ) rayhit ) & 0x1F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit not aligned to 32 bytes " ) ;
# endif
STAT ( size_t cnt = 0 ; for ( size_t i = 0 ; i < 8 ; i + + ) cnt + = ( ( int * ) valid ) [ i ] = = - 1 ; ) ;
STAT3 ( normal . travs , cnt , cnt , cnt ) ;
IntersectContext context ( scene , user_context ) ;
# if !defined(EMBREE_RAY_PACKETS)
2022-11-24 14:45:59 +00:00
RayHit8 * ray8 = ( RayHit8 * ) rayhit ;
2020-12-19 13:50:20 +00:00
for ( size_t i = 0 ; i < 8 ; i + + ) {
if ( ! valid [ i ] ) continue ;
2021-05-20 10:49:33 +00:00
RayHit ray1 ; ray8 - > get ( i , ray1 ) ;
2020-12-19 13:50:20 +00:00
scene - > intersectors . intersect ( ( RTCRayHit & ) ray1 , & context ) ;
2021-05-20 10:49:33 +00:00
ray8 - > set ( i , ray1 ) ;
2020-12-19 13:50:20 +00:00
}
# else
if ( likely ( scene - > intersectors . intersector8 ) )
scene - > intersectors . intersect8 ( valid , * rayhit , & context ) ;
else
scene - > device - > rayStreamFilters . intersectSOA ( scene , ( char * ) rayhit , 8 , 1 , sizeof ( RTCRayHit8 ) , & context ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcIntersect16 ( const int * valid , RTCScene hscene , RTCIntersectContext * user_context , RTCRayHit16 * rayhit )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcIntersect16 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) valid ) & 0x3F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 64 bytes " ) ;
if ( ( ( size_t ) rayhit ) & 0x3F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit not aligned to 64 bytes " ) ;
# endif
STAT ( size_t cnt = 0 ; for ( size_t i = 0 ; i < 16 ; i + + ) cnt + = ( ( int * ) valid ) [ i ] = = - 1 ; ) ;
STAT3 ( normal . travs , cnt , cnt , cnt ) ;
IntersectContext context ( scene , user_context ) ;
# if !defined(EMBREE_RAY_PACKETS)
2022-11-24 14:45:59 +00:00
RayHit16 * ray16 = ( RayHit16 * ) rayhit ;
2020-12-19 13:50:20 +00:00
for ( size_t i = 0 ; i < 16 ; i + + ) {
if ( ! valid [ i ] ) continue ;
2021-05-20 10:49:33 +00:00
RayHit ray1 ; ray16 - > get ( i , ray1 ) ;
2020-12-19 13:50:20 +00:00
scene - > intersectors . intersect ( ( RTCRayHit & ) ray1 , & context ) ;
2021-05-20 10:49:33 +00:00
ray16 - > set ( i , ray1 ) ;
2020-12-19 13:50:20 +00:00
}
# else
if ( likely ( scene - > intersectors . intersector16 ) )
scene - > intersectors . intersect16 ( valid , * rayhit , & context ) ;
else
scene - > device - > rayStreamFilters . intersectSOA ( scene , ( char * ) rayhit , 16 , 1 , sizeof ( RTCRayHit16 ) , & context ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcIntersect1M ( RTCScene hscene , RTCIntersectContext * user_context , RTCRayHit * rayhit , unsigned int M , size_t byteStride )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcIntersect1M ) ;
# if defined (EMBREE_RAY_PACKETS)
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) rayhit ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 4 bytes " ) ;
# endif
STAT3 ( normal . travs , M , M , M ) ;
IntersectContext context ( scene , user_context ) ;
/* fast codepath for single rays */
if ( likely ( M = = 1 ) ) {
if ( likely ( rayhit - > ray . tnear < = rayhit - > ray . tfar ) )
scene - > intersectors . intersect ( * rayhit , & context ) ;
}
/* codepath for streams */
else {
scene - > device - > rayStreamFilters . intersectAOS ( scene , rayhit , M , byteStride , & context ) ;
}
# else
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " rtcIntersect1M not supported " ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcIntersect1Mp ( RTCScene hscene , RTCIntersectContext * user_context , RTCRayHit * * rn , unsigned int M )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcIntersect1Mp ) ;
# if defined (EMBREE_RAY_PACKETS)
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) rn ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 4 bytes " ) ;
# endif
STAT3 ( normal . travs , M , M , M ) ;
IntersectContext context ( scene , user_context ) ;
/* fast codepath for single rays */
if ( likely ( M = = 1 ) ) {
if ( likely ( rn [ 0 ] - > ray . tnear < = rn [ 0 ] - > ray . tfar ) )
scene - > intersectors . intersect ( * rn [ 0 ] , & context ) ;
}
/* codepath for streams */
else {
scene - > device - > rayStreamFilters . intersectAOP ( scene , rn , M , & context ) ;
}
# else
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " rtcIntersect1Mp not supported " ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcIntersectNM ( RTCScene hscene , RTCIntersectContext * user_context , struct RTCRayHitN * rayhit , unsigned int N , unsigned int M , size_t byteStride )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcIntersectNM ) ;
# if defined (EMBREE_RAY_PACKETS)
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) rayhit ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 4 bytes " ) ;
# endif
STAT3 ( normal . travs , N * M , N * M , N * M ) ;
IntersectContext context ( scene , user_context ) ;
/* code path for single ray streams */
if ( likely ( N = = 1 ) )
{
/* fast code path for streams of size 1 */
if ( likely ( M = = 1 ) ) {
if ( likely ( ( ( RTCRayHit * ) rayhit ) - > ray . tnear < = ( ( RTCRayHit * ) rayhit ) - > ray . tfar ) )
scene - > intersectors . intersect ( * ( RTCRayHit * ) rayhit , & context ) ;
}
/* normal codepath for single ray streams */
else {
scene - > device - > rayStreamFilters . intersectAOS ( scene , ( RTCRayHit * ) rayhit , M , byteStride , & context ) ;
}
}
/* code path for ray packet streams */
else {
scene - > device - > rayStreamFilters . intersectSOA ( scene , ( char * ) rayhit , N , M , byteStride , & context ) ;
}
# else
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " rtcIntersectNM not supported " ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcIntersectNp ( RTCScene hscene , RTCIntersectContext * user_context , const RTCRayHitNp * rayhit , unsigned int N )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcIntersectNp ) ;
# if defined (EMBREE_RAY_PACKETS)
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) rayhit - > ray . org_x ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.org_x not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > ray . org_y ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.org_y not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > ray . org_z ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.org_z not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > ray . dir_x ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.dir_x not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > ray . dir_y ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.dir_y not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > ray . dir_z ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.dir_z not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > ray . tnear ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.dir_x not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > ray . tfar ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.tnear not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > ray . time ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.time not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > ray . mask ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->ray.mask not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > hit . Ng_x ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->hit.Ng_x not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > hit . Ng_y ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->hit.Ng_y not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > hit . Ng_z ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->hit.Ng_z not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > hit . u ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->hit.u not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > hit . v ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->hit.v not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > hit . geomID ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->hit.geomID not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > hit . primID ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->hit.primID not aligned to 4 bytes " ) ;
if ( ( ( size_t ) rayhit - > hit . instID ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " rayhit->hit.instID not aligned to 4 bytes " ) ;
# endif
STAT3 ( normal . travs , N , N , N ) ;
IntersectContext context ( scene , user_context ) ;
scene - > device - > rayStreamFilters . intersectSOP ( scene , rayhit , N , & context ) ;
# else
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " rtcIntersectNp not supported " ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcOccluded1 ( RTCScene hscene , RTCIntersectContext * user_context , RTCRay * ray )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcOccluded1 ) ;
STAT3 ( shadow . travs , 1 , 1 , 1 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) ray ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 16 bytes " ) ;
# endif
IntersectContext context ( scene , user_context ) ;
scene - > intersectors . occluded ( * ray , & context ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcOccluded4 ( const int * valid , RTCScene hscene , RTCIntersectContext * user_context , RTCRay4 * ray )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcOccluded4 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) valid ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 16 bytes " ) ;
if ( ( ( size_t ) ray ) & 0x0F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 16 bytes " ) ;
# endif
STAT ( size_t cnt = 0 ; for ( size_t i = 0 ; i < 4 ; i + + ) cnt + = ( ( int * ) valid ) [ i ] = = - 1 ; ) ;
STAT3 ( shadow . travs , cnt , cnt , cnt ) ;
IntersectContext context ( scene , user_context ) ;
# if !defined(EMBREE_RAY_PACKETS)
2021-05-20 10:49:33 +00:00
RayHit4 * ray4 = ( RayHit4 * ) ray ;
2020-12-19 13:50:20 +00:00
for ( size_t i = 0 ; i < 4 ; i + + ) {
if ( ! valid [ i ] ) continue ;
2021-05-20 10:49:33 +00:00
RayHit ray1 ; ray4 - > get ( i , ray1 ) ;
2020-12-19 13:50:20 +00:00
scene - > intersectors . occluded ( ( RTCRay & ) ray1 , & context ) ;
2021-05-20 10:49:33 +00:00
ray4 - > geomID [ i ] = ray1 . geomID ;
2020-12-19 13:50:20 +00:00
}
# else
scene - > intersectors . occluded4 ( valid , * ray , & context ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcOccluded8 ( const int * valid , RTCScene hscene , RTCIntersectContext * user_context , RTCRay8 * ray )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcOccluded8 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) valid ) & 0x1F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 32 bytes " ) ;
if ( ( ( size_t ) ray ) & 0x1F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 32 bytes " ) ;
# endif
STAT ( size_t cnt = 0 ; for ( size_t i = 0 ; i < 8 ; i + + ) cnt + = ( ( int * ) valid ) [ i ] = = - 1 ; ) ;
STAT3 ( shadow . travs , cnt , cnt , cnt ) ;
IntersectContext context ( scene , user_context ) ;
# if !defined(EMBREE_RAY_PACKETS)
2021-05-20 10:49:33 +00:00
RayHit8 * ray8 = ( RayHit8 * ) ray ;
2020-12-19 13:50:20 +00:00
for ( size_t i = 0 ; i < 8 ; i + + ) {
if ( ! valid [ i ] ) continue ;
2021-05-20 10:49:33 +00:00
RayHit ray1 ; ray8 - > get ( i , ray1 ) ;
2020-12-19 13:50:20 +00:00
scene - > intersectors . occluded ( ( RTCRay & ) ray1 , & context ) ;
ray8 - > set ( i , ray1 ) ;
}
# else
if ( likely ( scene - > intersectors . intersector8 ) )
scene - > intersectors . occluded8 ( valid , * ray , & context ) ;
else
scene - > device - > rayStreamFilters . occludedSOA ( scene , ( char * ) ray , 8 , 1 , sizeof ( RTCRay8 ) , & context ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcOccluded16 ( const int * valid , RTCScene hscene , RTCIntersectContext * user_context , RTCRay16 * ray )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcOccluded16 ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) valid ) & 0x3F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 64 bytes " ) ;
if ( ( ( size_t ) ray ) & 0x3F ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 64 bytes " ) ;
# endif
STAT ( size_t cnt = 0 ; for ( size_t i = 0 ; i < 16 ; i + + ) cnt + = ( ( int * ) valid ) [ i ] = = - 1 ; ) ;
STAT3 ( shadow . travs , cnt , cnt , cnt ) ;
IntersectContext context ( scene , user_context ) ;
# if !defined(EMBREE_RAY_PACKETS)
2021-05-20 10:49:33 +00:00
RayHit16 * ray16 = ( RayHit16 * ) ray ;
2020-12-19 13:50:20 +00:00
for ( size_t i = 0 ; i < 16 ; i + + ) {
if ( ! valid [ i ] ) continue ;
2021-05-20 10:49:33 +00:00
RayHit ray1 ; ray16 - > get ( i , ray1 ) ;
2020-12-19 13:50:20 +00:00
scene - > intersectors . occluded ( ( RTCRay & ) ray1 , & context ) ;
ray16 - > set ( i , ray1 ) ;
}
# else
if ( likely ( scene - > intersectors . intersector16 ) )
scene - > intersectors . occluded16 ( valid , * ray , & context ) ;
else
scene - > device - > rayStreamFilters . occludedSOA ( scene , ( char * ) ray , 16 , 1 , sizeof ( RTCRay16 ) , & context ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcOccluded1M ( RTCScene hscene , RTCIntersectContext * user_context , RTCRay * ray , unsigned int M , size_t byteStride )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcOccluded1M ) ;
# if defined (EMBREE_RAY_PACKETS)
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) ray ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 4 bytes " ) ;
# endif
STAT3 ( shadow . travs , M , M , M ) ;
IntersectContext context ( scene , user_context ) ;
/* fast codepath for streams of size 1 */
if ( likely ( M = = 1 ) ) {
if ( likely ( ray - > tnear < = ray - > tfar ) )
scene - > intersectors . occluded ( * ray , & context ) ;
}
/* codepath for normal streams */
else {
scene - > device - > rayStreamFilters . occludedAOS ( scene , ray , M , byteStride , & context ) ;
}
# else
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " rtcOccluded1M not supported " ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcOccluded1Mp ( RTCScene hscene , RTCIntersectContext * user_context , RTCRay * * ray , unsigned int M )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcOccluded1Mp ) ;
# if defined (EMBREE_RAY_PACKETS)
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) ray ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 4 bytes " ) ;
# endif
STAT3 ( shadow . travs , M , M , M ) ;
IntersectContext context ( scene , user_context ) ;
/* fast codepath for streams of size 1 */
if ( likely ( M = = 1 ) ) {
if ( likely ( ray [ 0 ] - > tnear < = ray [ 0 ] - > tfar ) )
scene - > intersectors . occluded ( * ray [ 0 ] , & context ) ;
}
/* codepath for normal streams */
else {
scene - > device - > rayStreamFilters . occludedAOP ( scene , ray , M , & context ) ;
}
# else
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " rtcOccluded1Mp not supported " ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcOccludedNM ( RTCScene hscene , RTCIntersectContext * user_context , RTCRayN * ray , unsigned int N , unsigned int M , size_t byteStride )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcOccludedNM ) ;
# if defined (EMBREE_RAY_PACKETS)
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( byteStride < sizeof ( RTCRayHit ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " byteStride too small " ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) ray ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " ray not aligned to 4 bytes " ) ;
# endif
STAT3 ( shadow . travs , N * M , N * N , N * N ) ;
IntersectContext context ( scene , user_context ) ;
/* codepath for single rays */
if ( likely ( N = = 1 ) )
{
/* fast path for streams of size 1 */
if ( likely ( M = = 1 ) ) {
if ( likely ( ( ( RTCRay * ) ray ) - > tnear < = ( ( RTCRay * ) ray ) - > tfar ) )
scene - > intersectors . occluded ( * ( RTCRay * ) ray , & context ) ;
}
/* codepath for normal ray streams */
else {
scene - > device - > rayStreamFilters . occludedAOS ( scene , ( RTCRay * ) ray , M , byteStride , & context ) ;
}
}
/* code path for ray packet streams */
else {
scene - > device - > rayStreamFilters . occludedSOA ( scene , ( char * ) ray , N , M , byteStride , & context ) ;
}
# else
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " rtcOccludedNM not supported " ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcOccludedNp ( RTCScene hscene , RTCIntersectContext * user_context , const RTCRayNp * ray , unsigned int N )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcOccludedNp ) ;
# if defined (EMBREE_RAY_PACKETS)
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
if ( scene - > isModified ( ) ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " scene not committed " ) ;
if ( ( ( size_t ) ray - > org_x ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " org_x not aligned to 4 bytes " ) ;
if ( ( ( size_t ) ray - > org_y ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " org_y not aligned to 4 bytes " ) ;
if ( ( ( size_t ) ray - > org_z ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " org_z not aligned to 4 bytes " ) ;
if ( ( ( size_t ) ray - > dir_x ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " dir_x not aligned to 4 bytes " ) ;
if ( ( ( size_t ) ray - > dir_y ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " dir_y not aligned to 4 bytes " ) ;
if ( ( ( size_t ) ray - > dir_z ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " dir_z not aligned to 4 bytes " ) ;
if ( ( ( size_t ) ray - > tnear ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " dir_x not aligned to 4 bytes " ) ;
if ( ( ( size_t ) ray - > tfar ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " tnear not aligned to 4 bytes " ) ;
if ( ( ( size_t ) ray - > time ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " time not aligned to 4 bytes " ) ;
if ( ( ( size_t ) ray - > mask ) & 0x03 ) throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " mask not aligned to 4 bytes " ) ;
# endif
STAT3 ( shadow . travs , N , N , N ) ;
IntersectContext context ( scene , user_context ) ;
scene - > device - > rayStreamFilters . occludedSOP ( scene , ray , N , & context ) ;
# else
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " rtcOccludedNp not supported " ) ;
# endif
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcRetainScene ( RTCScene hscene )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcRetainScene ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
scene - > refInc ( ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcReleaseScene ( RTCScene hscene )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcReleaseScene ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
scene - > refDec ( ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcSetGeometryInstancedScene ( RTCGeometry hgeometry , RTCScene hscene )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
Ref < Scene > scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryInstancedScene ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
geometry - > setInstancedScene ( scene ) ;
RTC_CATCH_END2 ( geometry ) ;
}
AffineSpace3fa loadTransform ( RTCFormat format , const float * xfm )
{
AffineSpace3fa space = one ;
switch ( format )
{
case RTC_FORMAT_FLOAT3X4_ROW_MAJOR :
space = AffineSpace3fa ( Vec3fa ( xfm [ 0 ] , xfm [ 4 ] , xfm [ 8 ] ) ,
Vec3fa ( xfm [ 1 ] , xfm [ 5 ] , xfm [ 9 ] ) ,
Vec3fa ( xfm [ 2 ] , xfm [ 6 ] , xfm [ 10 ] ) ,
Vec3fa ( xfm [ 3 ] , xfm [ 7 ] , xfm [ 11 ] ) ) ;
break ;
case RTC_FORMAT_FLOAT3X4_COLUMN_MAJOR :
space = AffineSpace3fa ( Vec3fa ( xfm [ 0 ] , xfm [ 1 ] , xfm [ 2 ] ) ,
Vec3fa ( xfm [ 3 ] , xfm [ 4 ] , xfm [ 5 ] ) ,
Vec3fa ( xfm [ 6 ] , xfm [ 7 ] , xfm [ 8 ] ) ,
Vec3fa ( xfm [ 9 ] , xfm [ 10 ] , xfm [ 11 ] ) ) ;
break ;
case RTC_FORMAT_FLOAT4X4_COLUMN_MAJOR :
space = AffineSpace3fa ( Vec3fa ( xfm [ 0 ] , xfm [ 1 ] , xfm [ 2 ] ) ,
Vec3fa ( xfm [ 4 ] , xfm [ 5 ] , xfm [ 6 ] ) ,
Vec3fa ( xfm [ 8 ] , xfm [ 9 ] , xfm [ 10 ] ) ,
Vec3fa ( xfm [ 12 ] , xfm [ 13 ] , xfm [ 14 ] ) ) ;
break ;
default :
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " invalid matrix format " ) ;
break ;
}
return space ;
}
void storeTransform ( const AffineSpace3fa & space , RTCFormat format , float * xfm )
{
switch ( format )
{
case RTC_FORMAT_FLOAT3X4_ROW_MAJOR :
xfm [ 0 ] = space . l . vx . x ; xfm [ 1 ] = space . l . vy . x ; xfm [ 2 ] = space . l . vz . x ; xfm [ 3 ] = space . p . x ;
xfm [ 4 ] = space . l . vx . y ; xfm [ 5 ] = space . l . vy . y ; xfm [ 6 ] = space . l . vz . y ; xfm [ 7 ] = space . p . y ;
xfm [ 8 ] = space . l . vx . z ; xfm [ 9 ] = space . l . vy . z ; xfm [ 10 ] = space . l . vz . z ; xfm [ 11 ] = space . p . z ;
break ;
case RTC_FORMAT_FLOAT3X4_COLUMN_MAJOR :
xfm [ 0 ] = space . l . vx . x ; xfm [ 1 ] = space . l . vx . y ; xfm [ 2 ] = space . l . vx . z ;
xfm [ 3 ] = space . l . vy . x ; xfm [ 4 ] = space . l . vy . y ; xfm [ 5 ] = space . l . vy . z ;
xfm [ 6 ] = space . l . vz . x ; xfm [ 7 ] = space . l . vz . y ; xfm [ 8 ] = space . l . vz . z ;
xfm [ 9 ] = space . p . x ; xfm [ 10 ] = space . p . y ; xfm [ 11 ] = space . p . z ;
break ;
case RTC_FORMAT_FLOAT4X4_COLUMN_MAJOR :
xfm [ 0 ] = space . l . vx . x ; xfm [ 1 ] = space . l . vx . y ; xfm [ 2 ] = space . l . vx . z ; xfm [ 3 ] = 0.f ;
xfm [ 4 ] = space . l . vy . x ; xfm [ 5 ] = space . l . vy . y ; xfm [ 6 ] = space . l . vy . z ; xfm [ 7 ] = 0.f ;
xfm [ 8 ] = space . l . vz . x ; xfm [ 9 ] = space . l . vz . y ; xfm [ 10 ] = space . l . vz . z ; xfm [ 11 ] = 0.f ;
xfm [ 12 ] = space . p . x ; xfm [ 13 ] = space . p . y ; xfm [ 14 ] = space . p . z ; xfm [ 15 ] = 1.f ;
break ;
default :
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " invalid matrix format " ) ;
break ;
}
}
RTC_API void rtcSetGeometryTransform ( RTCGeometry hgeometry , unsigned int timeStep , RTCFormat format , const void * xfm )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryTransform ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
RTC_VERIFY_HANDLE ( xfm ) ;
const AffineSpace3fa transform = loadTransform ( format , ( const float * ) xfm ) ;
geometry - > setTransform ( transform , timeStep ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryTransformQuaternion ( RTCGeometry hgeometry , unsigned int timeStep , const RTCQuaternionDecomposition * qd )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryTransformQuaternion ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
RTC_VERIFY_HANDLE ( qd ) ;
AffineSpace3fx transform ;
transform . l . vx . x = qd - > scale_x ;
transform . l . vy . y = qd - > scale_y ;
transform . l . vz . z = qd - > scale_z ;
transform . l . vy . x = qd - > skew_xy ;
transform . l . vz . x = qd - > skew_xz ;
transform . l . vz . y = qd - > skew_yz ;
transform . l . vx . y = qd - > translation_x ;
transform . l . vx . z = qd - > translation_y ;
transform . l . vy . z = qd - > translation_z ;
transform . p . x = qd - > shift_x ;
transform . p . y = qd - > shift_y ;
transform . p . z = qd - > shift_z ;
// normalize quaternion
Quaternion3f q ( qd - > quaternion_r , qd - > quaternion_i , qd - > quaternion_j , qd - > quaternion_k ) ;
q = normalize ( q ) ;
transform . l . vx . w = q . i ;
transform . l . vy . w = q . j ;
transform . l . vz . w = q . k ;
transform . p . w = q . r ;
geometry - > setQuaternionDecomposition ( transform , timeStep ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcGetGeometryTransform ( RTCGeometry hgeometry , float time , RTCFormat format , void * xfm )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometryTransform ) ;
const AffineSpace3fa transform = geometry - > getTransform ( time ) ;
storeTransform ( transform , format , ( float * ) xfm ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcFilterIntersection ( const struct RTCIntersectFunctionNArguments * const args_i , const struct RTCFilterFunctionNArguments * filter_args )
{
IntersectFunctionNArguments * args = ( IntersectFunctionNArguments * ) args_i ;
2022-11-24 14:45:59 +00:00
isa : : reportIntersection1 ( args , filter_args ) ;
2020-12-19 13:50:20 +00:00
}
RTC_API void rtcFilterOcclusion ( const struct RTCOccludedFunctionNArguments * const args_i , const struct RTCFilterFunctionNArguments * filter_args )
{
OccludedFunctionNArguments * args = ( OccludedFunctionNArguments * ) args_i ;
2022-11-24 14:45:59 +00:00
isa : : reportOcclusion1 ( args , filter_args ) ;
2020-12-19 13:50:20 +00:00
}
RTC_API RTCGeometry rtcNewGeometry ( RTCDevice hdevice , RTCGeometryType type )
{
Device * device = ( Device * ) hdevice ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcNewGeometry ) ;
RTC_VERIFY_HANDLE ( hdevice ) ;
switch ( type )
{
case RTC_GEOMETRY_TYPE_TRIANGLE :
{
# if defined(EMBREE_GEOMETRY_TRIANGLE)
createTriangleMeshTy createTriangleMesh = nullptr ;
2021-05-20 10:49:33 +00:00
SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512 ( device - > enabled_cpu_features , createTriangleMesh ) ;
2020-12-19 13:50:20 +00:00
Geometry * geom = createTriangleMesh ( device ) ;
return ( RTCGeometry ) geom - > refInc ( ) ;
# else
throw_RTCError ( RTC_ERROR_UNKNOWN , " RTC_GEOMETRY_TYPE_TRIANGLE is not supported " ) ;
# endif
}
case RTC_GEOMETRY_TYPE_QUAD :
{
# if defined(EMBREE_GEOMETRY_QUAD)
createQuadMeshTy createQuadMesh = nullptr ;
2021-05-20 10:49:33 +00:00
SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512 ( device - > enabled_cpu_features , createQuadMesh ) ;
2020-12-19 13:50:20 +00:00
Geometry * geom = createQuadMesh ( device ) ;
return ( RTCGeometry ) geom - > refInc ( ) ;
# else
throw_RTCError ( RTC_ERROR_UNKNOWN , " RTC_GEOMETRY_TYPE_QUAD is not supported " ) ;
# endif
}
case RTC_GEOMETRY_TYPE_SPHERE_POINT :
case RTC_GEOMETRY_TYPE_DISC_POINT :
case RTC_GEOMETRY_TYPE_ORIENTED_DISC_POINT :
{
# if defined(EMBREE_GEOMETRY_POINT)
createPointsTy createPoints = nullptr ;
2021-05-20 10:49:33 +00:00
SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512 ( device - > enabled_builder_cpu_features , createPoints ) ;
2020-12-19 13:50:20 +00:00
Geometry * geom ;
switch ( type ) {
case RTC_GEOMETRY_TYPE_SPHERE_POINT :
geom = createPoints ( device , Geometry : : GTY_SPHERE_POINT ) ;
break ;
case RTC_GEOMETRY_TYPE_DISC_POINT :
geom = createPoints ( device , Geometry : : GTY_DISC_POINT ) ;
break ;
case RTC_GEOMETRY_TYPE_ORIENTED_DISC_POINT :
geom = createPoints ( device , Geometry : : GTY_ORIENTED_DISC_POINT ) ;
break ;
default :
geom = nullptr ;
break ;
}
return ( RTCGeometry ) geom - > refInc ( ) ;
# else
throw_RTCError ( RTC_ERROR_UNKNOWN , " RTC_GEOMETRY_TYPE_POINT is not supported " ) ;
# endif
}
case RTC_GEOMETRY_TYPE_CONE_LINEAR_CURVE :
case RTC_GEOMETRY_TYPE_ROUND_LINEAR_CURVE :
case RTC_GEOMETRY_TYPE_FLAT_LINEAR_CURVE :
case RTC_GEOMETRY_TYPE_ROUND_BEZIER_CURVE :
case RTC_GEOMETRY_TYPE_FLAT_BEZIER_CURVE :
case RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_BEZIER_CURVE :
case RTC_GEOMETRY_TYPE_ROUND_BSPLINE_CURVE :
case RTC_GEOMETRY_TYPE_FLAT_BSPLINE_CURVE :
case RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_BSPLINE_CURVE :
case RTC_GEOMETRY_TYPE_ROUND_HERMITE_CURVE :
case RTC_GEOMETRY_TYPE_FLAT_HERMITE_CURVE :
case RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_HERMITE_CURVE :
case RTC_GEOMETRY_TYPE_ROUND_CATMULL_ROM_CURVE :
case RTC_GEOMETRY_TYPE_FLAT_CATMULL_ROM_CURVE :
case RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_CATMULL_ROM_CURVE :
{
# if defined(EMBREE_GEOMETRY_CURVE)
createLineSegmentsTy createLineSegments = nullptr ;
2021-05-20 10:49:33 +00:00
SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512 ( device - > enabled_cpu_features , createLineSegments ) ;
2020-12-19 13:50:20 +00:00
createCurvesTy createCurves = nullptr ;
2021-05-20 10:49:33 +00:00
SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512 ( device - > enabled_cpu_features , createCurves ) ;
2020-12-19 13:50:20 +00:00
Geometry * geom ;
switch ( type ) {
case RTC_GEOMETRY_TYPE_CONE_LINEAR_CURVE : geom = createLineSegments ( device , Geometry : : GTY_CONE_LINEAR_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_ROUND_LINEAR_CURVE : geom = createLineSegments ( device , Geometry : : GTY_ROUND_LINEAR_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_FLAT_LINEAR_CURVE : geom = createLineSegments ( device , Geometry : : GTY_FLAT_LINEAR_CURVE ) ; break ;
//case RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_LINEAR_CURVE : geom = createLineSegments (device,Geometry::GTY_ORIENTED_LINEAR_CURVE); break;
case RTC_GEOMETRY_TYPE_ROUND_BEZIER_CURVE : geom = createCurves ( device , Geometry : : GTY_ROUND_BEZIER_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_FLAT_BEZIER_CURVE : geom = createCurves ( device , Geometry : : GTY_FLAT_BEZIER_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_BEZIER_CURVE : geom = createCurves ( device , Geometry : : GTY_ORIENTED_BEZIER_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_ROUND_BSPLINE_CURVE : geom = createCurves ( device , Geometry : : GTY_ROUND_BSPLINE_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_FLAT_BSPLINE_CURVE : geom = createCurves ( device , Geometry : : GTY_FLAT_BSPLINE_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_BSPLINE_CURVE : geom = createCurves ( device , Geometry : : GTY_ORIENTED_BSPLINE_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_ROUND_HERMITE_CURVE : geom = createCurves ( device , Geometry : : GTY_ROUND_HERMITE_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_FLAT_HERMITE_CURVE : geom = createCurves ( device , Geometry : : GTY_FLAT_HERMITE_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_HERMITE_CURVE : geom = createCurves ( device , Geometry : : GTY_ORIENTED_HERMITE_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_ROUND_CATMULL_ROM_CURVE : geom = createCurves ( device , Geometry : : GTY_ROUND_CATMULL_ROM_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_FLAT_CATMULL_ROM_CURVE : geom = createCurves ( device , Geometry : : GTY_FLAT_CATMULL_ROM_CURVE ) ; break ;
case RTC_GEOMETRY_TYPE_NORMAL_ORIENTED_CATMULL_ROM_CURVE : geom = createCurves ( device , Geometry : : GTY_ORIENTED_CATMULL_ROM_CURVE ) ; break ;
default : geom = nullptr ; break ;
}
return ( RTCGeometry ) geom - > refInc ( ) ;
# else
throw_RTCError ( RTC_ERROR_UNKNOWN , " RTC_GEOMETRY_TYPE_CURVE is not supported " ) ;
# endif
}
case RTC_GEOMETRY_TYPE_SUBDIVISION :
{
# if defined(EMBREE_GEOMETRY_SUBDIVISION)
createSubdivMeshTy createSubdivMesh = nullptr ;
SELECT_SYMBOL_DEFAULT_AVX ( device - > enabled_cpu_features , createSubdivMesh ) ;
2021-05-20 10:49:33 +00:00
//SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_cpu_features,createSubdivMesh); // FIXME: this does not work for some reason?
2020-12-19 13:50:20 +00:00
Geometry * geom = createSubdivMesh ( device ) ;
return ( RTCGeometry ) geom - > refInc ( ) ;
# else
throw_RTCError ( RTC_ERROR_UNKNOWN , " RTC_GEOMETRY_TYPE_SUBDIVISION is not supported " ) ;
# endif
}
case RTC_GEOMETRY_TYPE_USER :
{
# if defined(EMBREE_GEOMETRY_USER)
createUserGeometryTy createUserGeometry = nullptr ;
2021-05-20 10:49:33 +00:00
SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512 ( device - > enabled_cpu_features , createUserGeometry ) ;
2020-12-19 13:50:20 +00:00
Geometry * geom = createUserGeometry ( device ) ;
return ( RTCGeometry ) geom - > refInc ( ) ;
# else
throw_RTCError ( RTC_ERROR_UNKNOWN , " RTC_GEOMETRY_TYPE_USER is not supported " ) ;
# endif
}
case RTC_GEOMETRY_TYPE_INSTANCE :
{
# if defined(EMBREE_GEOMETRY_INSTANCE)
createInstanceTy createInstance = nullptr ;
2021-05-20 10:49:33 +00:00
SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512 ( device - > enabled_cpu_features , createInstance ) ;
2020-12-19 13:50:20 +00:00
Geometry * geom = createInstance ( device ) ;
return ( RTCGeometry ) geom - > refInc ( ) ;
# else
throw_RTCError ( RTC_ERROR_UNKNOWN , " RTC_GEOMETRY_TYPE_INSTANCE is not supported " ) ;
# endif
}
case RTC_GEOMETRY_TYPE_GRID :
{
# if defined(EMBREE_GEOMETRY_GRID)
createGridMeshTy createGridMesh = nullptr ;
2021-05-20 10:49:33 +00:00
SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512 ( device - > enabled_cpu_features , createGridMesh ) ;
2020-12-19 13:50:20 +00:00
Geometry * geom = createGridMesh ( device ) ;
return ( RTCGeometry ) geom - > refInc ( ) ;
# else
throw_RTCError ( RTC_ERROR_UNKNOWN , " RTC_GEOMETRY_TYPE_GRID is not supported " ) ;
# endif
}
default :
throw_RTCError ( RTC_ERROR_UNKNOWN , " invalid geometry type " ) ;
}
RTC_CATCH_END ( device ) ;
return nullptr ;
}
RTC_API void rtcSetGeometryUserPrimitiveCount ( RTCGeometry hgeometry , unsigned int userPrimitiveCount )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryUserPrimitiveCount ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
if ( unlikely ( geometry - > getType ( ) ! = Geometry : : GTY_USER_GEOMETRY ) )
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " operation only allowed for user geometries " ) ;
geometry - > setNumPrimitives ( userPrimitiveCount ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryTimeStepCount ( RTCGeometry hgeometry , unsigned int timeStepCount )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryTimeStepCount ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
if ( timeStepCount > RTC_MAX_TIME_STEP_COUNT )
throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " number of time steps is out of range " ) ;
geometry - > setNumTimeSteps ( timeStepCount ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryTimeRange ( RTCGeometry hgeometry , float startTime , float endTime )
{
Ref < Geometry > geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryTimeRange ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
if ( startTime > endTime )
throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " startTime has to be smaller or equal to the endTime " ) ;
geometry - > setTimeRange ( BBox1f ( startTime , endTime ) ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryVertexAttributeCount ( RTCGeometry hgeometry , unsigned int N )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryVertexAttributeCount ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setVertexAttributeCount ( N ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryTopologyCount ( RTCGeometry hgeometry , unsigned int N )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryTopologyCount ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setTopologyCount ( N ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryBuildQuality ( RTCGeometry hgeometry , RTCBuildQuality quality )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryBuildQuality ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
if ( quality ! = RTC_BUILD_QUALITY_LOW & &
quality ! = RTC_BUILD_QUALITY_MEDIUM & &
quality ! = RTC_BUILD_QUALITY_HIGH & &
quality ! = RTC_BUILD_QUALITY_REFIT )
2021-05-04 09:07:12 +00:00
// -- GODOT start --
// throw std::runtime_error("invalid build quality");
abort ( ) ;
// -- GODOT end --
2020-12-19 13:50:20 +00:00
geometry - > setBuildQuality ( quality ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryMaxRadiusScale ( RTCGeometry hgeometry , float maxRadiusScale )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryMaxRadiusScale ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
# if RTC_MIN_WIDTH
if ( maxRadiusScale < 1.0f ) throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " maximal radius scale has to be larger or equal to 1 " ) ;
geometry - > setMaxRadiusScale ( maxRadiusScale ) ;
# else
throw_RTCError ( RTC_ERROR_INVALID_OPERATION , " min-width feature is not enabled " ) ;
# endif
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryMask ( RTCGeometry hgeometry , unsigned int mask )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryMask ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setMask ( mask ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometrySubdivisionMode ( RTCGeometry hgeometry , unsigned topologyID , RTCSubdivisionMode mode )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometrySubdivisionMode ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setSubdivisionMode ( topologyID , mode ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryVertexAttributeTopology ( RTCGeometry hgeometry , unsigned int vertexAttributeID , unsigned int topologyID )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryVertexAttributeTopology ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setVertexAttributeTopology ( vertexAttributeID , topologyID ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryBuffer ( RTCGeometry hgeometry , RTCBufferType type , unsigned int slot , RTCFormat format , RTCBuffer hbuffer , size_t byteOffset , size_t byteStride , size_t itemCount )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
Ref < Buffer > buffer = ( Buffer * ) hbuffer ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryBuffer ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
RTC_VERIFY_HANDLE ( hbuffer ) ;
if ( geometry - > device ! = buffer - > device )
throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " inputs are from different devices " ) ;
if ( itemCount > 0xFFFFFFFFu )
throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " buffer too large " ) ;
geometry - > setBuffer ( type , slot , format , buffer , byteOffset , byteStride , ( unsigned int ) itemCount ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetSharedGeometryBuffer ( RTCGeometry hgeometry , RTCBufferType type , unsigned int slot , RTCFormat format , const void * ptr , size_t byteOffset , size_t byteStride , size_t itemCount )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetSharedGeometryBuffer ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
if ( itemCount > 0xFFFFFFFFu )
throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " buffer too large " ) ;
Ref < Buffer > buffer = new Buffer ( geometry - > device , itemCount * byteStride , ( char * ) ptr + byteOffset ) ;
geometry - > setBuffer ( type , slot , format , buffer , 0 , byteStride , ( unsigned int ) itemCount ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void * rtcSetNewGeometryBuffer ( RTCGeometry hgeometry , RTCBufferType type , unsigned int slot , RTCFormat format , size_t byteStride , size_t itemCount )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetNewGeometryBuffer ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
if ( itemCount > 0xFFFFFFFFu )
throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " buffer too large " ) ;
/* vertex buffers need to get overallocated slightly as elements are accessed using SSE loads */
size_t bytes = itemCount * byteStride ;
if ( type = = RTC_BUFFER_TYPE_VERTEX | | type = = RTC_BUFFER_TYPE_VERTEX_ATTRIBUTE )
bytes + = ( 16 - ( byteStride % 16 ) ) % 16 ;
Ref < Buffer > buffer = new Buffer ( geometry - > device , bytes ) ;
geometry - > setBuffer ( type , slot , format , buffer , 0 , byteStride , ( unsigned int ) itemCount ) ;
return buffer - > data ( ) ;
RTC_CATCH_END2 ( geometry ) ;
return nullptr ;
}
RTC_API void * rtcGetGeometryBufferData ( RTCGeometry hgeometry , RTCBufferType type , unsigned int slot )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometryBufferData ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
return geometry - > getBuffer ( type , slot ) ;
RTC_CATCH_END2 ( geometry ) ;
return nullptr ;
}
RTC_API void rtcEnableGeometry ( RTCGeometry hgeometry )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcEnableGeometry ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > enable ( ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcUpdateGeometryBuffer ( RTCGeometry hgeometry , RTCBufferType type , unsigned int slot )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcUpdateGeometryBuffer ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > updateBuffer ( type , slot ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcDisableGeometry ( RTCGeometry hgeometry )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcDisableGeometry ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > disable ( ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryTessellationRate ( RTCGeometry hgeometry , float tessellationRate )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryTessellationRate ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setTessellationRate ( tessellationRate ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryUserData ( RTCGeometry hgeometry , void * ptr )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryUserData ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setUserData ( ptr ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void * rtcGetGeometryUserData ( RTCGeometry hgeometry )
{
Geometry * geometry = ( Geometry * ) hgeometry ; // no ref counting here!
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometryUserData ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
return geometry - > getUserData ( ) ;
RTC_CATCH_END2 ( geometry ) ;
return nullptr ;
}
RTC_API void rtcSetGeometryBoundsFunction ( RTCGeometry hgeometry , RTCBoundsFunction bounds , void * userPtr )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryBoundsFunction ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setBoundsFunction ( bounds , userPtr ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryDisplacementFunction ( RTCGeometry hgeometry , RTCDisplacementFunctionN displacement )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryDisplacementFunction ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setDisplacementFunction ( displacement ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryIntersectFunction ( RTCGeometry hgeometry , RTCIntersectFunctionN intersect )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryIntersectFunction ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setIntersectFunctionN ( intersect ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryPointQueryFunction ( RTCGeometry hgeometry , RTCPointQueryFunction pointQuery )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryPointQueryFunction ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setPointQueryFunction ( pointQuery ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API unsigned int rtcGetGeometryFirstHalfEdge ( RTCGeometry hgeometry , unsigned int faceID )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometryFirstHalfEdge ) ;
return geometry - > getFirstHalfEdge ( faceID ) ;
RTC_CATCH_END2 ( geometry ) ;
return - 1 ;
}
RTC_API unsigned int rtcGetGeometryFace ( RTCGeometry hgeometry , unsigned int edgeID )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometryFace ) ;
return geometry - > getFace ( edgeID ) ;
RTC_CATCH_END2 ( geometry ) ;
return - 1 ;
}
RTC_API unsigned int rtcGetGeometryNextHalfEdge ( RTCGeometry hgeometry , unsigned int edgeID )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometryNextHalfEdge ) ;
return geometry - > getNextHalfEdge ( edgeID ) ;
RTC_CATCH_END2 ( geometry ) ;
return - 1 ;
}
RTC_API unsigned int rtcGetGeometryPreviousHalfEdge ( RTCGeometry hgeometry , unsigned int edgeID )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometryPreviousHalfEdge ) ;
return geometry - > getPreviousHalfEdge ( edgeID ) ;
RTC_CATCH_END2 ( geometry ) ;
return - 1 ;
}
RTC_API unsigned int rtcGetGeometryOppositeHalfEdge ( RTCGeometry hgeometry , unsigned int topologyID , unsigned int edgeID )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometryOppositeHalfEdge ) ;
return geometry - > getOppositeHalfEdge ( topologyID , edgeID ) ;
RTC_CATCH_END2 ( geometry ) ;
return - 1 ;
}
RTC_API void rtcSetGeometryOccludedFunction ( RTCGeometry hgeometry , RTCOccludedFunctionN occluded )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetOccludedFunctionN ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setOccludedFunctionN ( occluded ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryIntersectFilterFunction ( RTCGeometry hgeometry , RTCFilterFunctionN filter )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryIntersectFilterFunction ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setIntersectionFilterFunctionN ( filter ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcSetGeometryOccludedFilterFunction ( RTCGeometry hgeometry , RTCFilterFunctionN filter )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcSetGeometryOccludedFilterFunction ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > setOcclusionFilterFunctionN ( filter ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcInterpolate ( const RTCInterpolateArguments * const args )
{
Geometry * geometry = ( Geometry * ) args - > geometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcInterpolate ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( args - > geometry ) ;
# endif
geometry - > interpolate ( args ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcInterpolateN ( const RTCInterpolateNArguments * const args )
{
Geometry * geometry = ( Geometry * ) args - > geometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcInterpolateN ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( args - > geometry ) ;
# endif
geometry - > interpolateN ( args ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcCommitGeometry ( RTCGeometry hgeometry )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcCommitGeometry ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
return geometry - > commit ( ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API unsigned int rtcAttachGeometry ( RTCScene hscene , RTCGeometry hgeometry )
{
Scene * scene = ( Scene * ) hscene ;
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcAttachGeometry ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
if ( scene - > device ! = geometry - > device )
throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " inputs are from different devices " ) ;
return scene - > bind ( RTC_INVALID_GEOMETRY_ID , geometry ) ;
RTC_CATCH_END2 ( scene ) ;
return - 1 ;
}
RTC_API void rtcAttachGeometryByID ( RTCScene hscene , RTCGeometry hgeometry , unsigned int geomID )
{
Scene * scene = ( Scene * ) hscene ;
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcAttachGeometryByID ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
RTC_VERIFY_GEOMID ( geomID ) ;
if ( scene - > device ! = geometry - > device )
throw_RTCError ( RTC_ERROR_INVALID_ARGUMENT , " inputs are from different devices " ) ;
scene - > bind ( geomID , geometry ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcDetachGeometry ( RTCScene hscene , unsigned int geomID )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcDetachGeometry ) ;
RTC_VERIFY_HANDLE ( hscene ) ;
RTC_VERIFY_GEOMID ( geomID ) ;
scene - > detachGeometry ( geomID ) ;
RTC_CATCH_END2 ( scene ) ;
}
RTC_API void rtcRetainGeometry ( RTCGeometry hgeometry )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcRetainGeometry ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > refInc ( ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API void rtcReleaseGeometry ( RTCGeometry hgeometry )
{
Geometry * geometry = ( Geometry * ) hgeometry ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcReleaseGeometry ) ;
RTC_VERIFY_HANDLE ( hgeometry ) ;
geometry - > refDec ( ) ;
RTC_CATCH_END2 ( geometry ) ;
}
RTC_API RTCGeometry rtcGetGeometry ( RTCScene hscene , unsigned int geomID )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometry ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
RTC_VERIFY_GEOMID ( geomID ) ;
# endif
return ( RTCGeometry ) scene - > get ( geomID ) ;
RTC_CATCH_END2 ( scene ) ;
return nullptr ;
}
2022-11-24 14:45:59 +00:00
RTC_API RTCGeometry rtcGetGeometryThreadSafe ( RTCScene hscene , unsigned int geomID )
{
Scene * scene = ( Scene * ) hscene ;
RTC_CATCH_BEGIN ;
RTC_TRACE ( rtcGetGeometryThreadSafe ) ;
# if defined(DEBUG)
RTC_VERIFY_HANDLE ( hscene ) ;
RTC_VERIFY_GEOMID ( geomID ) ;
# endif
Ref < Geometry > geom = scene - > get_locked ( geomID ) ;
return ( RTCGeometry ) geom . ptr ;
RTC_CATCH_END2 ( scene ) ;
return nullptr ;
}
2020-12-19 13:50:20 +00:00
RTC_NAMESPACE_END