text: // Copyright 2009-2021 Intel Corporation
  // SPDX-License-Identifier: Apache-2.0
  
  #define RTC_EXPORT_API
  
  #include "default.h"
  #include "device.h"
  #include "scene.h"
  #include "context.h"
  #include "../../include/embree3/rtcore_ray.h"
  using namespace embree;
  
  RTC_NAMESPACE_BEGIN;
  
    /* mutex to make API thread safe */
    static MutexSys g_mutex;
  
    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)
        throw std::runtime_error("invalid build quality");
      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)
      RayHit4* ray4 = (RayHit4*) rayhit;
      for (size_t i=0; i<4; i++) {
        if (!valid[i]) continue;
        RayHit ray1; ray4->get(i,ray1);
        scene->intersectors.intersect((RTCRayHit&)ray1,&context);
        ray4->set(i,ray1);
      }
  #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)
      RayHit8* ray8 = (RayHit8*) rayhit;
      for (size_t i=0; i<8; i++) {
        if (!valid[i]) continue;
        RayHit ray1; ray8->get(i,ray1);
        scene->intersectors.intersect((RTCRayHit&)ray1,&context);
        ray8->set(i,ray1);
      }
  #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)
      RayHit16* ray16 = (RayHit16*) rayhit;
      for (size_t i=0; i<16; i++) {
        if (!valid[i]) continue;
        RayHit ray1; ray16->get(i,ray1);
        scene->intersectors.intersect((RTCRayHit&)ray1,&context);
        ray16->set(i,ray1);
      }
  #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)
      RayHit4* ray4 = (RayHit4*) ray;
      for (size_t i=0; i<4; i++) {
        if (!valid[i]) continue;
        RayHit ray1; ray4->get(i,ray1);
        scene->intersectors.occluded((RTCRay&)ray1,&context);
        ray4->geomID[i] = ray1.geomID; 
      }
  #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)
      RayHit8* ray8 = (RayHit8*) ray;
      for (size_t i=0; i<8; i++) {
        if (!valid[i]) continue;
        RayHit ray1; ray8->get(i,ray1);
        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)
      RayHit16* ray16 = (RayHit16*) ray;
      for (size_t i=0; i<16; i++) {
        if (!valid[i]) continue;
        RayHit ray1; ray16->get(i,ray1);
        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;
      args->report(args,filter_args);
    }
  
    RTC_API void rtcFilterOcclusion(const struct RTCOccludedFunctionNArguments* const args_i, const struct RTCFilterFunctionNArguments* filter_args)
    {
      OccludedFunctionNArguments* args = (OccludedFunctionNArguments*) args_i;
      args->report(args,filter_args);
    }
    
    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;
        SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_cpu_features,createTriangleMesh);
        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;
        SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_cpu_features,createQuadMesh);
        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;
        SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_builder_cpu_features, createPoints);
  
        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;
        SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_cpu_features,createLineSegments);
        createCurvesTy createCurves = nullptr;
        SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_cpu_features,createCurves);
        
        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);
        //SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_cpu_features,createSubdivMesh); // FIXME: this does not work for some reason?
        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;
        SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_cpu_features,createUserGeometry);
        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;
        SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_cpu_features,createInstance);
        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;
        SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(device->enabled_cpu_features,createGridMesh);
        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)
        throw std::runtime_error("invalid build quality");
      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;
    }
  
    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;
    }
  
  RTC_NAMESPACE_END
  