C++ RTCORE_CATCH_END函数代码示例

  RTCORE_API void rtcCommitThread(RTCScene hscene, unsigned int threadID, unsigned int numThreads) 
  {
    Scene* scene = (Scene*) hscene;
    RTCORE_CATCH_BEGIN;
    RTCORE_TRACE(rtcCommitThread);
    RTCORE_VERIFY_HANDLE(hscene);

    if (unlikely(numThreads == 0)) 
      throw_RTCError(RTC_INVALID_OPERATION,"invalid number of threads specified");

#if defined(__MIC__)
    if (unlikely(numThreads % 4 != 0 && numThreads != 1)) 
      throw_RTCError(RTC_INVALID_OPERATION,"MIC requires numThreads % 4 == 0 in rtcCommitThread");
#endif
    
    /* for best performance set FTZ and DAZ flags in the MXCSR control and status register */
#if !defined(__MIC__)
    unsigned int mxcsr = _mm_getcsr();
    _mm_setcsr(mxcsr | /* FTZ */ (1<<15) | /* DAZ */ (1<<6));
#endif
    
     /* perform scene build */
    scene->build(threadID,numThreads);

 /* reset MXCSR register again */
#if !defined(__MIC__)
    _mm_setcsr(mxcsr);
#endif

    RTCORE_CATCH_END(scene->device);
  }

 RTCORE_API void rtcSetParameter1i(const RTCParameter parm, ssize_t val)
 {
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetParameter1i);
   Lock<MutexSys> lock(g_mutex);
   if (g_device) g_device->setParameter1i(parm,val);
   RTCORE_CATCH_END(g_device);
 }

 RTCORE_API void rtcSetErrorFunction(RTCErrorFunc func) 
 {
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetErrorFunction);
   assert(g_device);
   if (g_device) g_device->error_function = func;
   RTCORE_CATCH_END(g_device);
 }

 RTCORE_API void rtcDeviceSetMemoryMonitorFunction(RTCDevice hdevice, RTCMemoryMonitorFunc func) 
 {
   Device* device = (Device*) hdevice;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcDeviceSetMemoryMonitorFunction);
   device->memory_monitor_function = func;
   RTCORE_CATCH_END(device);
 }

 RTCORE_API void rtcSetMemoryMonitorFunction(RTCMemoryMonitorFunc func) 
 {
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetMemoryMonitorFunction);
   assert(g_device);
   if (g_device) g_device->memory_monitor_function = func;
   RTCORE_CATCH_END(g_device);
 }

 RTCORE_API void rtcExit() 
 {
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcExit);
   Lock<MutexSys> lock(g_mutex);
   if (!g_device) throw_RTCError(RTC_INVALID_OPERATION,"rtcInit has to get called before rtcExit");
   delete g_device; g_device = nullptr;
   RTCORE_CATCH_END(g_device);
 }

 RTCORE_API void rtcInit(const char* cfg) 
 {
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcInit);
   Lock<MutexSys> lock(g_mutex);
   if (g_device) throw_RTCError(RTC_INVALID_OPERATION,"already initialized");
   g_device = new Device(cfg,true);
   RTCORE_CATCH_END(g_device);
 }

 RTCORE_API void rtcSetProgressMonitorFunction(RTCScene hscene, RTCProgressMonitorFunc func, void* ptr) 
 {
   Scene* scene = (Scene*) hscene;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetProgressMonitorFunction);
   RTCORE_VERIFY_HANDLE(hscene);
   scene->setProgressMonitorFunction(func,ptr);
   RTCORE_CATCH_END(scene->device);
 }

 RTCORE_API void rtcDeviceSetErrorFunction(RTCDevice hdevice, RTCErrorFunc func) 
 {
   Device* device = (Device*) hdevice;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcDeviceSetErrorFunction);
   RTCORE_VERIFY_HANDLE(hdevice);
   device->error_function = func;
   RTCORE_CATCH_END(device);
 }

 extern "C" void ispcSetIntersectFunction16 (RTCScene hscene, unsigned geomID, RTCIntersectFunc16 intersect) 
 {
   Scene* scene = (Scene*) hscene;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetIntersectFunction16);
   RTCORE_VERIFY_HANDLE(scene);
   RTCORE_VERIFY_GEOMID(geomID);
   ((Scene*)scene)->get_locked(geomID)->setIntersectFunction16(intersect,true);
   RTCORE_CATCH_END(scene->device);
 }

 RTCORE_API RTCScene rtcDeviceNewScene (RTCDevice device, RTCSceneFlags flags, RTCAlgorithmFlags aflags) 
 {
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcDeviceNewScene);
   RTCORE_VERIFY_HANDLE(device);
   if (!isCoherent(flags) && !isIncoherent(flags)) flags = RTCSceneFlags(flags | RTC_SCENE_INCOHERENT);
   return (RTCScene) new Scene((Device*)device,flags,aflags);
   RTCORE_CATCH_END((Device*)device);
   return nullptr;
 }

 RTCORE_API RTCScene rtcNewScene (RTCSceneFlags flags, RTCAlgorithmFlags aflags) 
 {
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcNewScene);
   assert(g_device);
   if (!isCoherent(flags) && !isIncoherent(flags)) flags = RTCSceneFlags(flags | RTC_SCENE_INCOHERENT);
   return (RTCScene) new Scene(g_device,flags,aflags);
   RTCORE_CATCH_END(g_device);
   return nullptr;
 }

 extern "C" void ispcSetOcclusionFilterFunction16 (RTCScene hscene, unsigned geomID, RTCFilterFunc16 filter) 
 {
   Scene* scene = (Scene*) hscene;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetOcclusionFilterFunction16);
   RTCORE_VERIFY_HANDLE(scene);
   RTCORE_VERIFY_GEOMID(geomID);
   ((Scene*)scene)->get_locked(geomID)->setOcclusionFilterFunction16(filter,true);
   RTCORE_CATCH_END(scene->device);
 }

 RTCORE_API void rtcDeviceSetParameter1i(RTCDevice hdevice, const RTCParameter parm, ssize_t val)
 {
   Device* device = (Device*) hdevice;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcDeviceSetParameter1i);
   RTCORE_VERIFY_HANDLE(hdevice);
   Lock<MutexSys> lock(g_mutex);
   device->setParameter1i(parm,val);
   RTCORE_CATCH_END(device);
 }

 extern "C" void ispcSetOccludedFunction8 (RTCScene hscene, unsigned geomID, RTCOccludedFunc8 occluded) 
 {
   Scene* scene = (Scene*) hscene;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetOccludedFunction8);
   RTCORE_VERIFY_HANDLE(scene);
   RTCORE_VERIFY_GEOMID(geomID);
   ((Scene*)scene)->get_locked(geomID)->setOccludedFunction8(occluded,true);
   RTCORE_CATCH_END(scene->device);
 }