Example #1
0
  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);
  }
Example #2
0
 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);
 }
Example #3
0
 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);
 }
Example #4
0
 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);
 }
Example #5
0
 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);
 }
Example #6
0
 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);
 }
Example #7
0
 RTCORE_API void rtcDeleteDevice(RTCDevice device) 
 {
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcDeleteDevice);
   RTCORE_VERIFY_HANDLE(device);
   Lock<MutexSys> lock(g_mutex);
   delete (Device*) device;
   RTCORE_CATCH_END_NOREPORT;
 }
Example #8
0
 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);
 }
Example #9
0
 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);
 }
Example #10
0
 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);
 }
Example #11
0
 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);
 }
Example #12
0
 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);
 }
Example #13
0
 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;
 }
Example #14
0
 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;
 }
Example #15
0
 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);
 }
Example #16
0
 extern "C" void ispcSetUserData (RTCScene hscene, unsigned geomID, void* ptr) 
 {
   Scene* scene = (Scene*) hscene;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetUserData);
   RTCORE_VERIFY_HANDLE(scene);
   RTCORE_VERIFY_GEOMID(geomID);
   scene->get_locked(geomID)->setUserData(ptr);
   RTCORE_CATCH_END(scene->device);
 }
Example #17
0
 extern "C" void ispcSetDisplacementFunction (RTCScene hscene, unsigned int geomID, void* func, RTCBounds* bounds)
 {
   Scene* scene = (Scene*) hscene;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetDisplacementFunction);
   RTCORE_VERIFY_HANDLE(scene);
   RTCORE_VERIFY_GEOMID(geomID);
   ((Scene*)scene)->get_locked(geomID)->setDisplacementFunction((RTCDisplacementFunc)func,bounds);
   RTCORE_CATCH_END(scene->device);
 }
Example #18
0
 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);
 }
Example #19
0
 extern "C" void* ispcGetUserData (RTCScene hscene, unsigned geomID)
 {
   Scene* scene = (Scene*) hscene;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcSetUserData);
   RTCORE_VERIFY_HANDLE(scene);
   RTCORE_VERIFY_GEOMID(geomID);
   return scene->get(geomID)->getUserData(); // this call is on purpose not thread safe
   RTCORE_CATCH_END(scene->device);
   return nullptr;
 }
Example #20
0
 RTCORE_API RTCError rtcGetError()
 {
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcGetError);
   if (g_device == nullptr) return RTC_UNKNOWN_ERROR;
   RTCError* stored_error = g_device->error();
   RTCError error = *stored_error;
   *stored_error = RTC_NO_ERROR;
   return error;
   RTCORE_CATCH_END(g_device);
   return RTC_UNKNOWN_ERROR;
 }
Example #21
0
 RTCORE_API RTCError rtcDeviceGetError(RTCDevice hdevice)
 {
   Device* device = (Device*) hdevice;
   RTCORE_CATCH_BEGIN;
   RTCORE_TRACE(rtcDeviceGetError);
   RTCORE_VERIFY_HANDLE(hdevice);
   RTCError* stored_error = device->error();
   RTCError error = *stored_error;
   *stored_error = RTC_NO_ERROR;
   return error;
   RTCORE_CATCH_END(device);
   return RTC_UNKNOWN_ERROR;
 }
Example #22
0
  RTCORE_API void rtcIntersect4 (const void* valid, RTCScene hscene, RTCRay4& ray) 
  {
    Scene* scene = (Scene*) hscene;
    RTCORE_CATCH_BEGIN;
    RTCORE_TRACE(rtcIntersect4);
#if !defined(__TARGET_SIMD4__)
    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersect4 not supported");    
#else
#if defined(DEBUG)
    RTCORE_VERIFY_HANDLE(hscene);
    if (scene->isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
    if (((size_t)valid) & 0x0F       ) throw_RTCError(RTC_INVALID_ARGUMENT, "mask not aligned to 16 bytes");   
    if (((size_t)&ray ) & 0x0F       ) throw_RTCError(RTC_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;);
Example #23
0
  RTCORE_API void rtcCommit (RTCScene hscene) 
  {
    Scene* scene = (Scene*) hscene;
    RTCORE_CATCH_BEGIN;
    RTCORE_TRACE(rtcCommit);
    RTCORE_VERIFY_HANDLE(hscene);

#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
    RayStreamLogger::rayStreamLogger.dumpGeometry(scene);
#endif

    /* perform scene build */
    scene->build(0,0);
    
    RTCORE_CATCH_END(scene->device);
  }
Example #24
0
  RTCORE_API void rtcDebug() 
  {
    RTCORE_CATCH_BEGIN;
    RTCORE_TRACE(rtcDebug);

#if defined(RTCORE_STAT_COUNTERS)
    Stat::print(std::cout);
    Stat::clear();
#endif

#if defined(DEBUG) && 1
    extern void printTessCacheStats();
    printTessCacheStats();
#endif
    RTCORE_CATCH_END(g_device);
  }
Example #25
0
  RTCORE_API void rtcIntersect (RTCScene hscene, RTCRay& ray) 
  {
    Scene* scene = (Scene*) hscene;
    RTCORE_CATCH_BEGIN;
    RTCORE_TRACE(rtcIntersect);
#if defined(DEBUG)
    RTCORE_VERIFY_HANDLE(hscene);
    if (scene->isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
    if (((size_t)&ray) & 0x0F        ) throw_RTCError(RTC_INVALID_ARGUMENT, "ray not aligned to 16 bytes");   
#endif

#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
    RTCRay old_ray = ray;
#endif

    STAT3(normal.travs,1,1,1);
    scene->intersect(ray);

#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
    RayStreamLogger::rayStreamLogger.logRay1Intersect(scene,old_ray,ray);
#endif
    RTCORE_CATCH_END(scene->device);
  }