merged in devel

common/cmake/check_globals.cmake

@@ -23,7 +23,8 @@ string(REPLACE "\n" ";" output ${output})
 
 foreach (line ${output})
   if ("${line}" MATCHES "O .bss")
-    if (NOT "${line}" MATCHES "std::__ioinit")
+    if (NOT "${line}" MATCHES "std::__ioinit" AND    # this is caused by iostream initialization and is likely also ok
+        NOT "${line}" MATCHES "\\(\\)::")            # this matches a static inside a function which is fine
       message(WARNING "\nProblematic global variable in non-SSE code:\n" ${line})
     endif()
   endif()

common/sys/library.cpp

@@ -33,8 +33,7 @@ namespace embree
   lib_t openLibrary(const std::string& file)
   {
     std::string fullName = file+".dll";
-    FileName executable = getExecutableFileName();
-    HANDLE handle = LoadLibrary((executable.path() + fullName).c_str());
+    HANDLE handle = LoadLibrary(fullName.c_str());
     return lib_t(handle);
   }
 
@@ -69,15 +68,12 @@ namespace embree
     std::string fullName = "lib"+file+".so";
 #endif
     void* lib = dlopen(fullName.c_str(), RTLD_NOW);
-    if (lib) return lib_t(lib);
-    FileName executable = getExecutableFileName();
-    lib = dlopen((executable.path() + fullName).c_str(),RTLD_NOW);
     if (lib == nullptr) {
       const char* error = dlerror();
       if (error) { 
         THROW_RUNTIME_ERROR(error);
       } else {
-        THROW_RUNTIME_ERROR("could not load library "+executable.str());
+        THROW_RUNTIME_ERROR("could not load library "+fullName);
       }
     }
     return lib_t(lib);

kernels/CMakeLists.txt

@@ -23,21 +23,41 @@ SOURCE_GROUP("Source Files\\tasking" "/tasking/" )
 SOURCE_GROUP("Source Files\\algorithms" "/algorithms/")
 SOURCE_GROUP("" FILES embree.rc)
 
-SET(EMBREE_LIBRARY_FILES
- 
+SET(EMBREE_LIBRARY_FILES 
   embree.rc
-
-  common/device.cpp
+# common/rtcore_main.cpp
+  common/state.cpp
+  common/rtcore_main2.cpp
+  common/rtcore_builder.cpp
+  common/tasksys.cpp
   common/stat.cpp
+#  common/alloc.cpp
+  subdiv/bezier_curve.cpp
+  subdiv/bspline_curve.cpp
+)
+
+IF (EMBREE_RAY_PACKETS)
+  SET(EMBREE_LIBRARY_FILES ${EMBREE_LIBRARY_FILES}
+  common/rtcore_ispc.cpp
+  common/rtcore_ispc.ispc)
+ENDIF()
+
+IF (EMBREE_GEOMETRY_SUBDIV)
+  SET(EMBREE_LIBRARY_FILES ${EMBREE_LIBRARY_FILES}
+    subdiv/catmullclark_coefficients.cpp
+    subdiv/tessellation_cache.cpp
+)
+ENDIF()
+
+SET(EMBREE_LIBRARY_FILES_CORE
+ 
+  common/device.cpp
   common/acceln.cpp
   common/accelset.cpp
-  common/state.cpp
   common/rtcore.cpp
-  common/rtcore_builder.cpp
   common/scene.cpp
   common/alloc.cpp
   common/geometry.cpp
-  common/tasksys.cpp
   common/scene_user_geometry.cpp
   common/scene_instance.cpp
   common/scene_geometry_instance.cpp
@@ -46,12 +66,8 @@ SET(EMBREE_LIBRARY_FILES
   common/scene_bezier_curves.cpp
   common/scene_line_segments.cpp
 
-  subdiv/bezier_curve.cpp
-  subdiv/bspline_curve.cpp
-
   geometry/primitive.cpp
   geometry/instance_intersector1.cpp
-  geometry/instance_intersector.cpp
   builders/primrefgen.cpp
 
   bvh/bvh.cpp
@@ -69,188 +85,41 @@ SET(EMBREE_LIBRARY_FILES
   bvh/bvh_builder_instancing.cpp
 
   bvh/bvh_intersector1_bvh4.cpp
-  )
+  bvh/bvh_intersector1_bvh8.cpp
+)
 
 IF (EMBREE_GEOMETRY_SUBDIV)
-  SET(EMBREE_LIBRARY_FILES ${EMBREE_LIBRARY_FILES}
+  SET(EMBREE_LIBRARY_FILES_CORE ${EMBREE_LIBRARY_FILES_CORE}
   common/scene_subdiv_mesh.cpp
-  subdiv/tessellation_cache.cpp
+  common/scene_subdiv_mesh_avx.cpp
   subdiv/subdivpatch1base.cpp
-  subdiv/catmullclark_coefficients.cpp
   geometry/grid_soa.cpp	
   subdiv/subdivpatch1base_eval.cpp
   bvh/bvh_builder_subdiv.cpp)
 ENDIF()
 
 IF (EMBREE_RAY_PACKETS)
-  SET(EMBREE_LIBRARY_FILES ${EMBREE_LIBRARY_FILES}
-
-  common/rtcore_ispc.cpp
-  common/rtcore_ispc.ispc
+  SET(EMBREE_LIBRARY_FILES_CORE ${EMBREE_LIBRARY_FILES_CORE}
 
+  geometry/instance_intersector.cpp
   bvh/bvh_intersector_single.cpp
   bvh/bvh_intersector_hybrid4_bvh4.cpp
+  bvh/bvh_intersector_hybrid8_bvh4.cpp
+  bvh/bvh_intersector_hybrid16_bvh4.cpp
+  bvh/bvh_intersector_hybrid4_bvh8.cpp
+  bvh/bvh_intersector_hybrid8_bvh8.cpp
+  bvh/bvh_intersector_hybrid16_bvh8.cpp
   bvh/bvh_intersector_stream_bvh4.cpp
+  bvh/bvh_intersector_stream_bvh8.cpp
   bvh/bvh_intersector_stream_filters.cpp)
 ENDIF()
 
-SET(EMBREE_LIBRARY_FILES_SSE42
-    bvh/bvh_intersector1_bvh4.cpp)
-
-IF (EMBREE_GEOMETRY_SUBDIV)
-  SET(EMBREE_LIBRARY_FILES_SSE42 ${EMBREE_LIBRARY_FILES_SSE42}
-    geometry/grid_soa.cpp
-    subdiv/subdivpatch1base_eval.cpp)
-ENDIF()
-
-IF (EMBREE_RAY_PACKETS)
-    SET(EMBREE_LIBRARY_FILES_SSE42 ${EMBREE_LIBRARY_FILES_SSE42}
-    bvh/bvh_intersector_single.cpp
-    bvh/bvh_intersector_hybrid4_bvh4.cpp
-    bvh/bvh_intersector_stream_bvh4.cpp
-    bvh/bvh_intersector_stream_filters.cpp)
-ENDIF()
-
-SET(EMBREE_LIBRARY_FILES_AVX
-   
-    geometry/instance_intersector1.cpp
-    builders/primrefgen.cpp
-
-    bvh/bvh_rotate.cpp
-    bvh/bvh_refit.cpp
-    bvh/bvh_builder.cpp
-    bvh/bvh_builder_hair.cpp
-    bvh/bvh_builder_morton.cpp
-    bvh/bvh_builder_sah.cpp
-    bvh/bvh_builder_twolevel.cpp
-    bvh/bvh_builder_instancing.cpp
-    bvh/bvh_intersector1_bvh4.cpp
-    bvh/bvh_intersector1_bvh8.cpp
-    
-    bvh/bvh.cpp
-    bvh/bvh_statistics.cpp)
-
-IF (EMBREE_GEOMETRY_SUBDIV)
-  SET(EMBREE_LIBRARY_FILES_AVX ${EMBREE_LIBRARY_FILES_AVX}
-  geometry/grid_soa.cpp
-  subdiv/subdivpatch1base_eval.cpp
-  common/scene_subdiv_mesh_avx.cpp
-  bvh/bvh_builder_subdiv.cpp)
-ENDIF()
-
-IF (EMBREE_RAY_PACKETS)
-  SET(EMBREE_LIBRARY_FILES_AVX ${EMBREE_LIBRARY_FILES_AVX}
-
-    geometry/instance_intersector.cpp
-
-    bvh/bvh_intersector_single.cpp
-    bvh/bvh_intersector_hybrid4_bvh4.cpp
-    bvh/bvh_intersector_hybrid8_bvh4.cpp
-    bvh/bvh_intersector_hybrid4_bvh8.cpp
-    bvh/bvh_intersector_hybrid8_bvh8.cpp
-    bvh/bvh_intersector_stream_bvh4.cpp
-    bvh/bvh_intersector_stream_bvh8.cpp
-    bvh/bvh_intersector_stream_filters.cpp)
-ENDIF()
-
-SET(EMBREE_LIBRARY_FILES_AVX2
-
-    geometry/instance_intersector1.cpp
-    builders/primrefgen.cpp
-    bvh/bvh_builder_morton.cpp
-    bvh/bvh_rotate.cpp
-    bvh/bvh_intersector1_bvh4.cpp
-    bvh/bvh_intersector1_bvh8.cpp)
-
-IF (EMBREE_GEOMETRY_SUBDIV)
-  SET(EMBREE_LIBRARY_FILES_AVX2 ${EMBREE_LIBRARY_FILES_AVX2}
-  geometry/grid_soa.cpp
-  subdiv/subdivpatch1base_eval.cpp)
-ENDIF()
-
-IF (EMBREE_RAY_PACKETS)
-  SET(EMBREE_LIBRARY_FILES_AVX2 ${EMBREE_LIBRARY_FILES_AVX2}
-    geometry/instance_intersector.cpp
-
-    bvh/bvh_intersector_single.cpp
-    bvh/bvh_intersector_hybrid4_bvh4.cpp
-    bvh/bvh_intersector_hybrid8_bvh4.cpp
-    bvh/bvh_intersector_hybrid4_bvh8.cpp
-    bvh/bvh_intersector_hybrid8_bvh8.cpp
-    bvh/bvh_intersector_stream_bvh4.cpp
-    bvh/bvh_intersector_stream_bvh8.cpp
-    bvh/bvh_intersector_stream_filters.cpp)
-ENDIF()
-
-SET(EMBREE_LIBRARY_FILES_AVX512KNL
-
-    geometry/instance_intersector1.cpp
-
-    bvh/bvh_refit.cpp
-    bvh/bvh_rotate.cpp
-    bvh/bvh_intersector1_bvh4.cpp
-    bvh/bvh_intersector1_bvh8.cpp
-
-    builders/primrefgen.cpp
-    bvh/bvh_builder.cpp
-    bvh/bvh_builder_sah.cpp
-    bvh/bvh_builder_twolevel.cpp
-    bvh/bvh_builder_instancing.cpp
-    bvh/bvh_builder_morton.cpp)
-
-IF (EMBREE_GEOMETRY_SUBDIV)
-  SET(EMBREE_LIBRARY_FILES_AVX512KNL ${EMBREE_LIBRARY_FILES_AVX512KNL}
-  geometry/grid_soa.cpp    
-  subdiv/subdivpatch1base_eval.cpp
-  bvh/bvh_builder_subdiv.cpp)
-ENDIF()
-
-IF (EMBREE_RAY_PACKETS)
-  SET(EMBREE_LIBRARY_FILES_AVX512KNL ${EMBREE_LIBRARY_FILES_AVX512KNL}
-
-    geometry/instance_intersector.cpp
-
-    bvh/bvh_intersector_single.cpp
-    bvh/bvh_intersector_hybrid4_bvh4.cpp
-    bvh/bvh_intersector_hybrid8_bvh4.cpp
-    bvh/bvh_intersector_hybrid16_bvh4.cpp
-    bvh/bvh_intersector_hybrid4_bvh8.cpp
-    bvh/bvh_intersector_hybrid8_bvh8.cpp
-    bvh/bvh_intersector_hybrid16_bvh8.cpp
-    bvh/bvh_intersector_stream_bvh4.cpp
-    bvh/bvh_intersector_stream_bvh8.cpp
-    bvh/bvh_intersector_stream_filters.cpp)
-ENDIF()
-
-SET(EMBREE_LIBRARY_FILES_AVX512SKX
-
-    geometry/instance_intersector1.cpp
-
-    bvh/bvh_intersector1_bvh4.cpp
-    bvh/bvh_intersector1_bvh8.cpp)
-
-IF (EMBREE_GEOMETRY_SUBDIV)
-  SET(EMBREE_LIBRARY_FILES_AVX512SKX ${EMBREE_LIBRARY_FILES_AVX512SKX}
-  geometry/grid_soa.cpp
-  subdiv/subdivpatch1base_eval.cpp)
-ENDIF()
-
-IF (EMBREE_RAY_PACKETS)
-  SET(EMBREE_LIBRARY_FILES_AVX512SKX ${EMBREE_LIBRARY_FILES_AVX512SKX}
-
-    geometry/instance_intersector.cpp
-
-    bvh/bvh_intersector_single.cpp
-    bvh/bvh_intersector_hybrid4_bvh4.cpp
-    bvh/bvh_intersector_hybrid8_bvh4.cpp
-    bvh/bvh_intersector_hybrid16_bvh4.cpp
-    bvh/bvh_intersector_hybrid4_bvh8.cpp
-    bvh/bvh_intersector_hybrid8_bvh8.cpp
-    bvh/bvh_intersector_hybrid16_bvh8.cpp
-    bvh/bvh_intersector_stream_bvh4.cpp
-    bvh/bvh_intersector_stream_bvh8.cpp
-    bvh/bvh_intersector_stream_filters.cpp)
-ENDIF()
+SET(EMBREE_LIBRARY_FILES_SSE2 ${EMBREE_LIBRARY_FILES_CORE})
+SET(EMBREE_LIBRARY_FILES_SSE42 ${EMBREE_LIBRARY_FILES_CORE})
+SET(EMBREE_LIBRARY_FILES_AVX ${EMBREE_LIBRARY_FILES_CORE})
+SET(EMBREE_LIBRARY_FILES_AVX2 ${EMBREE_LIBRARY_FILES_CORE})
+SET(EMBREE_LIBRARY_FILES_AVX512KNL ${EMBREE_LIBRARY_FILES_CORE})
+SET(EMBREE_LIBRARY_FILES_AVX512SKX ${EMBREE_LIBRARY_FILES_CORE})
 
 # replaces all .cpp files with a dummy file that includes that .cpp file
 # this is to work around an ICC name mangling issue related to lambda functions under windows
@@ -268,6 +137,7 @@ MACRO (CreateISADummyFiles list isa)
       DEPENDS ${src_file})
   ENDFOREACH()
 ENDMACRO()
+CreateISADummyFiles(EMBREE_LIBRARY_FILES_SSE2      sse2      ${EMBREE_LIBRARY_FILES_SSE2})
 CreateISADummyFiles(EMBREE_LIBRARY_FILES_SSE42     sse42     ${EMBREE_LIBRARY_FILES_SSE42})
 CreateISADummyFiles(EMBREE_LIBRARY_FILES_AVX       avx       ${EMBREE_LIBRARY_FILES_AVX})
 CreateISADummyFiles(EMBREE_LIBRARY_FILES_AVX2      avx2      ${EMBREE_LIBRARY_FILES_AVX2})
@@ -278,6 +148,15 @@ ADD_ISPC_LIBRARY(embree ${EMBREE_LIB_TYPE} ${EMBREE_LIBRARY_FILES} $<TARGET_OBJE
 SET_TARGET_PROPERTIES(embree PROPERTIES COMPILE_FLAGS "${FLAGS_LOWEST}")
 SET_PROPERTY(TARGET embree PROPERTY FOLDER kernels)
 ADD_CUSTOM_TARGET(embree_check_stack_frame_size COMMAND ${CMAKE_COMMAND} -D file=$<TARGET_FILE:embree> -P ${PROJECT_SOURCE_DIR}/common/cmake/check_stack_frame_size.cmake DEPENDS embree)
+SET(EMBREE_LIBRARIES)
+
+IF (EMBREE_ISA_SSE2 AND EMBREE_LIBRARY_FILES_SSE2)
+  ADD_LIBRARY(embree_sse2 STATIC ${EMBREE_LIBRARY_FILES_SSE2})
+  SET_TARGET_PROPERTIES(embree_sse2 PROPERTIES COMPILE_FLAGS "${FLAGS_SSE2}")
+  SET_PROPERTY(TARGET embree_sse2 PROPERTY FOLDER kernels)
+  SET(EMBREE_LIBRARIES ${EMBREE_LIBRARIES} embree_sse2)
+  ADD_CUSTOM_TARGET(embree_sse2_check_globals ALL COMMAND ${CMAKE_COMMAND} -D file=$<TARGET_FILE:embree_sse2> -P ${PROJECT_SOURCE_DIR}/common/cmake/check_globals.cmake DEPENDS embree_sse2)
+ENDIF ()
 
 IF (EMBREE_ISA_SSE42 AND EMBREE_LIBRARY_FILES_SSE42)
   ADD_LIBRARY(embree_sse42 STATIC ${EMBREE_LIBRARY_FILES_SSE42})
@@ -331,7 +210,6 @@ ELSE()
   SET_SOURCE_FILES_PROPERTIES(common/rtcore.cpp PROPERTIES OBJECT_DEPENDS ${PROJECT_SOURCE_DIR}/kernels/export.linux.map)
 ENDIF()
 
-
 IF (EMBREE_ZIP_MODE)
   SET_TARGET_PROPERTIES(embree PROPERTIES VERSION ${EMBREE_VERSION_MAJOR} SOVERSION ${EMBREE_VERSION_MAJOR})
 ELSE()

kernels/bvh/bvh.cpp

@@ -18,6 +18,8 @@
 #include "bvh_statistics.h"
 
 namespace embree
+{
+namespace isa
 {
   template<int N>
   BVHN<N>::BVHN (const PrimitiveType& primTy, Scene* scene)
@@ -187,8 +189,9 @@ namespace embree
   template class BVHN<8>;
 #endif
 
-#if !defined(__AVX__) || !defined(__TARGET_SSE2__) && !defined(__TARGET_SSE42__)
+#if defined(__SSE2__)
   template class BVHN<4>;
 #endif
 }
+}
 

kernels/bvh/bvh.h

@@ -25,6 +25,8 @@
 #include "../common/ray.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! flags used to enable specific node types in intersectors */
   enum BVHNodeFlags
@@ -1335,3 +1337,4 @@ namespace embree
   typedef BVHN<4> BVH4;
   typedef BVHN<8> BVH8;
 }
+}

kernels/bvh/bvh4_factory.cpp

@@ -33,6 +33,8 @@
 #include "../common/accelinstance.h"
 
 namespace embree
+{
+namespace isa
 {
   DECLARE_SYMBOL2(Accel::Intersector1,BVH4Line4iIntersector1);
   DECLARE_SYMBOL2(Accel::Intersector1,BVH4Line4iMBIntersector1);
@@ -978,7 +980,7 @@ namespace embree
   void BVH4Factory::createLineSegmentsLine4i(LineSegments* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Line4i::type,mesh->parent);
+    accel = new BVH4(Line4i::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH4Line4iMeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH4Line4iMeshRefitSAH(accel,mesh,0); break;
@@ -990,35 +992,35 @@ namespace embree
   void BVH4Factory::createTriangleMeshTriangle4Morton(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Triangle4::type,mesh->parent);
+    accel = new BVH4(Triangle4::type(),mesh->parent);
     builder = factory->BVH4Triangle4MeshBuilderMortonGeneral(accel,mesh,0);
   }
 
   void BVH4Factory::createTriangleMeshTriangle4vMorton(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Triangle4v::type,mesh->parent);
+    accel = new BVH4(Triangle4v::type(),mesh->parent);
     builder = factory->BVH4Triangle4vMeshBuilderMortonGeneral(accel,mesh,0);
   }
 
   void BVH4Factory::createTriangleMeshTriangle4iMorton(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Triangle4i::type,mesh->parent);
+    accel = new BVH4(Triangle4i::type(),mesh->parent);
     builder = factory->BVH4Triangle4iMeshBuilderMortonGeneral(accel,mesh,0); 
   }
 
   void BVH4Factory::createQuadMeshQuad4vMorton(QuadMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Quad4v::type,mesh->parent);
+    accel = new BVH4(Quad4v::type(),mesh->parent);
     builder = factory->BVH4Quad4vMeshBuilderMortonGeneral(accel,mesh,0);
   }
 
   void BVH4Factory::createTriangleMeshTriangle4(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Triangle4::type,mesh->parent);
+    accel = new BVH4(Triangle4::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH4Triangle4MeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH4Triangle4MeshRefitSAH(accel,mesh,0); break;
@@ -1030,7 +1032,7 @@ namespace embree
   void BVH4Factory::createTriangleMeshTriangle4v(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Triangle4v::type,mesh->parent);
+    accel = new BVH4(Triangle4v::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH4Triangle4vMeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH4Triangle4vMeshRefitSAH(accel,mesh,0); break;
@@ -1042,7 +1044,7 @@ namespace embree
   void BVH4Factory::createTriangleMeshTriangle4i(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Triangle4i::type,mesh->parent);
+    accel = new BVH4(Triangle4i::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH4Triangle4iMeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH4Triangle4iMeshRefitSAH(accel,mesh,0); break;
@@ -1054,7 +1056,7 @@ namespace embree
   void BVH4Factory::createQuadMeshQuad4v(QuadMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Quad4v::type,mesh->parent);
+    accel = new BVH4(Quad4v::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH4Quad4vMeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH4Quad4vMeshRefitSAH(accel,mesh,0); break;
@@ -1066,7 +1068,7 @@ namespace embree
   void BVH4Factory::createAccelSetMesh(AccelSet* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH4Factory* factory = mesh->parent->device->bvh4_factory.get();
-    accel = new BVH4(Object::type,mesh->parent);
+    accel = new BVH4(Object::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH4VirtualMeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH4VirtualMeshRefitSAH(accel,mesh,0); break;
@@ -1077,7 +1079,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Bezier1v(Scene* scene)
   {
-    BVH4* accel = new BVH4(Bezier1v::type,scene);
+    BVH4* accel = new BVH4(Bezier1v::type(),scene);
     Accel::Intersectors intersectors = BVH4Bezier1vIntersectors(accel);
 
     Builder* builder = nullptr;
@@ -1090,7 +1092,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Bezier1i(Scene* scene)
   {
-    BVH4* accel = new BVH4(Bezier1i::type,scene);
+    BVH4* accel = new BVH4(Bezier1i::type(),scene);
     Accel::Intersectors intersectors = BVH4Bezier1iIntersectors(accel);
 
     Builder* builder = nullptr;
@@ -1104,7 +1106,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Line4i(Scene* scene, BuildVariant bvariant)
   {
-    BVH4* accel = new BVH4(Line4i::type,scene);
+    BVH4* accel = new BVH4(Line4i::type(),scene);
     Accel::Intersectors intersectors = BVH4Line4iIntersectors(accel);
 
     Builder* builder = nullptr;
@@ -1125,7 +1127,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Line4iMB(Scene* scene)
   {
-    BVH4* accel = new BVH4(Line4i::type,scene);
+    BVH4* accel = new BVH4(Line4i::type(),scene);
     Accel::Intersectors intersectors = BVH4Line4iMBIntersectors(accel);
 
     Builder* builder = nullptr;
@@ -1139,7 +1141,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4OBBBezier1v(Scene* scene)
   {
-    BVH4* accel = new BVH4(Bezier1v::type,scene);
+    BVH4* accel = new BVH4(Bezier1v::type(),scene);
     Accel::Intersectors intersectors = BVH4Bezier1vIntersectors_OBB(accel);
 
     Builder* builder = nullptr;
@@ -1152,7 +1154,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4OBBBezier1i(Scene* scene)
   {
-    BVH4* accel = new BVH4(Bezier1i::type,scene);
+    BVH4* accel = new BVH4(Bezier1i::type(),scene);
     Accel::Intersectors intersectors = BVH4Bezier1iIntersectors_OBB(accel);
 
     Builder* builder = nullptr;
@@ -1166,7 +1168,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4OBBBezier1iMB(Scene* scene)
   {
-    BVH4* accel = new BVH4(Bezier1i::type,scene);
+    BVH4* accel = new BVH4(Bezier1i::type(),scene);
     Accel::Intersectors intersectors = BVH4Bezier1iMBIntersectors_OBB(accel);
 
     Builder* builder = nullptr;
@@ -1180,7 +1182,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4InstancedBVH4Triangle4ObjectSplit(Scene* scene)
   {
-    BVH4* accel = new BVH4(Triangle4::type,scene);
+    BVH4* accel = new BVH4(Triangle4::type(),scene);
     Accel::Intersectors intersectors = BVH4Triangle4IntersectorsInstancing(accel);
     Builder* builder = BVH4BuilderInstancingTriangleMeshSAH(accel,scene,&createTriangleMeshTriangle4);
     return new AccelInstance(accel,builder,intersectors);
@@ -1188,7 +1190,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Triangle4(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH4* accel = new BVH4(Triangle4::type,scene);
+    BVH4* accel = new BVH4(Triangle4::type(),scene);
 
     Accel::Intersectors intersectors;
     if      (scene->device->tri_traverser == "default") intersectors = BVH4Triangle4Intersectors(accel,ivariant);
@@ -1215,7 +1217,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Triangle4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH4* accel = new BVH4(Triangle4v::type,scene);
+    BVH4* accel = new BVH4(Triangle4v::type(),scene);
 
     Accel::Intersectors intersectors;
     if      (scene->device->tri_traverser == "default") intersectors = BVH4Triangle4vIntersectors(accel,ivariant);
@@ -1243,7 +1245,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Triangle4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH4* accel = new BVH4(Triangle4i::type,scene);
+    BVH4* accel = new BVH4(Triangle4i::type(),scene);
     
     Accel::Intersectors intersectors;
     if      (scene->device->tri_traverser == "default") intersectors = BVH4Triangle4iIntersectors(accel,ivariant);
@@ -1272,7 +1274,7 @@ namespace embree
 
    Accel* BVH4Factory::BVH4Triangle4vMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH4* accel = new BVH4(Triangle4vMB::type,scene);
+    BVH4* accel = new BVH4(Triangle4vMB::type(),scene);
 
     Accel::Intersectors intersectors;
     if      (scene->device->tri_traverser_mb == "default") intersectors = BVH4Triangle4vMBIntersectors(accel,ivariant);
@@ -1295,7 +1297,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Triangle4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH4* accel = new BVH4(Triangle4iMB::type,scene);
+    BVH4* accel = new BVH4(Triangle4iMB::type(),scene);
 
     Accel::Intersectors intersectors;
     if      (scene->device->tri_traverser_mb == "default") intersectors = BVH4Triangle4iMBIntersectors(accel,ivariant);
@@ -1320,7 +1322,7 @@ namespace embree
   
   Accel* BVH4Factory::BVH4Quad4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH4* accel = new BVH4(Quad4v::type,scene);
+    BVH4* accel = new BVH4(Quad4v::type(),scene);
     Accel::Intersectors intersectors = BVH4Quad4vIntersectors(accel,ivariant);
    
     Builder* builder = nullptr;
@@ -1341,7 +1343,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Quad4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH4* accel = new BVH4(Quad4i::type,scene);
+    BVH4* accel = new BVH4(Quad4i::type(),scene);
     Accel::Intersectors intersectors = BVH4Quad4iIntersectors(accel,ivariant);
 
     Builder* builder = nullptr;
@@ -1361,7 +1363,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4Quad4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH4* accel = new BVH4(Quad4iMB::type,scene);
+    BVH4* accel = new BVH4(Quad4iMB::type(),scene);
     Accel::Intersectors intersectors = BVH4Quad4iMBIntersectors(accel,ivariant);
 
     Builder* builder = nullptr;
@@ -1381,7 +1383,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4QuantizedQuad4i(Scene* scene)
   {
-    BVH4* accel = new BVH4(Quad4i::type,scene);
+    BVH4* accel = new BVH4(Quad4i::type(),scene);
     Builder* builder = BVH4QuantizedQuad4iSceneBuilderSAH(accel,scene,0);
     Accel::Intersectors intersectors = QBVH4Quad4iIntersectors(accel);
     scene->needQuadVertices = true;
@@ -1390,7 +1392,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4QuantizedTriangle4i(Scene* scene)
   {
-    BVH4* accel = new BVH4(Triangle4i::type,scene);
+    BVH4* accel = new BVH4(Triangle4i::type(),scene);
     Builder* builder = BVH4QuantizedTriangle4iSceneBuilderSAH(accel,scene,0);
     Accel::Intersectors intersectors = QBVH4Triangle4iIntersectors(accel);
     scene->needTriangleVertices = true;
@@ -1401,7 +1403,7 @@ namespace embree
   {
     if (cached)
     {
-      BVH4* accel = new BVH4(SubdivPatch1Cached::type_cached,scene);
+      BVH4* accel = new BVH4(SubdivPatch1Cached::type_cached(),scene);
       Accel::Intersectors intersectors = BVH4SubdivPatch1CachedIntersectors(accel);
       Builder* builder = BVH4SubdivPatch1CachedBuilderSAH(accel,scene,1);
       scene->needSubdivVertices = true;
@@ -1409,7 +1411,7 @@ namespace embree
     }
     else 
     {
-      BVH4* accel = new BVH4(SubdivPatch1Cached::type,scene);
+      BVH4* accel = new BVH4(SubdivPatch1Cached::type(),scene);
       Accel::Intersectors intersectors = BVH4SubdivPatch1Intersectors(accel);
       Builder* builder = BVH4SubdivPatch1CachedBuilderSAH(accel,scene,0);
       scene->needSubdivVertices = true;
@@ -1419,7 +1421,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4SubdivPatch1Eager(Scene* scene)
   {
-    BVH4* accel = new BVH4(SubdivPatch1Cached::type,scene); // FIXME: use different type
+    BVH4* accel = new BVH4(SubdivPatch1Cached::type(),scene); // FIXME: use different type
     Accel::Intersectors intersectors = BVH4SubdivPatch1EagerIntersectors(accel);
     Builder* builder = BVH4SubdivPatch1EagerBuilderSAH(accel,scene,0);
     return new AccelInstance(accel,builder,intersectors);
@@ -1429,7 +1431,7 @@ namespace embree
   {
     if (cached)
     {
-      BVH4* accel = new BVH4(SubdivPatch1Cached::type_cached,scene);
+      BVH4* accel = new BVH4(SubdivPatch1Cached::type_cached(),scene);
       Accel::Intersectors intersectors = BVH4SubdivPatch1CachedMBIntersectors(accel);
       Builder* builder = BVH4SubdivPatch1CachedMBBuilderSAH(accel,scene,1);
       scene->needSubdivVertices = true;
@@ -1437,7 +1439,7 @@ namespace embree
     }
     else
     {
-      BVH4* accel = new BVH4(SubdivPatch1Cached::type,scene);
+      BVH4* accel = new BVH4(SubdivPatch1Cached::type(),scene);
       Accel::Intersectors intersectors = BVH4SubdivPatch1MBIntersectors(accel);
       Builder* builder = BVH4SubdivPatch1CachedMBBuilderSAH(accel,scene,0);
       scene->needSubdivVertices = true;
@@ -1447,7 +1449,7 @@ namespace embree
 
   Accel* BVH4Factory::BVH4UserGeometry(Scene* scene, BuildVariant bvariant)
   {
-    BVH4* accel = new BVH4(Object::type,scene);
+    BVH4* accel = new BVH4(Object::type(),scene);
     Accel::Intersectors intersectors = BVH4UserGeometryIntersectors(accel);
 
     Builder* builder = nullptr;
@@ -1467,11 +1469,11 @@ namespace embree
 
   Accel* BVH4Factory::BVH4UserGeometryMB(Scene* scene)
   {
-    BVH4* accel = new BVH4(Object::type,scene);
+    BVH4* accel = new BVH4(Object::type(),scene);
     Accel::Intersectors intersectors = BVH4UserGeometryMBIntersectors(accel);
     Builder* builder = BVH4VirtualMBSceneBuilderSAH(accel,scene,0);
     return new AccelInstance(accel,builder,intersectors);
   }
 }
-
+}
 

kernels/bvh/bvh4_factory.h

@@ -22,6 +22,8 @@
 #include "../common/scene.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! BVH4 instantiations */
   class BVH4Factory
@@ -347,3 +349,4 @@ namespace embree
     
   };
 }
+}

kernels/bvh/bvh8_factory.cpp

@@ -14,7 +14,7 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
 
 #include "bvh8_factory.h"
 #include "../bvh/bvh.h"
@@ -34,6 +34,8 @@
 #include "../common/accelinstance.h"
 
 namespace embree
+{
+namespace isa
 {
   DECLARE_SYMBOL2(Accel::Intersector1,BVH8Line4iIntersector1);
   DECLARE_SYMBOL2(Accel::Intersector1,BVH8Line4iMBIntersector1);
@@ -392,28 +394,28 @@ namespace embree
   void BVH8Factory::createTriangleMeshTriangle4Morton(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH8Factory* factory = mesh->parent->device->bvh8_factory.get();
-    accel = new BVH8(Triangle4::type,mesh->parent);
+    accel = new BVH8(Triangle4::type(),mesh->parent);
     builder = factory->BVH8Triangle4MeshBuilderMortonGeneral(accel,mesh,0);
   }
 
   void BVH8Factory::createTriangleMeshTriangle4vMorton(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH8Factory* factory = mesh->parent->device->bvh8_factory.get();
-    accel = new BVH8(Triangle4v::type,mesh->parent);
+    accel = new BVH8(Triangle4v::type(),mesh->parent);
     builder = factory->BVH8Triangle4vMeshBuilderMortonGeneral(accel,mesh,0);
   }
 
   void BVH8Factory::createTriangleMeshTriangle4iMorton(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH8Factory* factory = mesh->parent->device->bvh8_factory.get();
-    accel = new BVH8(Triangle4i::type,mesh->parent);
+    accel = new BVH8(Triangle4i::type(),mesh->parent);
     builder = factory->BVH8Triangle4iMeshBuilderMortonGeneral(accel,mesh,0); 
   }
 
   void BVH8Factory::createTriangleMeshTriangle4(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH8Factory* factory = mesh->parent->device->bvh8_factory.get();
-    accel = new BVH8(Triangle4::type,mesh->parent);
+    accel = new BVH8(Triangle4::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH8Triangle4MeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH8Triangle4MeshRefitSAH(accel,mesh,0); break;
@@ -425,7 +427,7 @@ namespace embree
   void BVH8Factory::createTriangleMeshTriangle4v(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH8Factory* factory = mesh->parent->device->bvh8_factory.get();
-    accel = new BVH8(Triangle4v::type,mesh->parent);
+    accel = new BVH8(Triangle4v::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH8Triangle4vMeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH8Triangle4vMeshRefitSAH(accel,mesh,0); break;
@@ -437,7 +439,7 @@ namespace embree
   void BVH8Factory::createTriangleMeshTriangle4i(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH8Factory* factory = mesh->parent->device->bvh8_factory.get();
-    accel = new BVH8(Triangle4i::type,mesh->parent);
+    accel = new BVH8(Triangle4i::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH8Triangle4iMeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH8Triangle4iMeshRefitSAH(accel,mesh,0); break;
@@ -449,7 +451,7 @@ namespace embree
   void BVH8Factory::createQuadMeshQuad4v(QuadMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH8Factory* factory = mesh->parent->device->bvh8_factory.get();
-    accel = new BVH8(Quad4v::type,mesh->parent);
+    accel = new BVH8(Quad4v::type(),mesh->parent);
     switch (mesh->flags) {
     case RTC_GEOMETRY_STATIC:     builder = factory->BVH8Quad4vMeshBuilderSAH(accel,mesh,0); break;
     case RTC_GEOMETRY_DEFORMABLE: builder = factory->BVH8Quad4vMeshRefitSAH(accel,mesh,0); break;
@@ -461,7 +463,7 @@ namespace embree
   void BVH8Factory::createQuadMeshQuad4vMorton(QuadMesh* mesh, AccelData*& accel, Builder*& builder)
   {
     BVH8Factory* factory = mesh->parent->device->bvh8_factory.get();
-    accel = new BVH8(Quad4v::type,mesh->parent);
+    accel = new BVH8(Quad4v::type(),mesh->parent);
     builder = factory->BVH8Quad4vMeshBuilderMortonGeneral(accel,mesh,0);
   }
 
@@ -789,7 +791,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8OBBBezier1v(Scene* scene)
   {
-    BVH8* accel = new BVH8(Bezier1v::type,scene);
+    BVH8* accel = new BVH8(Bezier1v::type(),scene);
     Accel::Intersectors intersectors = BVH8Bezier1vIntersectors_OBB(accel);
     Builder* builder = BVH8Bezier1vBuilder_OBB_New(accel,scene,0);
     return new AccelInstance(accel,builder,intersectors);
@@ -797,7 +799,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8OBBBezier1i(Scene* scene)
   {
-    BVH8* accel = new BVH8(Bezier1i::type,scene);
+    BVH8* accel = new BVH8(Bezier1i::type(),scene);
     Accel::Intersectors intersectors = BVH8Bezier1iIntersectors_OBB(accel);
     Builder* builder = BVH8Bezier1iBuilder_OBB_New(accel,scene,0);
     scene->needBezierVertices = true;
@@ -806,7 +808,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8OBBBezier1iMB(Scene* scene)
   {
-    BVH8* accel = new BVH8(Bezier1i::type,scene);
+    BVH8* accel = new BVH8(Bezier1i::type(),scene);
     Accel::Intersectors intersectors = BVH8Bezier1iMBIntersectors_OBB(accel);
     Builder* builder = BVH8Bezier1iMBBuilder_OBB_New(accel,scene,0);
     scene->needBezierVertices = true;
@@ -815,7 +817,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Line4i(Scene* scene)
   {
-    BVH8* accel = new BVH8(Line4i::type,scene);
+    BVH8* accel = new BVH8(Line4i::type(),scene);
     Accel::Intersectors intersectors = BVH8Line4iIntersectors(accel);
     Builder* builder = nullptr;
     if      (scene->device->line_builder == "default"     ) builder = BVH8Line4iSceneBuilderSAH(accel,scene,0);
@@ -826,7 +828,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Line4iMB(Scene* scene)
   {
-    BVH8* accel = new BVH8(Line4i::type,scene);
+    BVH8* accel = new BVH8(Line4i::type(),scene);
     Accel::Intersectors intersectors = BVH8Line4iMBIntersectors(accel);
     Builder* builder = nullptr;
     if      (scene->device->line_builder_mb == "default"     ) builder = BVH8Line4iMBSceneBuilderSAH(accel,scene,0);
@@ -837,7 +839,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Triangle4(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH8* accel = new BVH8(Triangle4::type,scene);
+    BVH8* accel = new BVH8(Triangle4::type(),scene);
     Accel::Intersectors intersectors= BVH8Triangle4Intersectors(accel,ivariant);
     Builder* builder = nullptr;
     if (scene->device->tri_builder == "default")  {
@@ -859,7 +861,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Triangle4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH8* accel = new BVH8(Triangle4v::type,scene);
+    BVH8* accel = new BVH8(Triangle4v::type(),scene);
     Accel::Intersectors intersectors= BVH8Triangle4vIntersectors(accel,ivariant);
     Builder* builder = nullptr;
     if (scene->device->tri_builder == "default")  {
@@ -875,7 +877,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Triangle4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH8* accel = new BVH8(Triangle4i::type,scene);
+    BVH8* accel = new BVH8(Triangle4i::type(),scene);
     Accel::Intersectors intersectors = BVH8Triangle4iIntersectors(accel,ivariant);
 
     Builder* builder = nullptr;
@@ -896,7 +898,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Triangle4vMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH8* accel = new BVH8(Triangle4vMB::type,scene);
+    BVH8* accel = new BVH8(Triangle4vMB::type(),scene);
     Accel::Intersectors intersectors= BVH8Triangle4vMBIntersectors(accel,ivariant);
 
     Builder* builder = nullptr;
@@ -915,7 +917,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Triangle4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH8* accel = new BVH8(Triangle4iMB::type,scene);
+    BVH8* accel = new BVH8(Triangle4iMB::type(),scene);
     Accel::Intersectors intersectors= BVH8Triangle4iMBIntersectors(accel,ivariant);
 
     Builder* builder = nullptr;
@@ -934,7 +936,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8QuantizedTriangle4i(Scene* scene)
   {
-    BVH8* accel = new BVH8(Triangle4i::type,scene);
+    BVH8* accel = new BVH8(Triangle4i::type(),scene);
     Accel::Intersectors intersectors = QBVH8Triangle4iIntersectors(accel);
     Builder* builder = BVH8QuantizedTriangle4iSceneBuilderSAH(accel,scene,0);
     scene->needTriangleVertices = true;
@@ -943,7 +945,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Quad4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH8* accel = new BVH8(Quad4v::type,scene);
+    BVH8* accel = new BVH8(Quad4v::type(),scene);
     Accel::Intersectors intersectors = BVH8Quad4vIntersectors(accel,ivariant);
 
     Builder* builder = nullptr;
@@ -964,7 +966,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Quad4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH8* accel = new BVH8(Quad4i::type,scene);
+    BVH8* accel = new BVH8(Quad4i::type(),scene);
     Accel::Intersectors intersectors = BVH8Quad4iIntersectors(accel,ivariant);
 
     Builder* builder = nullptr;
@@ -983,7 +985,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8Quad4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
   {
-    BVH8* accel = new BVH8(Quad4iMB::type,scene);
+    BVH8* accel = new BVH8(Quad4iMB::type(),scene);
     Accel::Intersectors intersectors = BVH8Quad4iMBIntersectors(accel,ivariant);
 
     Builder* builder = nullptr;
@@ -1002,7 +1004,7 @@ namespace embree
 
   Accel* BVH8Factory::BVH8QuantizedQuad4i(Scene* scene)
   {
-    BVH8* accel = new BVH8(Quad4i::type,scene);
+    BVH8* accel = new BVH8(Quad4i::type(),scene);
     Accel::Intersectors intersectors = QBVH8Quad4iIntersectors(accel);
     Builder* builder = nullptr;
     if      (scene->device->quad_builder == "default"     ) builder = BVH8QuantizedQuad4iSceneBuilderSAH(accel,scene,0);
@@ -1011,5 +1013,6 @@ namespace embree
     return new AccelInstance(accel,builder,intersectors);
   }
 }
+}
 
 #endif

kernels/bvh/bvh8_factory.h

@@ -22,6 +22,8 @@
 #include "../common/scene.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! BVH8 instantiations */
   class BVH8Factory
@@ -254,3 +256,4 @@ namespace embree
     DEFINE_BUILDER2(void,Scene,size_t,BVH8Quad4vSceneBuilderFastSpatialSAH);
   };
 }
+}

kernels/bvh/bvh_intersector1_bvh4.cpp

@@ -20,10 +20,6 @@ namespace embree
 {
   namespace isa
   {
-    int getISA() {
-      return VerifyMultiTargetLinking::getISA();
-    }
-
     ////////////////////////////////////////////////////////////////////////////////
     /// BVH4Intersector1 Definitions
     ////////////////////////////////////////////////////////////////////////////////

kernels/bvh/bvh_intersector1_bvh8.cpp

@@ -14,6 +14,8 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
+#if defined (__AVX__)
+
 #include "bvh_intersector1.cpp"
 
 namespace embree
@@ -52,3 +54,5 @@ namespace embree
     IF_ENABLED_LINES(DEFINE_INTERSECTOR1(BVH8Line4iMBIntersector1,BVHNIntersector1<8 COMMA BVH_AN2 COMMA false COMMA ArrayIntersector1<LineMiMBIntersector1<SIMD_MODE(4) COMMA true> > >));
   }
 }
+
+#endif

kernels/bvh/bvh_intersector_hybrid16_bvh4.cpp

@@ -14,6 +14,8 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
+#if defined (__AVX512F__)
+
 #include "bvh_intersector_hybrid.cpp"
 
 namespace embree
@@ -62,3 +64,4 @@ namespace embree
   }
 }
 
+#endif

kernels/bvh/bvh_intersector_hybrid16_bvh8.cpp

@@ -14,6 +14,8 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
+#if defined (__AVX512F__)
+
 #include "bvh_intersector_hybrid.cpp"
 
 namespace embree
@@ -53,3 +55,4 @@ namespace embree
   }
 }
 
+#endif

kernels/bvh/bvh_intersector_hybrid4_bvh8.cpp

@@ -14,6 +14,8 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
+#if defined (__AVX__)
+
 #include "bvh_intersector_hybrid.cpp"
 
 namespace embree
@@ -53,3 +55,4 @@ namespace embree
   }
 }
 
+#endif

kernels/bvh/bvh_intersector_hybrid8_bvh4.cpp

@@ -14,6 +14,8 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
+#if defined (__AVX__)
+
 #include "bvh_intersector_hybrid.cpp"
 
 namespace embree
@@ -62,3 +64,4 @@ namespace embree
   }
 }
 
+#endif

kernels/bvh/bvh_intersector_hybrid8_bvh8.cpp

@@ -14,6 +14,8 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
+#if defined (__AVX__)
+
 #include "bvh_intersector_hybrid.cpp"
 
 namespace embree
@@ -53,3 +55,4 @@ namespace embree
   }
 }
 
+#endif

kernels/bvh/bvh_intersector_stream_bvh8.cpp

@@ -14,6 +14,8 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
+#if defined (__AVX__)
+
 #include "bvh_intersector_stream.cpp"
 
 namespace embree
@@ -54,3 +56,5 @@ namespace embree
     //IF_ENABLED_QUADS(DEFINE_INTERSECTORN(BVH8Quad4iMBIntersectorStreamPluecker,BVHNIntersectorStream<SIMD_MODE(8) COMMA BVH_AN2 COMMA false COMMA ArrayIntersector1<QuadMiMBIntersector1Pluecker<4 COMMA true> > >));
   }
 }
+
+#endif

kernels/bvh/bvh_statistics.cpp

@@ -18,6 +18,8 @@
 #include "../../common/algorithms/parallel_reduce.h"
 
 namespace embree
+{
+namespace isa
 {
   template<int N>
   BVHNStatistics<N>::BVHNStatistics (BVH* bvh) : bvh(bvh)
@@ -168,7 +170,8 @@ namespace embree
   template class BVHNStatistics<8>;
 #endif
 
-#if !defined(__AVX__) || !defined(__TARGET_SSE2__) && !defined(__TARGET_SSE42__)
+#if defined(__SSE2__)
   template class BVHNStatistics<4>;
 #endif
 }
+}

kernels/bvh/bvh_statistics.h

@@ -20,6 +20,8 @@
 #include <sstream>
 
 namespace embree
+{
+namespace isa
 {
   template<int N>
   class BVHNStatistics
@@ -288,3 +290,4 @@ namespace embree
   typedef BVHNStatistics<4> BVH4Statistics;
   typedef BVHNStatistics<8> BVH8Statistics;
 }
+}

kernels/common/accel.h

@@ -22,6 +22,9 @@
 
 namespace embree
 {
+namespace isa
+{
+
   class Scene;
 
   /*! Base class for the acceleration structure data. */
@@ -497,3 +500,4 @@ namespace embree
 
   typedef RayStreamFilterFuncs (*RayStreamFilterFuncsType)();
 }
+}

kernels/common/accelinstance.h

@@ -20,6 +20,8 @@
 #include "builder.h"
 
 namespace embree
+{
+namespace isa
 {
   class AccelInstance : public Accel
   {
@@ -52,3 +54,4 @@ namespace embree
     std::unique_ptr<Builder> builder;
   };
 }
+}

kernels/common/acceln.cpp

@@ -20,6 +20,8 @@
 #include "../../common/algorithms/parallel_for.h"
 
 namespace embree
+{
+namespace isa
 {
   AccelN::AccelN () 
     : Accel(AccelData::TY_ACCELN), accels(nullptr), validAccels(nullptr), validIntersectorN(false) {}
@@ -207,4 +209,4 @@ namespace embree
       accels[i]->clear();
   }
 }
-
+}

kernels/common/acceln.h

@@ -19,6 +19,8 @@
 #include "accel.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! merges N acceleration structures together, by processing them in order */
   class AccelN : public Accel
@@ -59,3 +61,5 @@ namespace embree
     bool validIntersectorN;
   };
 }
+}
+

kernels/common/accelset.cpp

@@ -18,6 +18,8 @@
 #include "scene.h"
 
 namespace embree
+{
+namespace isa
 {
   AccelSet::AccelSet (Scene* parent, RTCGeometryFlags gflags, size_t numItems, size_t numTimeSteps) 
     : Geometry(parent,Geometry::USER_GEOMETRY,numItems,numTimeSteps,gflags), boundsFunc(nullptr), boundsFunc2(nullptr), boundsFunc3(nullptr), boundsFuncUserPtr(nullptr)
@@ -79,3 +81,4 @@ namespace embree
   AccelSet::IntersectorN::IntersectorN (IntersectFuncN intersect, OccludedFuncN occluded, const char* name)
     : intersect(intersect), occluded(occluded), name(name) {}
 }
+}

kernels/common/accelset.h

@@ -22,6 +22,8 @@
 #include "ray.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! Base class for set of acceleration structures. */
   class AccelSet : public Geometry
@@ -490,3 +492,4 @@ namespace embree
                                   TOSTRING(isa) "::" TOSTRING(symbol)); \
   }
 }
+}

kernels/common/alloc.cpp

@@ -19,13 +19,16 @@
 
 namespace embree
 {
-  __thread FastAllocator::ThreadLocal2* FastAllocator::thread_local_allocator2 = nullptr;
+namespace isa
+{
+  __thread isa::FastAllocator::ThreadLocal2* isa::FastAllocator::thread_local_allocator2 = nullptr;
 
+#if 0
   struct fast_allocator_regression_test : public RegressionTest
   {
     BarrierSys barrier;
     std::atomic<size_t> numFailed;
-    std::unique_ptr<FastAllocator> alloc;
+    std::unique_ptr<isa::FastAllocator> alloc;
 
     fast_allocator_regression_test() 
       : RegressionTest("fast_allocator_regression_test"), numFailed(0)
@@ -35,7 +38,7 @@ namespace embree
 
     static void thread_alloc(fast_allocator_regression_test* This)
     {
-      FastAllocator::CachedAllocator threadalloc = This->alloc->getCachedAllocator();
+      isa::FastAllocator::CachedAllocator threadalloc = This->alloc->getCachedAllocator();
 
       size_t* ptrs[1000];
       for (size_t j=0; j<1000; j++)
@@ -55,7 +58,7 @@ namespace embree
     
     bool run ()
     {
-      alloc = make_unique(new FastAllocator(nullptr,false));
+      alloc = make_unique(new isa::FastAllocator(nullptr,false));
       numFailed.store(0);
 
       size_t numThreads = getNumberOfLogicalThreads();
@@ -85,6 +88,7 @@ namespace embree
   };
 
   fast_allocator_regression_test fast_allocator_regression;
+#endif
+}
 }
 
-

kernels/common/alloc.h

@@ -23,7 +23,9 @@
 
 namespace embree
 {
-  class FastAllocator
+namespace isa
+{
+  class FastAllocator 
   {
     /*! maximal supported alignment */
     static const size_t maxAlignment = 64;
@@ -873,3 +875,4 @@ namespace embree
     mvector<PrimRef> primrefarray;     //!< primrefarray used to allocate nodes
   };
 }
+}

kernels/common/buffer.h

@@ -19,6 +19,8 @@
 #include "default.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! Implements a reference to a data buffer, this class does not own the buffer content. */
   class BufferRef
@@ -278,3 +280,4 @@ namespace embree
     int userdata;    //!< special data
   };
 }
+}

kernels/common/builder.h

@@ -21,6 +21,8 @@
 
 namespace embree
 {
+namespace isa
+{
 #define MODE_HIGH_QUALITY (1<<8)
 
   /*! virtual interface for all hierarchy builders */
@@ -71,3 +73,4 @@ namespace embree
   typedef void (*createAccelSetAccelTy)(AccelSet* mesh, AccelData*& accel, Builder*& builder);
 
 }
+}

kernels/common/context.h

@@ -20,6 +20,8 @@
 #include "rtcore.h"
 
 namespace embree
+{
+namespace isa
 {
   class Scene;
 
@@ -57,3 +59,4 @@ namespace embree
     
   };
 }
+}

kernels/common/default.h

@@ -63,6 +63,8 @@
 #include <sstream>
 
 namespace embree
+{
+namespace isa
 {
   ////////////////////////////////////////////////////////////////////////////////
   /// Vec2 shortcuts
@@ -200,3 +202,4 @@ namespace embree
   typedef BBox<Vec3vf8>  BBox3vf8;
   typedef BBox<Vec3vf16> BBox3vf16;
 }
+}

kernels/common/device.cpp

@@ -37,35 +37,38 @@
 
 namespace embree
 {
-  /*! some global variables that can be set via rtcSetParameter1i for debugging purposes */
-  ssize_t Device::debug_int0 = 0;
-  ssize_t Device::debug_int1 = 0;
-  ssize_t Device::debug_int2 = 0;
-  ssize_t Device::debug_int3 = 0;
-
+namespace isa
+{
   DECLARE_SYMBOL2(RayStreamFilterFuncs,rayStreamFilterFuncs);
 
-  static MutexSys g_mutex;
-  static std::map<Device*,size_t> g_cache_size_map;
-  static std::map<Device*,size_t> g_num_threads_map;
+  Device::Device (const State& state)
+    : State(state) 
+  {
+    init();
+  }
 
   Device::Device (const char* cfg, bool singledevice)
-    : State(singledevice)
+    : State(cfg,singledevice)
+  {
+    init();
+  }
+
+  void Device::init()
   {
     /* check CPU */
     if (!hasISA(ISA)) 
       throw_RTCError(RTC_UNSUPPORTED_CPU,"CPU does not support " ISA_STR);
 
-    /* initialize global state */
-    State::parseString(cfg);
-    if (!ignore_config_files && FileName::executableFolder() != FileName(""))
-      State::parseFile(FileName::executableFolder()+FileName(".embree" TOSTRING(__EMBREE_VERSION_MAJOR__)));
-    if (!ignore_config_files && FileName::homeFolder() != FileName(""))
-      State::parseFile(FileName::homeFolder()+FileName(".embree" TOSTRING(__EMBREE_VERSION_MAJOR__)));
-    State::verify();
+    error_function = nullptr;
+    error_function2 = nullptr;
+    error_function_userptr = nullptr;
+
+    memory_monitor_function = nullptr;
+    memory_monitor_function2 = nullptr;
+    memory_monitor_userptr = nullptr;
 
     /*! do some internal tests */
-    assert(isa::Cylinder::verify());
+    assert(Cylinder::verify());
 
     /*! enable huge page support if desired */
 #if defined(__WIN32__)
@@ -101,7 +104,7 @@ namespace embree
 
     bvh4_factory = make_unique(new BVH4Factory(enabled_builder_cpu_features, enabled_cpu_features));
 
-#if defined(__TARGET_AVX__)
+#if defined(__AVX__)
     bvh8_factory = make_unique(new BVH8Factory(enabled_builder_cpu_features, enabled_cpu_features));
 #endif
 
@@ -225,6 +228,10 @@ namespace embree
     std::cout << std::endl;
   }
 
+  SceneInterface* Device::newScene (RTCSceneFlags flags, RTCAlgorithmFlags aflags) {
+    return new Scene(this,flags,aflags);
+  }
+
   void Device::setDeviceErrorCode(RTCError error)
   {
     RTCError* stored_error = errorHandler.error();
@@ -240,29 +247,10 @@ namespace embree
     return error;
   }
 
-  void Device::setThreadErrorCode(RTCError error)
-  {
-    RTCError* stored_error = g_errorHandler.error();
-    if (*stored_error == RTC_NO_ERROR)
-      *stored_error = error;
-  }
-
-  RTCError Device::getThreadErrorCode()
-  {
-    RTCError* stored_error = g_errorHandler.error();
-    RTCError error = *stored_error;
-    *stored_error = RTC_NO_ERROR;
-    return error;
-  }
-
-  void Device::process_error(Device* device, RTCError error, const char* str)
+  void Device::processError(RTCError error, const char* str)
   { 
-    /* store global error code when device construction failed */
-    if (!device)
-      return setThreadErrorCode(error);
-
     /* print error when in verbose mode */
-    if (device->verbosity(1)) 
+    if (verbosity(1)) 
     {
       switch (error) {
       case RTC_NO_ERROR         : std::cerr << "Embree: No error"; break;
@@ -278,74 +266,47 @@ namespace embree
     }
 
     /* call user specified error callback */
-    if (device->error_function) 
-      device->error_function(error,str); 
-    if (device->error_function2) 
-      device->error_function2(device->error_function_userptr,error,str); 
+    if (error_function) 
+      error_function(error,str); 
+    if (error_function2) 
+      error_function2(error_function_userptr,error,str); 
 
     /* record error code */
-    device->setDeviceErrorCode(error);
+    setDeviceErrorCode(error);
   }
 
   void Device::memoryMonitor(ssize_t bytes, bool post)
   {
-    if (State::memory_monitor_function && bytes != 0) {
-      if (!State::memory_monitor_function(bytes,post)) {
+    if (memory_monitor_function && bytes != 0) {
+      if (!memory_monitor_function(bytes,post)) {
         if (bytes > 0) { // only throw exception when we allocate memory to never throw inside a destructor
           throw_RTCError(RTC_OUT_OF_MEMORY,"memory monitor forced termination");
         }
       }
     }
 
-    if (State::memory_monitor_function2 && bytes != 0) {
-      if (!State::memory_monitor_function2(State::memory_monitor_userptr,bytes,post)) {
+    if (memory_monitor_function2 && bytes != 0) {
+      if (!memory_monitor_function2(memory_monitor_userptr,bytes,post)) {
         if (bytes > 0) { // only throw exception when we allocate memory to never throw inside a destructor
           throw_RTCError(RTC_OUT_OF_MEMORY,"memory monitor forced termination");
         }
       }
     }
   }
-
-  size_t getMaxNumThreads()
-  {
-    size_t maxNumThreads = 0;
-    for (std::map<Device*,size_t>::iterator i=g_num_threads_map.begin(); i != g_num_threads_map.end(); i++)
-      maxNumThreads = max(maxNumThreads, (*i).second);
-    if (maxNumThreads == 0)
-      maxNumThreads = std::numeric_limits<size_t>::max();
-    return maxNumThreads;
-  }
-
-  size_t getMaxCacheSize()
-  {
-    size_t maxCacheSize = 0;
-    for (std::map<Device*,size_t>::iterator i=g_cache_size_map.begin(); i!= g_cache_size_map.end(); i++)
-      maxCacheSize = max(maxCacheSize, (*i).second);
-    return maxCacheSize;
-  }
  
   void Device::setCacheSize(size_t bytes) 
   {
 #if defined(EMBREE_GEOMETRY_SUBDIV)
-    Lock<MutexSys> lock(g_mutex);
-    if (bytes == 0) g_cache_size_map.erase(this);
-    else            g_cache_size_map[this] = bytes;
-    
-    size_t maxCacheSize = getMaxCacheSize();
+    DeviceInterface::setCacheSize(this,bytes);
+    size_t maxCacheSize = DeviceInterface::getMaxCacheSize();
     resizeTessellationCache(maxCacheSize);
 #endif
   }
 
   void Device::initTaskingSystem(size_t numThreads) 
   {
-    Lock<MutexSys> lock(g_mutex);
-    if (numThreads == 0) 
-      g_num_threads_map[this] = std::numeric_limits<size_t>::max();
-    else 
-      g_num_threads_map[this] = numThreads;
-
-    /* create task scheduler */
-    size_t maxNumThreads = getMaxNumThreads();
+    DeviceInterface::setNumThreads(this,numThreads);
+    size_t maxNumThreads = DeviceInterface::getMaxNumThreads();
     TaskScheduler::create(maxNumThreads,State::set_affinity,State::start_threads);
 #if USE_TASK_ARENA
     arena = make_unique(new tbb::task_arena((int)min(maxNumThreads,TaskScheduler::threadCount())));
@@ -354,16 +315,13 @@ namespace embree
 
   void Device::exitTaskingSystem() 
   {
-    Lock<MutexSys> lock(g_mutex);
-    g_num_threads_map.erase(this);
-
     /* terminate tasking system */
-    if (g_num_threads_map.size() == 0) {
+    if (DeviceInterface::unsetNumThreads(this)) {
       TaskScheduler::destroy();
     } 
     /* or configure new number of threads */
     else {
-      size_t maxNumThreads = getMaxNumThreads();
+      size_t maxNumThreads = DeviceInterface::getMaxNumThreads();
       TaskScheduler::create(maxNumThreads,State::set_affinity,State::start_threads);
     }
 #if USE_TASK_ARENA
@@ -528,3 +486,4 @@ namespace embree
     };
   }
 }
+}

kernels/common/device.h

@@ -21,40 +21,71 @@
 #include "accel.h"
 
 namespace embree
+{
+  struct SceneInterface;
+  struct DeviceInterface
+  {
+    virtual ~DeviceInterface() {};
+    virtual void setParameter1i(const RTCParameter parm, ssize_t val) = 0;
+    virtual ssize_t getParameter1i(const RTCParameter parm) = 0;
+    virtual RTCError getDeviceErrorCode() = 0;
+    virtual void setErrorFunction(RTCErrorFunc fptr) = 0;
+    virtual void setErrorFunction(RTCErrorFunc2 fptr, void* uptr) = 0;
+    virtual void setMemoryMonitorFunction(RTCMemoryMonitorFunc fptr) = 0;
+    virtual void setMemoryMonitorFunction(RTCMemoryMonitorFunc2 fptr, void* uptr) = 0;
+    virtual void processError(RTCError error, const char* str) = 0;
+    virtual SceneInterface* newScene (RTCSceneFlags flags, RTCAlgorithmFlags aflags) = 0;
+
+    static size_t getMaxNumThreads();
+    static size_t getMaxCacheSize();
+    static void setCacheSize(DeviceInterface* device, size_t bytes);
+    static void setNumThreads(DeviceInterface* device, size_t numThreads);
+    static bool unsetNumThreads(DeviceInterface* device);
+
+    /*! some variables that can be set via rtcSetParameter1i for debugging purposes */
+  public:
+    static ssize_t debug_int0;
+    static ssize_t debug_int1;
+    static ssize_t debug_int2;
+    static ssize_t debug_int3;
+  };
+
+namespace isa
 {
   class BVH4Factory;
   class BVH8Factory;
   class InstanceFactory;
 
-  class Device : public State, public MemoryMonitorInterface
+  class Device : public DeviceInterface, public State, public MemoryMonitorInterface
   {
     ALIGNED_CLASS;
 
   public:
 
+    /*! Device construction */
+    Device (const State& state);
+
     /*! Device construction */
     Device (const char* cfg, bool singledevice);
 
     /*! Device destruction */
     virtual ~Device ();
 
+    void init();
+
     /*! prints info about the device */
     void print();
 
+    virtual SceneInterface* newScene (RTCSceneFlags flags, RTCAlgorithmFlags aflags);
+
     /*! sets the error code */
     void setDeviceErrorCode(RTCError error);
 
     /*! returns and clears the error code */
     RTCError getDeviceErrorCode();
 
-    /*! sets the error code */
-    static void setThreadErrorCode(RTCError error);
-
-    /*! returns and clears the error code */
-    static RTCError getThreadErrorCode();
-
     /*! processes error codes, do not call directly */
-    static void process_error(Device* device, RTCError error, const char* str);
+    virtual void processError(RTCError error, const char* str);
 
     /*! invokes the memory monitor callback */
     void memoryMonitor(ssize_t bytes, bool post);
@@ -76,19 +107,12 @@ namespace embree
     /*! shuts down the tasking system */
     void exitTaskingSystem();
 
-    /*! some variables that can be set via rtcSetParameter1i for debugging purposes */
   public:
-    static ssize_t debug_int0;
-    static ssize_t debug_int1;
-    static ssize_t debug_int2;
-    static ssize_t debug_int3;
-
-  public:
-    bool singledevice;      //!< true if this is the device created implicitely through rtcInit
+    ErrorHandler errorHandler;
 
     std::unique_ptr<InstanceFactory> instance_factory;
     std::unique_ptr<BVH4Factory> bvh4_factory;
-#if defined(__TARGET_AVX__)
+#if defined(__AVX__)
     std::unique_ptr<BVH8Factory> bvh8_factory;
 #endif
     
@@ -98,5 +122,44 @@ namespace embree
     
     /* ray streams filter */
     RayStreamFilterFuncs rayStreamFilters;
+
+ public:
+    void setErrorFunction(RTCErrorFunc fptr) 
+    {
+      error_function = fptr;
+      error_function2 = nullptr;
+      error_function_userptr = nullptr;
+    }
+    
+    void setErrorFunction(RTCErrorFunc2 fptr, void* uptr) 
+    {
+      error_function = nullptr;
+      error_function2 = fptr;
+      error_function_userptr = uptr;
+    }
+
+    RTCErrorFunc error_function;
+    RTCErrorFunc2 error_function2;
+    void* error_function_userptr;
+
+  public:
+    void setMemoryMonitorFunction(RTCMemoryMonitorFunc fptr) 
+    {
+      memory_monitor_function = fptr;
+      memory_monitor_function2 = nullptr;
+      memory_monitor_userptr = nullptr;
+    }
+    
+    void setMemoryMonitorFunction(RTCMemoryMonitorFunc2 fptr, void* uptr) 
+    {
+      memory_monitor_function = nullptr;
+      memory_monitor_function2 = fptr;
+      memory_monitor_userptr = uptr;
+    }
+      
+    RTCMemoryMonitorFunc memory_monitor_function;
+    RTCMemoryMonitorFunc2 memory_monitor_function2;
+    void* memory_monitor_userptr;
   };
 }
+}

kernels/common/geometry.cpp

@@ -18,12 +18,14 @@
 #include "scene.h"
 
 namespace embree
+{
+namespace isa
 {
   Geometry::Geometry (Scene* parent, Type type, size_t numPrimitives, size_t numTimeSteps, RTCGeometryFlags flags) 
     : parent(parent), id(0), type(type), 
       numPrimitives(numPrimitives), numPrimitivesChanged(false),
       numTimeSteps(unsigned(numTimeSteps)), fnumTimeSegments(float(numTimeSteps-1)), flags(flags),
-      enabled(true), modified(true), userPtr(nullptr), mask(-1), used(1),
+      enabled(true), modified(true), mask(-1), used(1),
       intersectionFilter1(nullptr), occlusionFilter1(nullptr),
       intersectionFilter4(nullptr), occlusionFilter4(nullptr),
       intersectionFilter8(nullptr), occlusionFilter8(nullptr),
@@ -343,3 +345,4 @@ namespace embree
     }
   }
 }
+}

kernels/common/geometry.h

@@ -19,11 +19,187 @@
 #include "default.h"
 
 namespace embree
+{
+  struct GeometryInterface
+  {
+    __forceinline GeometryInterface ()
+      : userPtr(nullptr) {}
+
+    void* userPtr;             //!< user pointer
+
+    /*! Get user data pointer. */
+    __forceinline void* getUserData() const {
+      return userPtr;
+    }
+
+  public:
+    /*! Geometry destructor */
+    virtual ~GeometryInterface() {}
+
+    /*! for all geometries */
+  public:
+
+    /*! Enable geometry. */
+    virtual void enable () = 0;
+
+    /*! Update geometry. */
+    virtual void update () = 0;
+
+    /*! Update geometry buffer. */
+    virtual void updateBuffer (RTCBufferType type) = 0;
+    
+    /*! Disable geometry. */
+    virtual void disable () = 0;
+
+    /*! Free buffers that are unused */
+    virtual void immutable () = 0;
+
+    /*! Verify the geometry */
+    virtual bool verify () = 0;
+
+    /*! called if geometry is switching from disabled to enabled state */
+    virtual void enabling() = 0;
+
+    /*! called if geometry is switching from enabled to disabled state */
+    virtual void disabling() = 0;
+
+    /*! called before every build */
+    virtual void preCommit() = 0;
+
+    /*! called after every build */
+    virtual void postCommit() = 0;
+
+    /*! sets constant tessellation rate for the geometry */
+    virtual void setTessellationRate(float N) = 0;
+
+    /*! Set user data pointer. */
+    virtual void setUserData (void* ptr) = 0;
+      
+    /*! interpolates user data to the specified u/v location */
+    virtual void interpolate(unsigned primID, float u, float v, RTCBufferType buffer, float* P, float* dPdu, float* dPdv, float* ddPdudu, float* ddPdvdv, float* ddPdudv, size_t numFloats) = 0;
+
+    /*! interpolates user data to the specified u/v locations */
+    virtual void interpolateN(const void* valid_i, const unsigned* primIDs, const float* u, const float* v, size_t numUVs, 
+                              RTCBufferType buffer, float* P, float* dPdu, float* dPdv, float* ddPdudu, float* ddPdvdv, float* ddPdudv, size_t numFloats) = 0;
+
+    /*! for subdivision surfaces only */
+  public:
+    virtual void setSubdivisionMode (unsigned topologyID, RTCSubdivisionMode mode)  = 0;
+
+    virtual void setIndexBuffer(RTCBufferType vertexBuffer, RTCBufferType indexBuffer) = 0;
+
+    /*! for triangle meshes and bezier curves only */
+  public:
+
+    /*! Sets ray mask. */
+    virtual void setMask (unsigned mask) = 0;
+
+    /*! Maps specified buffer. */
+    virtual void* map(RTCBufferType type) = 0;
+
+    /*! Unmap specified buffer. */
+    virtual void unmap(RTCBufferType type) = 0;
+
+    /*! Sets specified buffer. */
+    virtual void setBuffer(RTCBufferType type, void* ptr, size_t offset, size_t stride, size_t size) = 0;
+
+    /*! Set displacement function. */
+    virtual void setDisplacementFunction (RTCDisplacementFunc filter, RTCBounds* bounds) = 0;
+
+    /*! Set displacement function. */
+    virtual void setDisplacementFunction2 (RTCDisplacementFunc2 filter, RTCBounds* bounds) = 0;
+
+    /*! Set intersection filter function for single rays. */
+    virtual void setIntersectionFilterFunction (RTCFilterFunc filter, bool ispc = false) = 0;
+    
+    /*! Set intersection filter function for ray packets of size 4. */
+    virtual void setIntersectionFilterFunction4 (RTCFilterFunc4 filter4, bool ispc = false) = 0;
+    
+    /*! Set intersection filter function for ray packets of size 8. */
+    virtual void setIntersectionFilterFunction8 (RTCFilterFunc8 filter8, bool ispc = false) = 0;
+    
+    /*! Set intersection filter function for ray packets of size 16. */
+    virtual void setIntersectionFilterFunction16 (RTCFilterFunc16 filter16, bool ispc = false) = 0;
+
+    /*! Set intersection filter function for ray packets of size N. */
+    virtual void setIntersectionFilterFunctionN (RTCFilterFuncN filterN) = 0;
+
+    /*! Set occlusion filter function for single rays. */
+    virtual void setOcclusionFilterFunction (RTCFilterFunc filter, bool ispc = false) = 0;
+    
+    /*! Set occlusion filter function for ray packets of size 4. */
+    virtual void setOcclusionFilterFunction4 (RTCFilterFunc4 filter4, bool ispc = false) = 0;
+    
+    /*! Set occlusion filter function for ray packets of size 8. */
+    virtual void setOcclusionFilterFunction8 (RTCFilterFunc8 filter8, bool ispc = false) = 0;
+    
+    /*! Set occlusion filter function for ray packets of size 16. */
+    virtual void setOcclusionFilterFunction16 (RTCFilterFunc16 filter16, bool ispc = false) = 0;
+
+    /*! Set occlusion filter function for ray packets of size N. */
+    virtual void setOcclusionFilterFunctionN (RTCFilterFuncN filterN) = 0;
+
+    /*! for instances only */
+  public:
+    
+    /*! Sets transformation of the instance */
+    virtual void setTransform(const AffineSpace3fa& transform, size_t timeStep) = 0;
+
+    /*! for user geometries only */
+  public:
+
+    /*! Set bounds function. */
+    virtual void setBoundsFunction (RTCBoundsFunc bounds) = 0;
+
+    /*! Set bounds function. */
+    virtual void setBoundsFunction2 (RTCBoundsFunc2 bounds, void* userPtr) = 0;
+
+    /*! Set bounds function. */
+    virtual void setBoundsFunction3 (RTCBoundsFunc3 bounds, void* userPtr) = 0;
+
+    /*! Set intersect function for single rays. */
+    virtual void setIntersectFunction (RTCIntersectFunc intersect, bool ispc = false) = 0;
+    
+    /*! Set intersect function for ray packets of size 4. */
+    virtual void setIntersectFunction4 (RTCIntersectFunc4 intersect4, bool ispc = false) = 0;
+    
+    /*! Set intersect function for ray packets of size 8. */
+    virtual void setIntersectFunction8 (RTCIntersectFunc8 intersect8, bool ispc = false) = 0;
+    
+    /*! Set intersect function for ray packets of size 16. */
+    virtual void setIntersectFunction16 (RTCIntersectFunc16 intersect16, bool ispc = false) = 0;
+
+    /*! Set intersect function for streams of single rays. */
+    virtual void setIntersectFunction1Mp (RTCIntersectFunc1Mp intersect) = 0;
+
+    /*! Set intersect function for ray packets of size N. */
+    virtual void setIntersectFunctionN (RTCIntersectFuncN intersect) = 0;
+    
+    /*! Set occlusion function for single rays. */
+    virtual void setOccludedFunction (RTCOccludedFunc occluded, bool ispc = false) = 0;
+    
+    /*! Set occlusion function for ray packets of size 4. */
+    virtual void setOccludedFunction4 (RTCOccludedFunc4 occluded4, bool ispc = false) = 0;
+    
+    /*! Set occlusion function for ray packets of size 8. */
+    virtual void setOccludedFunction8 (RTCOccludedFunc8 occluded8, bool ispc = false) = 0;
+    
+    /*! Set occlusion function for ray packets of size 16. */
+    virtual void setOccludedFunction16 (RTCOccludedFunc16 occluded16, bool ispc = false) = 0;
+
+    /*! Set occlusion function for streams of single rays. */
+    virtual void setOccludedFunction1Mp (RTCOccludedFunc1Mp occluded) = 0;
+
+    /*! Set occlusion function for ray packets of size N. */
+    virtual void setOccludedFunctionN (RTCOccludedFuncN occluded) = 0;
+  };
+
+namespace isa
 {
   class Scene;
 
   /*! Base class all geometries are derived from */
-  class Geometry
+  class Geometry : public GeometryInterface
   {
     friend class Scene;
   public:
@@ -128,11 +304,6 @@ namespace embree
 
     /*! Set user data pointer. */
     virtual void setUserData (void* ptr);
-      
-    /*! Get user data pointer. */
-    __forceinline void* getUserData() const {
-      return userPtr;
-    }
 
     /*! interpolates user data to the specified u/v location */
     virtual void interpolate(unsigned primID, float u, float v, RTCBufferType buffer, float* P, float* dPdu, float* dPdv, float* ddPdudu, float* ddPdvdv, float* ddPdudv, size_t numFloats) {
@@ -484,7 +655,6 @@ namespace embree
     RTCGeometryFlags flags;    //!< flags of geometry
     bool enabled;              //!< true if geometry is enabled
     bool modified;             //!< true if geometry is modified
-    void* userPtr;             //!< user pointer
     unsigned mask;             //!< for masking out geometry
     std::atomic<size_t> used;  //!< counts by how many enabled instances this geometry is used
     
@@ -551,3 +721,4 @@ namespace embree
     return vint<N>(itimef);
   }
 }
+}

kernels/common/hit.h

@@ -19,6 +19,8 @@
 #include "default.h"
 
 namespace embree
+{
+namespace isa
 {
   /* Hit structure for K hits */
   template<int K>
@@ -89,3 +91,4 @@ namespace embree
                 << "}";
   }
 }
+}

kernels/common/isa.h

@@ -18,17 +18,14 @@
 
 namespace embree
 {
+namespace isa
+{
 #define DEFINE_SYMBOL2(type,name)               \
   typedef type (*name##Func)();                 \
   name##Func name;
   
 #define DECLARE_SYMBOL2(type,name)                                       \
-  namespace sse2      { extern type name(); }                           \
-  namespace sse42     { extern type name(); }                           \
-  namespace avx       { extern type name(); }                           \
-  namespace avx2      { extern type name(); }                           \
-  namespace avx512knl { extern type name(); }                           \
-  namespace avx512skx { extern type name(); }                           \
+  extern type name();                                                   \
   void name##_error2() { throw_RTCError(RTC_UNKNOWN_ERROR,"internal error in ISA selection for " TOSTRING(name)); } \
   type name##_error() { return type(name##_error2); }                 \
   type name##_zero() { return type(nullptr); }
@@ -38,12 +35,7 @@ namespace embree
   symbol##Func symbol;
 
 #define DECLARE_BUILDER2(Accel,Mesh,Args,symbol)                         \
-  namespace sse2      { extern Builder* symbol(Accel* accel, Mesh* scene, Args args); } \
-  namespace sse42     { extern Builder* symbol(Accel* accel, Mesh* scene, Args args); } \
-  namespace avx       { extern Builder* symbol(Accel* accel, Mesh* scene, Args args); } \
-  namespace avx2      { extern Builder* symbol(Accel* accel, Mesh* scene, Args args); } \
-  namespace avx512knl { extern Builder* symbol(Accel* accel, Mesh* scene, Args args); } \
-  namespace avx512skx { extern Builder* symbol(Accel* accel, Mesh* scene, Args args); } \
+  extern Builder* symbol(Accel* accel, Mesh* scene, Args args);         \
   void symbol##_error() { throw_RTCError(RTC_UNSUPPORTED_CPU,"builder " TOSTRING(symbol) " not supported by your CPU"); } \
 
 #define ZERO_SYMBOL(features,intersector)                      \
@@ -53,7 +45,28 @@ namespace embree
   intersector = decltype(intersector)(intersector##_error);
 
 #define SELECT_SYMBOL_DEFAULT(features,intersector) \
-  intersector = isa::intersector;
+  intersector = embree::isa::intersector;
+
+#if defined(__SSE42__)
+#define SELECT_SYMBOL_SSE42(features,intersector) \
+  intersector = embree::isa::intersector;
+#else
+#define SELECT_SYMBOL_SSE42(features,intersector)
+#endif
+
+#if defined(__AVX__)
+#define SELECT_SYMBOL_AVX(features,intersector) \
+  intersector = embree::isa::intersector;
+#else
+#define SELECT_SYMBOL_AVX(features,intersector)
+#endif
+
+#if defined(__AVX512F__)
+#define SELECT_SYMBOL_AVX512(features,intersector) \
+  intersector = embree::isa::intersector;
+#else
+#define SELECT_SYMBOL_AVX512(features,intersector)
+#endif
 
 #if defined(__SSE__)
 #if !defined(__TARGET_SIMD4__)
@@ -61,126 +74,68 @@ namespace embree
 #endif
 #endif
 
-#if defined(__TARGET_SSE42__)
-#define SELECT_SYMBOL_SSE42(features,intersector) \
-  if ((features & SSE42) == SSE42) intersector = sse42::intersector;
-#else
-#define SELECT_SYMBOL_SSE42(features,intersector)
-#endif
-
 #if defined(__TARGET_AVX__)
 #if !defined(__TARGET_SIMD8__)
 #define __TARGET_SIMD8__
 #endif
-#define SELECT_SYMBOL_AVX(features,intersector) \
-  if ((features & AVX) == AVX) intersector = avx::intersector;
-#else
-#define SELECT_SYMBOL_AVX(features,intersector)
 #endif
 
 #if defined(__TARGET_AVX2__)
 #if !defined(__TARGET_SIMD8__)
 #define __TARGET_SIMD8__
 #endif
-#define SELECT_SYMBOL_AVX2(features,intersector) \
-  if ((features & AVX2) == AVX2) intersector = avx2::intersector;
-#else
-#define SELECT_SYMBOL_AVX2(features,intersector)
 #endif
 
 #if defined(__TARGET_AVX512KNL__)
 #if !defined(__TARGET_SIMD16__)
 #define __TARGET_SIMD16__
 #endif
-#define SELECT_SYMBOL_AVX512KNL(features,intersector) \
-  if ((features & AVX512KNL) == AVX512KNL) intersector = avx512knl::intersector;
-#else
-#define SELECT_SYMBOL_AVX512KNL(features,intersector)
 #endif
 
 #if defined(__TARGET_AVX512SKX__)
 #if !defined(__TARGET_SIMD16__)
 #define __TARGET_SIMD16__
 #endif
-#define SELECT_SYMBOL_AVX512SKX(features,intersector) \
-  if ((features & AVX512SKX) == AVX512SKX) intersector = avx512skx::intersector;
-#else
-#define SELECT_SYMBOL_AVX512SKX(features,intersector)
 #endif
 
 #define SELECT_SYMBOL_DEFAULT_SSE42(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);            \
-  SELECT_SYMBOL_SSE42(features,intersector);                                  
+  SELECT_SYMBOL_DEFAULT(features,intersector);
   
 #define SELECT_SYMBOL_DEFAULT_SSE42_AVX(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                \
-  SELECT_SYMBOL_SSE42(features,intersector);                  \
-  SELECT_SYMBOL_AVX(features,intersector);                        
+  SELECT_SYMBOL_DEFAULT(features,intersector);
   
 #define SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                     \
-  SELECT_SYMBOL_SSE42(features,intersector);                       \
-  SELECT_SYMBOL_AVX(features,intersector);                         \
-  SELECT_SYMBOL_AVX2(features,intersector);                       
+  SELECT_SYMBOL_DEFAULT(features,intersector);
 
 #define SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512SKX(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                          \
-  SELECT_SYMBOL_SSE42(features,intersector);                            \
-  SELECT_SYMBOL_AVX(features,intersector);                              \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_DEFAULT(features,intersector);
 
 #define SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512KNL_AVX512SKX(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                                   \
-  SELECT_SYMBOL_AVX(features,intersector);                                       \
-  SELECT_SYMBOL_AVX2(features,intersector);                                      \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);                                 \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_DEFAULT(features,intersector);
 
 #define SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512SKX(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                         \
-  SELECT_SYMBOL_AVX(features,intersector);                             \
-  SELECT_SYMBOL_AVX2(features,intersector);                            \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_DEFAULT(features,intersector);
 
 #define SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512KNL_AVX512SKX(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                                         \
-  SELECT_SYMBOL_SSE42(features,intersector);                                           \
-  SELECT_SYMBOL_AVX(features,intersector);                                             \
-  SELECT_SYMBOL_AVX2(features,intersector);                                            \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);                                       \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_DEFAULT(features,intersector);
 
 #define SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512SKX(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                               \
-  SELECT_SYMBOL_SSE42(features,intersector);                                 \
-  SELECT_SYMBOL_AVX(features,intersector);                                   \
-  SELECT_SYMBOL_AVX2(features,intersector);                                  \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
-  
+  SELECT_SYMBOL_DEFAULT(features,intersector);
+
 #define SELECT_SYMBOL_DEFAULT_AVX(features,intersector) \
   SELECT_SYMBOL_DEFAULT(features,intersector);          \
-  SELECT_SYMBOL_AVX(features,intersector);                        
   
 #define SELECT_SYMBOL_DEFAULT_AVX_AVX2(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);               \
-  SELECT_SYMBOL_AVX(features,intersector);                   \
-  SELECT_SYMBOL_AVX2(features,intersector);                       
+  SELECT_SYMBOL_DEFAULT(features,intersector);
   
 #define SELECT_SYMBOL_DEFAULT_AVX_AVX512KNL(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                    \
-  SELECT_SYMBOL_AVX(features,intersector);                        \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);
+  SELECT_SYMBOL_DEFAULT(features,intersector);
 
 #define SELECT_SYMBOL_DEFAULT_AVX_AVX512KNL_AVX512SKX(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                              \
-  SELECT_SYMBOL_AVX(features,intersector);                                  \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);                            \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_DEFAULT(features,intersector);
 
 #define SELECT_SYMBOL_DEFAULT_AVX_AVX512SKX(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                    \
-  SELECT_SYMBOL_AVX(features,intersector);                        \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_DEFAULT(features,intersector);
   
 #define SELECT_SYMBOL_INIT_AVX(features,intersector) \
   INIT_SYMBOL(features,intersector);                 \
@@ -188,88 +143,43 @@ namespace embree
   
 #define SELECT_SYMBOL_INIT_AVX_AVX2(features,intersector) \
   INIT_SYMBOL(features,intersector);                      \
-  SELECT_SYMBOL_AVX(features,intersector);                \
-  SELECT_SYMBOL_AVX2(features,intersector);
+  SELECT_SYMBOL_AVX(features,intersector);
 
 #define SELECT_SYMBOL_INIT_AVX_AVX2_AVX512SKX(features,intersector) \
   INIT_SYMBOL(features,intersector);                                \
-  SELECT_SYMBOL_AVX(features,intersector);                          \
-  SELECT_SYMBOL_AVX2(features,intersector);                         \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_AVX(features,intersector);
 
 #define SELECT_SYMBOL_INIT_SSE42_AVX_AVX2(features,intersector) \
   INIT_SYMBOL(features,intersector);                            \
-  SELECT_SYMBOL_SSE42(features,intersector);                    \
-  SELECT_SYMBOL_AVX(features,intersector);                      \
-  SELECT_SYMBOL_AVX2(features,intersector);
+  SELECT_SYMBOL_SSE42(features,intersector);
   
 #define SELECT_SYMBOL_INIT_AVX_AVX512KNL(features,intersector) \
   INIT_SYMBOL(features,intersector);                           \
-  SELECT_SYMBOL_AVX(features,intersector);                     \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);
+  SELECT_SYMBOL_AVX(features,intersector);
 
 #define SELECT_SYMBOL_INIT_AVX_AVX512KNL_AVX512SKX(features,intersector) \
   INIT_SYMBOL(features,intersector);                                     \
-  SELECT_SYMBOL_AVX(features,intersector);                               \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);                         \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_AVX(features,intersector);
 
 #define SELECT_SYMBOL_INIT_AVX_AVX2_AVX512KNL(features,intersector) \
   INIT_SYMBOL(features,intersector);                                \
-  SELECT_SYMBOL_AVX(features,intersector);                          \
-  SELECT_SYMBOL_AVX2(features,intersector);                         \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);
+  SELECT_SYMBOL_AVX(features,intersector);
 
 #define SELECT_SYMBOL_INIT_AVX_AVX2_AVX512KNL_AVX512SKX(features,intersector) \
   INIT_SYMBOL(features,intersector);                                          \
-  SELECT_SYMBOL_AVX(features,intersector);                                    \
-  SELECT_SYMBOL_AVX2(features,intersector);                                   \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);                              \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_AVX(features,intersector);
 
 #define SELECT_SYMBOL_INIT_SSE42_AVX_AVX2_AVX512KNL_AVX512SKX(features,intersector) \
   INIT_SYMBOL(features,intersector);                                                \
-  SELECT_SYMBOL_SSE42(features,intersector);                                        \
-  SELECT_SYMBOL_AVX(features,intersector);                                          \
-  SELECT_SYMBOL_AVX2(features,intersector);                                         \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);                                    \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_SSE42(features,intersector);
 
 #define SELECT_SYMBOL_ZERO_SSE42_AVX_AVX2_AVX512KNL_AVX512SKX(features,intersector) \
   ZERO_SYMBOL(features,intersector);                                    \
-  SELECT_SYMBOL_SSE42(features,intersector);                            \
-  SELECT_SYMBOL_AVX(features,intersector);                              \
-  SELECT_SYMBOL_AVX2(features,intersector);                             \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);                               \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
+  SELECT_SYMBOL_SSE42(features,intersector);
 
-#define SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512KNL_AVX512SKX(features,intersector) \
-  SELECT_SYMBOL_DEFAULT(features,intersector);                                   \
-  SELECT_SYMBOL_AVX(features,intersector);                                       \
-  SELECT_SYMBOL_AVX2(features,intersector);                                      \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);                                 \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
-  
 #define SELECT_SYMBOL_INIT_AVX512KNL_AVX512SKX(features,intersector) \
   INIT_SYMBOL(features,intersector);                                 \
-  SELECT_SYMBOL_AVX512KNL(features,intersector);                     \
-  SELECT_SYMBOL_AVX512SKX(features,intersector);
-  
-#define SELECT_SYMBOL_SSE42_AVX_AVX2(features,intersector) \
-  SELECT_SYMBOL_SSE42(features,intersector);               \
-  SELECT_SYMBOL_AVX(features,intersector);                 \
-  SELECT_SYMBOL_AVX2(features,intersector);
+  SELECT_SYMBOL_AVX512(features,intersector);
 
-  struct VerifyMultiTargetLinking {
-    static __noinline int getISA(int depth = 5) { 
-      if (depth == 0) return ISA; 
-      else return getISA(depth-1); 
-    }
-  };
-  namespace sse2      { int getISA(); };
-  namespace sse42     { int getISA(); };
-  namespace avx       { int getISA(); };
-  namespace avx2      { int getISA(); };
-  namespace avx512knl { int getISA(); };
-  namespace avx512skx { int getISA(); };
+}
 }

kernels/common/primref.h

@@ -20,6 +20,8 @@
 #include "scene_bezier_curves.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! A primitive reference stores the bounds of the primitive and its ID. */
   struct __aligned(32) PrimRef 
@@ -151,3 +153,4 @@ namespace embree
 #endif
   }
 }
+}

kernels/common/profile.h

@@ -19,6 +19,8 @@
 #include "default.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! helper structure for the implementation of the profile functions below */
   struct ProfileTimer
@@ -170,3 +172,5 @@ namespace embree
       timer.print(numElements);
     }
 }
+}
+

kernels/common/ray.h

@@ -21,6 +21,8 @@
 #define MAX_INTERNAL_STREAM_SIZE 64
 
 namespace embree
+{
+namespace isa
 {
   /* Ray structure for K rays */
   template<int K>
@@ -661,3 +663,4 @@ namespace embree
 
   };
 }
+}

kernels/common/rtcore.cpp

@@ -14,11 +14,12 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
-#ifdef _WIN32
+/*#ifdef _WIN32
 #  define RTCORE_API extern "C" __declspec(dllexport)
 #else
 #  define RTCORE_API extern "C" __attribute__ ((visibility ("default")))
-#endif
+#endif*/
+#define RTCORE_API
 
 #include "default.h"
 #include "device.h"
@@ -27,15 +28,25 @@
 #include "../../include/embree2/rtcore_ray.h"
 
 namespace embree
-{  
-  /* mutex to make API thread safe */
-  static MutexSys g_mutex;
+{
+  extern MutexSys g_api_mutex;
 
+  void setThreadErrorCode(RTCError error);
+  RTCError getThreadErrorCode();
+  void process_error(DeviceInterface* device, RTCError error, const char* str);
+
+namespace isa
+{
+  RTCORE_API DeviceInterface* createDevice(const State& state) {
+    return new Device(state);
+  }
+
+#if 0
   RTCORE_API RTCDevice rtcNewDevice(const char* cfg)
   {
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcNewDevice);
-    Lock<MutexSys> lock(g_mutex);
+    Lock<MutexSys> lock(g_api_mutex);
     return (RTCDevice) new Device(cfg,false);
     RTCORE_CATCH_END(nullptr);
     return (RTCDevice) nullptr;
@@ -46,7 +57,7 @@ namespace embree
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcDeleteDevice);
     RTCORE_VERIFY_HANDLE(device);
-    Lock<MutexSys> lock(g_mutex);
+    Lock<MutexSys> lock(g_api_mutex);
     delete (Device*) device;
     RTCORE_CATCH_END(nullptr);
   }
@@ -58,7 +69,7 @@ namespace embree
   {
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcInit);
-    Lock<MutexSys> lock(g_mutex);
+    Lock<MutexSys> lock(g_api_mutex);
     if (g_device) throw_RTCError(RTC_INVALID_OPERATION,"already initialized");
     g_device = new Device(cfg,true);
     RTCORE_CATCH_END(g_device);
@@ -68,7 +79,7 @@ namespace embree
   {
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcExit);
-    Lock<MutexSys> lock(g_mutex);
+    Lock<MutexSys> lock(g_api_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);
@@ -78,7 +89,7 @@ namespace embree
   {
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcSetParameter1i);
-    Lock<MutexSys> lock(g_mutex);
+    Lock<MutexSys> lock(g_api_mutex);
     if (g_device) g_device->setParameter1i(parm,val);
     RTCORE_CATCH_END(g_device);
   }
@@ -88,7 +99,7 @@ namespace embree
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcGetParameter1i);
     assert(g_device);
-    Lock<MutexSys> lock(g_mutex);
+    Lock<MutexSys> lock(g_api_mutex);
     return g_device->getParameter1i(parm);
     RTCORE_CATCH_END(g_device);
     return 0;
@@ -101,7 +112,7 @@ namespace embree
     RTCORE_TRACE(rtcDeviceSetParameter1i);
     const bool internal_parm = (size_t)parm >= 1000000 && (size_t)parm < 1000004;
     if (!internal_parm) RTCORE_VERIFY_HANDLE(hdevice); // allow NULL device for special internal settings
-    Lock<MutexSys> lock(g_mutex);
+    Lock<MutexSys> lock(g_api_mutex);
     device->setParameter1i(parm,val);
     RTCORE_CATCH_END(device);
   }
@@ -112,7 +123,7 @@ namespace embree
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcDeviceGetParameter1i);
     RTCORE_VERIFY_HANDLE(hdevice);
-    Lock<MutexSys> lock(g_mutex);
+    Lock<MutexSys> lock(g_api_mutex);
     return device->getParameter1i(parm);
     RTCORE_CATCH_END(device);
     return 0;
@@ -122,7 +133,7 @@ namespace embree
   {
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcGetError);
-    if (g_device == nullptr) return Device::getThreadErrorCode();
+    if (g_device == nullptr) return getThreadErrorCode();
     else                     return g_device->getDeviceErrorCode();
     RTCORE_CATCH_END(g_device);
     return RTC_UNKNOWN_ERROR;
@@ -133,7 +144,7 @@ namespace embree
     Device* device = (Device*) hdevice;
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcDeviceGetError);
-    if (device == nullptr) return Device::getThreadErrorCode();
+    if (device == nullptr) return getThreadErrorCode();
     else                   return device->getDeviceErrorCode();
     RTCORE_CATCH_END(device);
     return RTC_UNKNOWN_ERROR;
@@ -236,6 +247,7 @@ namespace embree
     RTCORE_CATCH_BEGIN;
     RTCORE_TRACE(rtcSetProgressMonitorFunction);
     RTCORE_VERIFY_HANDLE(hscene);
+    Lock<MutexSys> lock(g_api_mutex);
     scene->setProgressMonitorFunction(func,ptr);
     RTCORE_CATCH_END(scene->device);
   }
@@ -1814,4 +1826,6 @@ namespace embree
     RTCORE_CATCH_END(scene->device);
   }
 #endif
+#endif
+}
 }

kernels/common/rtcore.h

@@ -20,6 +20,8 @@
 
 namespace embree
 {
+//namespace isa
+//{
   /*! decoding of geometry flags */
   __forceinline bool isStatic    (RTCSceneFlags flags) { return (flags & 1) == RTC_SCENE_STATIC; }
   __forceinline bool isDynamic   (RTCSceneFlags flags) { return (flags & 1) == RTC_SCENE_DYNAMIC; }
@@ -52,13 +54,13 @@ namespace embree
 #define RTCORE_CATCH_BEGIN try {
 #define RTCORE_CATCH_END(device)                                        \
   } catch (std::bad_alloc&) {                                            \
-    Device::process_error(device,RTC_OUT_OF_MEMORY,"out of memory");    \
+    process_error(device,RTC_OUT_OF_MEMORY,"out of memory");    \
   } catch (rtcore_error& e) {                                           \
-    Device::process_error(device,e.error,e.what());                     \
+    process_error(device,e.error,e.what());                     \
   } catch (std::exception& e) {                                         \
-    Device::process_error(device,RTC_UNKNOWN_ERROR,e.what()); \
+    process_error(device,RTC_UNKNOWN_ERROR,e.what()); \
   } catch (...) {                                                       \
-    Device::process_error(device,RTC_UNKNOWN_ERROR,"unknown exception caught"); \
+    process_error(device,RTC_UNKNOWN_ERROR,"unknown exception caught"); \
   }
 
 #define RTCORE_VERIFY_HANDLE(handle)                                    \
@@ -103,4 +105,40 @@ namespace embree
 
 #define RTC_BUILD_SETTINGS_HAS(settings,member)                 \
   (settings.size > (offsetof(RTCBuildSettings,member)+sizeof(settings.member))) 
+
+  struct ErrorHandler
+  {
+  public:
+    ErrorHandler()
+      : thread_error(createTls()) {}
+
+    ~ErrorHandler()
+    {
+      Lock<MutexSys> lock(errors_mutex);
+      for (size_t i=0; i<thread_errors.size(); i++)
+        delete thread_errors[i];
+      destroyTls(thread_error);
+      thread_errors.clear();
+    }
+
+    RTCError* error()
+    {
+      RTCError* stored_error = (RTCError*) getTls(thread_error);
+      if (stored_error) return stored_error;
+      
+      Lock<MutexSys> lock(errors_mutex);
+      stored_error = new RTCError(RTC_NO_ERROR);
+      thread_errors.push_back(stored_error);
+      setTls(thread_error,stored_error);
+      return stored_error;
+    }
+    
+  public:
+    tls_t thread_error;
+    std::vector<RTCError*> thread_errors;
+    MutexSys errors_mutex;
+  };
+
+
+//}
 }

kernels/common/rtcore_builder.cpp

@@ -31,6 +31,8 @@
 
 namespace embree
 { 
+  void process_error(DeviceInterface* device, RTCError error, const char* str);
+
   namespace isa // FIXME: support more ISAs for builders
   {
     struct BVH

kernels/common/rtcore_ispc.cpp

@@ -28,6 +28,10 @@
 #endif
 
 namespace embree
+{
+  void process_error(DeviceInterface* device, RTCError error, const char* str);
+
+namespace isa
 {
 #define size_t int   // FIXME: workaround for ISPC bug (ISPC bug still present in ISPC v1.8.2)
 #define ssize_t int  // FIXME: workaround for ISPC bug (ISPC bug still present in ISPC v1.8.2) 
@@ -631,3 +635,4 @@ namespace embree
     rtcInterpolateN2(scene,geomID,valid,primIDs,u,v,numUVs,buffer,P,dPdu,dPdv,ddPdudu,ddPdvdv,ddPdudv,numFloats);
   }
 }
+}

kernels/common/rtcore_main.cpp

@@ -0,0 +1,275 @@
+// ======================================================================== //
+// Copyright 2009-2017 Intel Corporation                                    //
+//                                                                          //
+// Licensed under the Apache License, Version 2.0 (the "License");          //
+// you may not use this file except in compliance with the License.         //
+// You may obtain a copy of the License at                                  //
+//                                                                          //
+//     http://www.apache.org/licenses/LICENSE-2.0                           //
+//                                                                          //
+// Unless required by applicable law or agreed to in writing, software      //
+// distributed under the License is distributed on an "AS IS" BASIS,        //
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. //
+// See the License for the specific language governing permissions and      //
+// limitations under the License.                                           //
+// ======================================================================== //
+
+#ifdef _WIN32
+#  define RTCORE_API extern "C" __declspec(dllexport)
+#else
+#  define RTCORE_API extern "C" __attribute__ ((visibility ("default")))
+#endif
+
+#include "default.h"
+#include "device.h"
+#include "scene.h"
+#include "context.h"
+#include "../../include/embree2/rtcore_ray.h"
+
+
+#define NARGS(...) NARGS_(__VA_ARGS__,RSEQ())
+#define NARGS_(...) ARGS_N(__VA_ARGS__)
+#define ARGS_N(\
+  _1, _2, _3, _4, _5, _6, _7, _8, _9,_10,           \
+  _11,_12,_13,_14,_15,_16,_17,_18,_19,_20,        \
+  _21,_22,_23,_24,_25,_26,_27,_28,_29,_30,        \
+  _31,_32,_33,_34,_35,_36,_37,_38,_39,_40,        \
+  _41,_42,_43,_44,_45,_46,_47,_48,_49,_50,        \
+  _51,_52,_53,_54,_55,_56,_57,_58,_59,_60,        \
+  _61,_62,_63,N,...) N
+#define RSEQ() \
+  63,62,61,60,                          \
+  59,58,57,56,55,54,53,52,51,50,      \
+  49,48,47,46,45,44,43,42,41,40,      \
+  39,38,37,36,35,34,33,32,31,30,      \
+  29,28,27,26,25,24,23,22,21,20,      \
+  19,18,17,16,15,14,13,12,11,10,      \
+  9,8,7,6,5,4,3,2,1,0
+
+#define CALL1(first,...)
+#define CALL2(first,second,...) second
+#define CALL4(first,second,...) second, CALL2(__VA_ARGS__)
+#define CALL6(first,second,...) second, CALL4(__VA_ARGS__)
+#define CALL8(first,second,...) second, CALL6(__VA_ARGS__)
+#define CALL10(first,second,...) second, CALL8(__VA_ARGS__)
+#define CALL12(first,second,...) second, CALL10(__VA_ARGS__)
+#define CALL14(first,second,...) second, CALL12(__VA_ARGS__)
+#define CALL16(first,second,...) second, CALL14(__VA_ARGS__)
+#define CALL18(first,second,...) second, CALL16(__VA_ARGS__)
+#define CALL20(first,second,...) second, CALL18(__VA_ARGS__)
+#define CALL22(first,second,...) second, CALL20(__VA_ARGS__)
+#define CALL24(first,second,...) second, CALL22(__VA_ARGS__)
+#define CALL26(first,second,...) second, CALL24(__VA_ARGS__)
+#define CALL28(first,second,...) second, CALL26(__VA_ARGS__)
+#define CALL30(first,second,...) second, CALL28(__VA_ARGS__)
+#define CALL__(N,...) CALL##N(__VA_ARGS__,__end__)
+#define CALL_(N,...) CALL__(N,__VA_ARGS__)
+#define CALL(...) CALL_(NARGS(__VA_ARGS__),__VA_ARGS__)
+
+#define PAIRS1(first,...)
+#define PAIRS2(first,second,...) first second
+#define PAIRS4(first,second,...) first second, PAIRS2(__VA_ARGS__)
+#define PAIRS6(first,second,...) first second, PAIRS4(__VA_ARGS__)
+#define PAIRS8(first,second,...) first second, PAIRS6(__VA_ARGS__)
+#define PAIRS10(first,second,...) first second, PAIRS8(__VA_ARGS__)
+#define PAIRS12(first,second,...) first second, PAIRS10(__VA_ARGS__)
+#define PAIRS14(first,second,...) first second, PAIRS12(__VA_ARGS__)
+#define PAIRS16(first,second,...) first second, PAIRS14(__VA_ARGS__)
+#define PAIRS18(first,second,...) first second, PAIRS16(__VA_ARGS__)
+#define PAIRS20(first,second,...) first second, PAIRS18(__VA_ARGS__)
+#define PAIRS22(first,second,...) first second, PAIRS20(__VA_ARGS__)
+#define PAIRS24(first,second,...) first second, PAIRS22(__VA_ARGS__)
+#define PAIRS26(first,second,...) first second, PAIRS24(__VA_ARGS__)
+#define PAIRS28(first,second,...) first second, PAIRS26(__VA_ARGS__)
+#define PAIRS30(first,second,...) first second, PAIRS28(__VA_ARGS__)
+#define PAIRS__(N,...) PAIRS##N(__VA_ARGS__,__end__)
+#define PAIRS_(N,...) PAIRS__(N,__VA_ARGS__)
+#define PAIRS(...) PAIRS_(NARGS(__VA_ARGS__),__VA_ARGS__)
+
+#if defined(__TARGET_SSE2__)
+#define SELECT_SSE2(f,name) if (hasISA(SSE2)) f = &sse2::name;
+#else
+#define SELECT_SSE2(f,name)
+#endif
+
+#if defined(__TARGET_SSE42__)
+#define SELECT_SSE42(f,name) if (hasISA(SSE42)) f = &sse42::name;
+#else
+#define SELECT_SSE42(f,name)
+#endif
+
+#if defined(__TARGET_AVX__)
+#define SELECT_AVX(f,name) if (hasISA(AVX)) f = &avx::name;
+#else
+#define SELECT_AVX(f,name)
+#endif
+
+#if defined(__TARGET_AVX2__)
+#define SELECT_AVX2(f,name) if (hasISA(AVX2)) f = &avx2::name;
+#else
+#define SELECT_AVX2(f,name)
+#endif
+
+#if defined(__TARGET_AVX512KNL__)
+#define SELECT_AVX512KNL(f,name) if (hasISA(AVX512KNL)) f = &avx512knl::name;
+#else
+#define SELECT_AVX512KNL(f,name)
+#endif
+
+#if defined(__TARGET_AVX512SKX__)
+#define SELECT_AVX512SKX(f,name) if (hasISA(AVX512SKX)) f = &avx512skx::name;
+#else
+#define SELECT_AVX512SKX(f,name)
+#endif
+
+#define DECLARE_SYMBOL(dty,name,...)                               \
+  namespace sse2      { extern dty name(PAIRS(__VA_ARGS__)); }          \
+  namespace sse41     { extern dty name(PAIRS(__VA_ARGS__)); }          \
+  namespace sse42     { extern dty name(PAIRS(__VA_ARGS__)); }          \
+  namespace avx       { extern dty name(PAIRS(__VA_ARGS__)); }          \
+  namespace avx2      { extern dty name(PAIRS(__VA_ARGS__)); }          \
+  namespace avx512knl { extern dty name(PAIRS(__VA_ARGS__)); }          \
+  namespace avx512skx { extern dty name(PAIRS(__VA_ARGS__)); }          \
+  extern dty (*selected_##name) (PAIRS(__VA_ARGS__));                     \
+  dty select_##name(PAIRS(__VA_ARGS__)) {                               \
+    SELECT_SSE2(selected_##name,name)                                   \
+    SELECT_SSE42(selected_##name,name)                                \
+    SELECT_AVX(selected_##name,name)                                  \
+    SELECT_AVX2(selected_##name,name)                                   \
+    SELECT_AVX512KNL(selected_##name,name)                                 \
+    SELECT_AVX512SKX(selected_##name,name)                            \
+    return selected_##name(CALL(__VA_ARGS__));                          \
+  }                                                                     \
+  dty (*selected_##name) (PAIRS(__VA_ARGS__)) = &select_##name;
+
+#define FORWARD_FUNCTION(dty,name,...)                   \
+  DECLARE_SYMBOL(dty,name,__VA_ARGS__)                             \
+  RTCORE_API dty name(PAIRS(__VA_ARGS__)) {                             \
+    return selected_##name(CALL(__VA_ARGS__));                          \
+  }
+
+namespace embree
+{  
+  __forceinline bool hasISA(int _isa) {
+    return (getCPUFeatures() & _isa) == _isa;
+  }
+
+  FORWARD_FUNCTION(RTCDevice,rtcNewDevice,const char*,cfg);
+  FORWARD_FUNCTION(void,rtcDeleteDevice,RTCDevice,device);
+  FORWARD_FUNCTION(void,rtcInit,const char*,cfg);
+  FORWARD_FUNCTION(void,rtcExit,void);
+  FORWARD_FUNCTION(void,rtcSetParameter1i,const RTCParameter,parm,ssize_t,val);
+  FORWARD_FUNCTION(ssize_t,rtcGetParameter1i,const RTCParameter,parm);
+  FORWARD_FUNCTION(void,rtcDeviceSetParameter1i,RTCDevice,hdevice,const RTCParameter,parm,ssize_t,val);
+  FORWARD_FUNCTION(ssize_t,rtcDeviceGetParameter1i,RTCDevice,hdevice,const RTCParameter,parm);
+  FORWARD_FUNCTION(RTCError,rtcGetError,void);
+  FORWARD_FUNCTION(RTCError,rtcDeviceGetError,RTCDevice,hdevice);
+  FORWARD_FUNCTION(void,rtcSetErrorFunction,RTCErrorFunc,func);
+  FORWARD_FUNCTION(void,rtcDeviceSetErrorFunction,RTCDevice,hdevice,RTCErrorFunc,func);
+  FORWARD_FUNCTION(void,rtcDeviceSetErrorFunction2,RTCDevice,hdevice,RTCErrorFunc2,func,void*,userPtr);
+  FORWARD_FUNCTION(void,rtcSetMemoryMonitorFunction,RTCMemoryMonitorFunc,func);
+  FORWARD_FUNCTION(void,rtcDeviceSetMemoryMonitorFunction,RTCDevice,hdevice,RTCMemoryMonitorFunc,func);
+  FORWARD_FUNCTION(void,rtcDeviceSetMemoryMonitorFunction2,RTCDevice,hdevice,RTCMemoryMonitorFunc2,func,void*,userPtr);
+  FORWARD_FUNCTION(void,rtcDebug,void);
+  FORWARD_FUNCTION(RTCScene,rtcNewScene,RTCSceneFlags,flags,RTCAlgorithmFlags,aflags);
+  FORWARD_FUNCTION(RTCScene,rtcDeviceNewScene,RTCDevice,device,RTCSceneFlags,flags,RTCAlgorithmFlags,aflags);
+  FORWARD_FUNCTION(void,rtcSetProgressMonitorFunction,RTCScene,hscene,RTCProgressMonitorFunc,func,void*,ptr);
+  FORWARD_FUNCTION(void,rtcCommit,RTCScene,hscene);
+  FORWARD_FUNCTION(void,rtcCommitJoin,RTCScene,hscene);
+  FORWARD_FUNCTION(void,rtcCommitThread,RTCScene,hscene,unsigned int,threadID,unsigned int,numThreads);
+  FORWARD_FUNCTION(void,rtcGetBounds,RTCScene,hscene,RTCBounds&,bounds_o);
+  FORWARD_FUNCTION(void,rtcGetLinearBounds,RTCScene,hscene,RTCBounds*,bounds_o);
+  FORWARD_FUNCTION(void,rtcIntersect,RTCScene,hscene,RTCRay&,ray);
+  FORWARD_FUNCTION(void,rtcIntersect1Ex,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay&,ray);
+  FORWARD_FUNCTION(void,rtcIntersect4,const void*,valid,RTCScene,hscene,RTCRay4&,ray);
+  FORWARD_FUNCTION(void,rtcIntersect4Ex,const void*,valid,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay4&,ray);
+  FORWARD_FUNCTION(void,rtcIntersect8,const void*,valid,RTCScene,hscene,RTCRay8&,ray);
+  FORWARD_FUNCTION(void,rtcIntersect8Ex,const void*,valid,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay8&,ray);
+  FORWARD_FUNCTION(void,rtcIntersect16,const void*,valid,RTCScene,hscene,RTCRay16&,ray);
+  FORWARD_FUNCTION(void,rtcIntersect16Ex,const void*,valid,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay16&,ray);
+  FORWARD_FUNCTION(void,rtcIntersect1M,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay*,rays,const size_t,M,const size_t,stride);
+  FORWARD_FUNCTION(void,rtcIntersect1Mp,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay**,rays,const size_t,M);
+  FORWARD_FUNCTION(void,rtcIntersectNM,RTCScene,hscene,const RTCIntersectContext*,user_context,struct RTCRayN*,rays,const size_t,N,const size_t,M,const size_t,stride);
+  FORWARD_FUNCTION(void,rtcIntersectNp,RTCScene,hscene,const RTCIntersectContext*,user_context,const RTCRayNp&,rays,const size_t,N);
+  FORWARD_FUNCTION(void,rtcOccluded,RTCScene,hscene,RTCRay&,ray);
+  FORWARD_FUNCTION(void,rtcOccluded1Ex,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay&,ray);
+  FORWARD_FUNCTION(void,rtcOccluded4,const void*,valid,RTCScene,hscene,RTCRay4&,ray);
+  FORWARD_FUNCTION(void,rtcOccluded4Ex,const void*,valid,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay4&,ray);
+  FORWARD_FUNCTION(void,rtcOccluded8,const void*,valid,RTCScene,hscene,RTCRay8&,ray);
+  FORWARD_FUNCTION(void,rtcOccluded8Ex,const void*,valid,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay8&,ray);
+  FORWARD_FUNCTION(void,rtcOccluded16,const void*,valid,RTCScene,hscene,RTCRay16&,ray);
+  FORWARD_FUNCTION(void,rtcOccluded16Ex,const void*,valid,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay16&,ray);
+  FORWARD_FUNCTION(void,rtcOccluded1M,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay*,rays,const size_t,M,const size_t,stride);
+  FORWARD_FUNCTION(void,rtcOccluded1Mp,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRay**,rays,const size_t,M);
+  FORWARD_FUNCTION(void,rtcOccludedNM,RTCScene,hscene,const RTCIntersectContext*,user_context,RTCRayN*,rays,const size_t,N,const size_t,M,const size_t,stride);
+  FORWARD_FUNCTION(void,rtcOccludedNp,RTCScene,hscene,const RTCIntersectContext*,user_context,const RTCRayNp&,rays,const size_t,N);
+  FORWARD_FUNCTION(void,rtcDeleteScene,RTCScene,hscene);
+  FORWARD_FUNCTION(unsigned,rtcNewInstance,RTCScene,htarget,RTCScene,hsource);
+  FORWARD_FUNCTION(unsigned,rtcNewInstance2,RTCScene,htarget,RTCScene,hsource,size_t,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewGeometryInstance,RTCScene,hscene,unsigned,geomID);
+  FORWARD_FUNCTION(unsigned,rtcNewGeometryGroup,RTCScene,hscene,RTCGeometryFlags,flags,unsigned*,geomIDs,size_t,N);
+  FORWARD_FUNCTION(void,rtcSetTransform,RTCScene,hscene,unsigned,geomID,RTCMatrixType,layout,const float*,xfm);
+  FORWARD_FUNCTION(void,rtcSetTransform2,RTCScene,hscene,unsigned,geomID,RTCMatrixType,layout,const float*,xfm,size_t,timeStep);
+  FORWARD_FUNCTION(unsigned,rtcNewUserGeometry,RTCScene,hscene,size_t,numItems);
+  FORWARD_FUNCTION(unsigned,rtcNewUserGeometry2,RTCScene,hscene,size_t,numItems,size_t,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewUserGeometry3,RTCScene,hscene,RTCGeometryFlags,gflags,size_t,numItems,size_t,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewTriangleMesh,RTCScene,hscene,RTCGeometryFlags,flags,size_t,numTriangles,size_t,numVertices,size_t,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewQuadMesh,RTCScene,hscene,RTCGeometryFlags,flags,size_t,numQuads,size_t,numVertices,size_t,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewHairGeometry,RTCScene,hscene,RTCGeometryFlags,flags,size_t,numCurves,size_t,numVertices,size_t,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewBezierHairGeometry,RTCScene,hscene,RTCGeometryFlags,flags,unsigned int,numCurves,unsigned int,numVertices,unsigned int,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewBSplineHairGeometry,RTCScene,hscene,RTCGeometryFlags,flags,unsigned int,numCurves,unsigned int,numVertices,unsigned int,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewCurveGeometry,RTCScene,hscene,RTCGeometryFlags,flags,size_t,numCurves,size_t,numVertices,size_t,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewBezierCurveGeometry,RTCScene,hscene,RTCGeometryFlags,flags,unsigned int,numCurves,unsigned int,numVertices,unsigned int,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewBSplineCurveGeometry,RTCScene,hscene,RTCGeometryFlags,flags,unsigned int,numCurves,unsigned int,numVertices,unsigned int,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewLineSegments,RTCScene,hscene,RTCGeometryFlags,flags,size_t,numSegments,size_t,numVertices,size_t,numTimeSteps);
+  FORWARD_FUNCTION(unsigned,rtcNewSubdivisionMesh,RTCScene,hscene,RTCGeometryFlags,flags,size_t,numFaces,size_t,numEdges,size_t,numVertices,size_t,numEdgeCreases,size_t,numVertexCreases,size_t,numHoles,size_t,numTimeSteps);
+  FORWARD_FUNCTION(void,rtcSetMask,RTCScene,hscene,unsigned,geomID,int,mask);
+  FORWARD_FUNCTION(void,rtcSetBoundaryMode,RTCScene,hscene,unsigned,geomID,RTCBoundaryMode,mode);
+  FORWARD_FUNCTION(void,rtcSetSubdivisionMode,RTCScene,hscene,unsigned,geomID,unsigned,topologyID,RTCSubdivisionMode,mode);
+  FORWARD_FUNCTION(void,rtcSetIndexBuffer,RTCScene,hscene,unsigned,geomID,RTCBufferType,vertexBuffer,RTCBufferType,indexBuffer);
+  FORWARD_FUNCTION(void*,rtcMapBuffer,RTCScene,hscene,unsigned,geomID,RTCBufferType,type);
+  FORWARD_FUNCTION(void,rtcUnmapBuffer,RTCScene,hscene,unsigned,geomID,RTCBufferType,type);
+  FORWARD_FUNCTION(void,rtcSetBuffer,RTCScene,hscene,unsigned,geomID,RTCBufferType,type,const void*,ptr,size_t,offset,size_t,stride);
+  FORWARD_FUNCTION(void,rtcSetBuffer2,RTCScene,hscene,unsigned,geomID,RTCBufferType,type,const void*,ptr,size_t,offset,size_t,stride,size_t,size);
+  FORWARD_FUNCTION(void,rtcEnable,RTCScene,hscene,unsigned,geomID);
+  FORWARD_FUNCTION(void,rtcUpdate,RTCScene,hscene,unsigned,geomID);
+  FORWARD_FUNCTION(void,rtcUpdateBuffer,RTCScene,hscene,unsigned,geomID,RTCBufferType,type);
+  FORWARD_FUNCTION(void,rtcDisable,RTCScene,hscene,unsigned,geomID);
+  FORWARD_FUNCTION(void,rtcDeleteGeometry,RTCScene,hscene,unsigned,geomID);
+  FORWARD_FUNCTION(void,rtcSetTessellationRate,RTCScene,hscene,unsigned,geomID,float,tessellationRate);
+  FORWARD_FUNCTION(void,rtcSetUserData,RTCScene,hscene,unsigned,geomID,void*,ptr);
+  FORWARD_FUNCTION(void*,rtcGetUserData,RTCScene,hscene,unsigned,geomID);
+  FORWARD_FUNCTION(void,rtcSetBoundsFunction,RTCScene,hscene,unsigned,geomID,RTCBoundsFunc,bounds);
+  FORWARD_FUNCTION(void,rtcSetBoundsFunction2,RTCScene,hscene,unsigned,geomID,RTCBoundsFunc2,bounds,void*,userPtr);
+  FORWARD_FUNCTION(void,rtcSetBoundsFunction3,RTCScene,hscene,unsigned,geomID,RTCBoundsFunc3,bounds,void*,userPtr);
+  FORWARD_FUNCTION(void,rtcSetDisplacementFunction,RTCScene,hscene,unsigned,geomID,RTCDisplacementFunc,func,RTCBounds*,bounds);
+  FORWARD_FUNCTION(void,rtcSetDisplacementFunction2,RTCScene,hscene,unsigned,geomID,RTCDisplacementFunc2,func,RTCBounds*,bounds);
+  FORWARD_FUNCTION(void,rtcSetIntersectFunction,RTCScene,hscene,unsigned,geomID,RTCIntersectFunc,intersect);
+  FORWARD_FUNCTION(void,rtcSetIntersectFunction4,RTCScene,hscene,unsigned,geomID,RTCIntersectFunc4,intersect4);
+  FORWARD_FUNCTION(void,rtcSetIntersectFunction8,RTCScene,hscene,unsigned,geomID,RTCIntersectFunc8,intersect8);
+  FORWARD_FUNCTION(void,rtcSetIntersectFunction16,RTCScene,hscene,unsigned,geomID,RTCIntersectFunc16,intersect16);
+  FORWARD_FUNCTION(void,rtcSetIntersectFunction1Mp,RTCScene,hscene,unsigned,geomID,RTCIntersectFunc1Mp,intersect);
+  FORWARD_FUNCTION(void,rtcSetIntersectFunctionN,RTCScene,hscene,unsigned,geomID,RTCIntersectFuncN,intersect);
+  FORWARD_FUNCTION(void,rtcSetOccludedFunction,RTCScene,hscene,unsigned,geomID,RTCOccludedFunc,occluded);
+  FORWARD_FUNCTION(void,rtcSetOccludedFunction4,RTCScene,hscene,unsigned,geomID,RTCOccludedFunc4,occluded4);
+  FORWARD_FUNCTION(void,rtcSetOccludedFunction8,RTCScene,hscene,unsigned,geomID,RTCOccludedFunc8,occluded8);
+  FORWARD_FUNCTION(void,rtcSetOccludedFunction16,RTCScene,hscene,unsigned,geomID,RTCOccludedFunc16,occluded16);
+  FORWARD_FUNCTION(void,rtcSetOccludedFunction1Mp,RTCScene,hscene,unsigned,geomID,RTCOccludedFunc1Mp,occluded);
+  FORWARD_FUNCTION(void,rtcSetOccludedFunctionN,RTCScene,hscene,unsigned,geomID,RTCOccludedFuncN,occluded);
+  FORWARD_FUNCTION(void,rtcSetIntersectionFilterFunction,RTCScene,hscene,unsigned,geomID,RTCFilterFunc,intersect);
+  FORWARD_FUNCTION(void,rtcSetIntersectionFilterFunction4,RTCScene,hscene,unsigned,geomID,RTCFilterFunc4,filter4);
+  FORWARD_FUNCTION(void,rtcSetIntersectionFilterFunction8,RTCScene,hscene,unsigned,geomID,RTCFilterFunc8,filter8);
+  FORWARD_FUNCTION(void,rtcSetIntersectionFilterFunction16,RTCScene,hscene,unsigned,geomID,RTCFilterFunc16,filter16);
+  FORWARD_FUNCTION(void,rtcSetIntersectionFilterFunctionN,RTCScene,hscene,unsigned,geomID,RTCFilterFuncN,filterN);
+  FORWARD_FUNCTION(void,rtcSetOcclusionFilterFunction,RTCScene,hscene,unsigned,geomID,RTCFilterFunc,intersect);
+  FORWARD_FUNCTION(void,rtcSetOcclusionFilterFunction4,RTCScene,hscene,unsigned,geomID,RTCFilterFunc4,filter4);
+  FORWARD_FUNCTION(void,rtcSetOcclusionFilterFunction8,RTCScene,hscene,unsigned,geomID,RTCFilterFunc8,filter8);
+  FORWARD_FUNCTION(void,rtcSetOcclusionFilterFunction16,RTCScene,hscene,unsigned,geomID,RTCFilterFunc16,filter16);
+  FORWARD_FUNCTION(void,rtcSetOcclusionFilterFunctionN,RTCScene,hscene,unsigned,geomID,RTCFilterFuncN,filterN);
+  FORWARD_FUNCTION(void,rtcInterpolate,RTCScene,hscene,unsigned,geomID,unsigned,primID,float,u,float,v,RTCBufferType,buffer,float*,P,float*,dPdu,float*,dPdv,size_t,numFloats);
+  FORWARD_FUNCTION(void,rtcInterpolate2,RTCScene,hscene,unsigned,geomID,unsigned,primID,float,u,float,v,RTCBufferType,buffer,float*,P,float*,dPdu,float*,dPdv,float*,ddPdudu,float*,ddPdvdv,float*,ddPdudv,size_t,numFloats);
+#if defined(EMBREE_RAY_PACKETS)
+  FORWARD_FUNCTION(void,rtcInterpolateN,RTCScene,hscene,unsigned,geomID,const void*,valid_i,const unsigned*,primIDs,const float*,u,const float*,v,size_t,numUVs,RTCBufferType,buffer,float*,P,float*,dPdu,float*,dPdv,size_t,numFloats);
+  FORWARD_FUNCTION(void,rtcInterpolateN2,RTCScene,hscene,unsigned,geomID,const void*,valid_i,const unsigned*,primIDs,const float*,u,const float*,v,size_t,numUVs,RTCBufferType,buffer,float*,P,float*,dPdu,float*,dPdv,float*,ddPdudu,float*,ddPdvdv,float*,ddPdudv,size_t,numFloats);
+#endif
+}

kernels/common/scene.cpp

@@ -15,11 +15,14 @@
 // ======================================================================== //
 
 #include "scene.h"
+#include "../../include/embree2/rtcore_ray.h"
 
 #include "../bvh/bvh4_factory.h"
 #include "../bvh/bvh8_factory.h"
  
 namespace embree
+{
+namespace isa
 {
   /* error raising rtcIntersect and rtcOccluded functions */
   void missing_rtcCommit()      { throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed"); }
@@ -99,7 +102,7 @@ namespace embree
         int mode =  2*(int)isCompact() + 1*(int)isRobust(); 
         switch (mode) {
         case /*0b00*/ 0: 
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
           if (device->hasISA(AVX))
 	  {
             if (isHighQuality()) 
@@ -118,7 +121,7 @@ namespace embree
           break;
 
         case /*0b01*/ 1: 
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
           if (device->hasISA(AVX)) 
             accels.add(device->bvh8_factory->BVH8Triangle4v(this,BVH8Factory::BuildVariant::STATIC,BVH8Factory::IntersectVariant::ROBUST)); 
           else
@@ -127,7 +130,7 @@ namespace embree
 
           break;
         case /*0b10*/ 2: 
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
           if (device->hasISA(AVX)) 
             accels.add(device->bvh8_factory->BVH8Triangle4i(this,BVH8Factory::BuildVariant::STATIC,BVH8Factory::IntersectVariant::FAST  )); 
           else
@@ -135,7 +138,7 @@ namespace embree
             accels.add(device->bvh4_factory->BVH4Triangle4i(this,BVH4Factory::BuildVariant::STATIC,BVH4Factory::IntersectVariant::FAST  )); 
           break;
         case /*0b11*/ 3: 
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
           if (device->hasISA(AVX)) 
             accels.add(device->bvh8_factory->BVH8Triangle4i(this,BVH8Factory::BuildVariant::STATIC,BVH8Factory::IntersectVariant::ROBUST)); 
           else
@@ -146,7 +149,7 @@ namespace embree
       }
       else /* dynamic */
       {
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
           if (device->hasISA(AVX))
 	  {
             int mode =  2*(int)isCompact() + 1*(int)isRobust();
@@ -175,7 +178,7 @@ namespace embree
     else if (device->tri_accel == "bvh4.triangle4i")      accels.add(device->bvh4_factory->BVH4Triangle4i(this));
     else if (device->tri_accel == "qbvh4.triangle4i")     accels.add(device->bvh4_factory->BVH4QuantizedTriangle4i(this));
 
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
     else if (device->tri_accel == "bvh8.triangle4")       accels.add(device->bvh8_factory->BVH8Triangle4 (this));
     else if (device->tri_accel == "bvh8.triangle4i")      accels.add(device->bvh8_factory->BVH8Triangle4i(this));
     else if (device->tri_accel == "qbvh8.triangle4i")     accels.add(device->bvh8_factory->BVH8QuantizedTriangle4i(this));
@@ -191,7 +194,7 @@ namespace embree
     {
       int mode =  2*(int)isCompact() + 1*(int)isRobust(); 
       
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
       if (device->hasISA(AVX2)) // BVH8 reduces performance on AVX only-machines
       {
         switch (mode) {
@@ -214,7 +217,7 @@ namespace embree
     }
     else if (device->tri_accel_mb == "bvh4.triangle4vmb") accels.add(device->bvh4_factory->BVH4Triangle4vMB(this));
     else if (device->tri_accel_mb == "bvh4.triangle4imb") accels.add(device->bvh4_factory->BVH4Triangle4iMB(this));
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
     else if (device->tri_accel_mb == "bvh8.triangle4vmb") accels.add(device->bvh8_factory->BVH8Triangle4vMB(this));
     else if (device->tri_accel_mb == "bvh8.triangle4imb") accels.add(device->bvh8_factory->BVH8Triangle4iMB(this));
 #endif
@@ -233,7 +236,7 @@ namespace embree
         int mode =  2*(int)isCompact() + 1*(int)isRobust(); 
         switch (mode) {
         case /*0b00*/ 0:
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
           if (device->hasISA(AVX))
           {
             if (isHighQuality()) 
@@ -252,7 +255,7 @@ namespace embree
           break;
 
         case /*0b01*/ 1:
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
           if (device->hasISA(AVX))
             accels.add(device->bvh8_factory->BVH8Quad4v(this,BVH8Factory::BuildVariant::STATIC,BVH8Factory::IntersectVariant::ROBUST));
           else
@@ -266,7 +269,7 @@ namespace embree
       }
       else /* dynamic */
       {
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
           if (device->hasISA(AVX))
 	  {
             int mode =  2*(int)isCompact() + 1*(int)isRobust();
@@ -294,7 +297,7 @@ namespace embree
     else if (device->quad_accel == "bvh4.quad4i")       accels.add(device->bvh4_factory->BVH4Quad4i(this));
     else if (device->quad_accel == "qbvh4.quad4i")      accels.add(device->bvh4_factory->BVH4QuantizedQuad4i(this));
 
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
     else if (device->quad_accel == "bvh8.quad4v")       accels.add(device->bvh8_factory->BVH8Quad4v(this));
     else if (device->quad_accel == "bvh8.quad4i")       accels.add(device->bvh8_factory->BVH8Quad4i(this));
     else if (device->quad_accel == "qbvh8.quad4i")      accels.add(device->bvh8_factory->BVH8QuantizedQuad4i(this));
@@ -311,7 +314,7 @@ namespace embree
       int mode =  2*(int)isCompact() + 1*(int)isRobust(); 
       switch (mode) {
       case /*0b00*/ 0:
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
         if (device->hasISA(AVX))
           accels.add(device->bvh8_factory->BVH8Quad4iMB(this,BVH8Factory::BuildVariant::STATIC,BVH8Factory::IntersectVariant::FAST));
         else
@@ -320,7 +323,7 @@ namespace embree
         break;
 
       case /*0b01*/ 1:
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
         if (device->hasISA(AVX))
           accels.add(device->bvh8_factory->BVH8Quad4iMB(this,BVH8Factory::BuildVariant::STATIC,BVH8Factory::IntersectVariant::ROBUST));
         else
@@ -333,7 +336,7 @@ namespace embree
       }
     }
     else if (device->quad_accel_mb == "bvh4.quad4imb") accels.add(device->bvh4_factory->BVH4Quad4iMB(this));
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
     else if (device->quad_accel_mb == "bvh8.quad4imb") accels.add(device->bvh8_factory->BVH8Quad4iMB(this));
 #endif
     else throw_RTCError(RTC_INVALID_ARGUMENT,"unknown quad acceleration structure "+device->quad_accel_mb);
@@ -348,7 +351,7 @@ namespace embree
       int mode = 2*(int)isCompact() + 1*(int)isRobust();
       if (isStatic())
       {
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
         if (device->hasISA(AVX2)) // only enable on HSW machines, for SNB this codepath is slower
         {
           switch (mode) {
@@ -383,7 +386,7 @@ namespace embree
     else if (device->hair_accel == "bvh4.bezier1i"    ) accels.add(device->bvh4_factory->BVH4Bezier1i(this));
     else if (device->hair_accel == "bvh4obb.bezier1v" ) accels.add(device->bvh4_factory->BVH4OBBBezier1v(this));
     else if (device->hair_accel == "bvh4obb.bezier1i" ) accels.add(device->bvh4_factory->BVH4OBBBezier1i(this));
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
     else if (device->hair_accel == "bvh8obb.bezier1v" ) accels.add(device->bvh8_factory->BVH8OBBBezier1v(this));
     else if (device->hair_accel == "bvh8obb.bezier1i" ) accels.add(device->bvh8_factory->BVH8OBBBezier1i(this));
 #endif
@@ -396,7 +399,7 @@ namespace embree
 #if defined(EMBREE_GEOMETRY_HAIR)
     if (device->hair_accel_mb == "default")
     {
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
       if (device->hasISA(AVX2)) // only enable on HSW machines, on SNB this codepath is slower
       {
         accels.add(device->bvh8_factory->BVH8OBBBezier1iMB(this));
@@ -408,7 +411,7 @@ namespace embree
       }
     }
     else if (device->hair_accel_mb == "bvh4obb.bezier1imb") accels.add(device->bvh4_factory->BVH4OBBBezier1iMB(this));
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
     else if (device->hair_accel_mb == "bvh8obb.bezier1imb") accels.add(device->bvh8_factory->BVH8OBBBezier1iMB(this));
 #endif
     else throw_RTCError(RTC_INVALID_ARGUMENT,"unknown motion blur hair acceleration structure "+device->tri_accel_mb);
@@ -422,7 +425,7 @@ namespace embree
     {
       if (isStatic())
       {
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
         if (device->hasISA(AVX) && !isCompact())
           accels.add(device->bvh8_factory->BVH8Line4i(this));
         else
@@ -435,7 +438,7 @@ namespace embree
       }
     }
     else if (device->line_accel == "bvh4.line4i") accels.add(device->bvh4_factory->BVH4Line4i(this));
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
     else if (device->line_accel == "bvh8.line4i") accels.add(device->bvh8_factory->BVH8Line4i(this));
 #endif
     else throw_RTCError(RTC_INVALID_ARGUMENT,"unknown line segment acceleration structure "+device->line_accel);
@@ -447,7 +450,7 @@ namespace embree
 #if defined(EMBREE_GEOMETRY_LINES)
     if (device->line_accel_mb == "default")
     {
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
       if (device->hasISA(AVX) && !isCompact())
         accels.add(device->bvh8_factory->BVH8Line4iMB(this));
       else
@@ -455,7 +458,7 @@ namespace embree
         accels.add(device->bvh4_factory->BVH4Line4iMB(this));
     }
     else if (device->line_accel_mb == "bvh4.line4imb") accels.add(device->bvh4_factory->BVH4Line4iMB(this));
-#if defined (__TARGET_AVX__)
+#if defined (__AVX__)
     else if (device->line_accel_mb == "bvh8.line4imb") accels.add(device->bvh8_factory->BVH8Line4iMB(this));
 #endif
     else throw_RTCError(RTC_INVALID_ARGUMENT,"unknown motion blur line segment acceleration structure "+device->line_accel_mb);
@@ -531,9 +534,9 @@ namespace embree
   void Scene::clear() {
   }
 
-#if defined(EMBREE_GEOMETRY_USER)
   unsigned Scene::newUserGeometry (RTCGeometryFlags gflags, size_t items, size_t numTimeSteps) 
   {
+#if defined(EMBREE_GEOMETRY_USER)
     if (isStatic() && (gflags != RTC_GEOMETRY_STATIC)) {
       throw_RTCError(RTC_INVALID_OPERATION,"static scenes can only contain static geometries");
       return -1;
@@ -545,18 +548,24 @@ namespace embree
     }
 
     return add(new UserGeometry(this,gflags,items,numTimeSteps));
+#else
+    return -1;
+#endif
   }
 
-  unsigned Scene::newInstance (Scene* scene, size_t numTimeSteps) 
+  unsigned Scene::newInstance (SceneInterface* scene, size_t numTimeSteps) 
   {
+#if defined(EMBREE_GEOMETRY_USER)
     if (numTimeSteps == 0 || numTimeSteps > RTC_MAX_TIME_STEPS) {
       throw_RTCError(RTC_INVALID_OPERATION,"maximal number of timesteps exceeded");
       return -1;
     }
 
-    return add(Instance::create(this,scene,numTimeSteps));
-  }
+    return add(Instance::create(this,dynamic_cast<Scene*>(scene),numTimeSteps));
+#else
+    return -1;
 #endif
+  }
 
   unsigned Scene::newGeometryInstance (Geometry* geom_in) 
   {
@@ -566,6 +575,10 @@ namespace embree
     return id;
   }
 
+  unsigned Scene::newGeometryInstance (unsigned geomID) {
+    return newGeometryInstance(get_locked(geomID));
+  }
+
   unsigned int Scene::newGeometryGroup (RTCGeometryFlags gflags, const std::vector<Geometry*> geometries)
   {
     Geometry* geom = new GeometryGroup(this,gflags,geometries);
@@ -574,9 +587,23 @@ namespace embree
     return id;
   }
 
-#if defined(EMBREE_GEOMETRY_TRIANGLES)
+  unsigned int Scene::newGeometryGroup (RTCGeometryFlags gflags, unsigned* geomIDs, size_t N)
+  {
+    std::vector<Geometry*> geometries(N);
+    for (size_t i=0; i<N; i++) {
+      geometries[i] = get_locked(geomIDs[i]);
+      if (geometries[i]->getType() == Geometry::GROUP)
+        throw_RTCError(RTC_INVALID_ARGUMENT,"geometry groups cannot contain other geometry groups");
+      if (geometries[i]->getType() != geometries[0]->getType())
+        throw_RTCError(RTC_INVALID_ARGUMENT,"geometries inside group have to be of same type");
+    }
+    return newGeometryGroup(gflags,geometries);
+  }
+
   unsigned Scene::newTriangleMesh (RTCGeometryFlags gflags, size_t numTriangles, size_t numVertices, size_t numTimeSteps) 
   {
+#if defined(EMBREE_GEOMETRY_TRIANGLES)
+
     if (isStatic() && (gflags != RTC_GEOMETRY_STATIC)) {
       throw_RTCError(RTC_INVALID_OPERATION,"static scenes can only contain static geometries");
       return -1;
@@ -588,12 +615,15 @@ namespace embree
     }
     
     return add(new TriangleMesh(this,gflags,numTriangles,numVertices,numTimeSteps));
-  }
+#else
+    return -1;
 #endif
+  }
 
-#if defined(EMBREE_GEOMETRY_QUADS)
   unsigned Scene::newQuadMesh (RTCGeometryFlags gflags, size_t numQuads, size_t numVertices, size_t numTimeSteps) 
   {
+#if defined(EMBREE_GEOMETRY_QUADS)
+
     if (isStatic() && (gflags != RTC_GEOMETRY_STATIC)) {
       throw_RTCError(RTC_INVALID_OPERATION,"static scenes can only contain static geometries");
       return -1;
@@ -605,12 +635,15 @@ namespace embree
     }
     
     return add(new QuadMesh(this,gflags,numQuads,numVertices,numTimeSteps));
-  }
+#else
+    return -1;
 #endif
+  }
 
-#if defined(EMBREE_GEOMETRY_SUBDIV)
   unsigned Scene::newSubdivisionMesh (RTCGeometryFlags gflags, size_t numFaces, size_t numEdges, size_t numVertices, size_t numEdgeCreases, size_t numVertexCreases, size_t numHoles, size_t numTimeSteps) 
   {
+#if defined(EMBREE_GEOMETRY_SUBDIV)
+
     if (isStatic() && (gflags != RTC_GEOMETRY_STATIC)) {
       throw_RTCError(RTC_INVALID_OPERATION,"static scenes can only contain static geometries");
       return -1;
@@ -621,18 +654,24 @@ namespace embree
       return -1;
     }
 
-#if defined(__TARGET_AVX__)
+#if defined(__AVX__)
     if (device->hasISA(AVX))
       return add(new SubdivMeshAVX(this,gflags,numFaces,numEdges,numVertices,numEdgeCreases,numVertexCreases,numHoles,numTimeSteps));
     else 
 #endif
       return add(new SubdivMesh(this,gflags,numFaces,numEdges,numVertices,numEdgeCreases,numVertexCreases,numHoles,numTimeSteps));
-  }
+#else
+    return -1;
 #endif
+  }
 
-#if defined(EMBREE_GEOMETRY_HAIR)
-  unsigned Scene::newCurves (NativeCurves::SubType subtype, NativeCurves::Basis basis, RTCGeometryFlags gflags, size_t numCurves, size_t numVertices, size_t numTimeSteps) 
+  unsigned Scene::newCurves (int subtype_i, int basis_i, RTCGeometryFlags gflags, size_t numCurves, size_t numVertices, size_t numTimeSteps) 
   {
+    NativeCurves::SubType subtype = (NativeCurves::SubType) subtype_i;
+    NativeCurves::Basis basis = (NativeCurves::Basis) basis_i;
+    
+#if defined(EMBREE_GEOMETRY_HAIR)
+
     if (isStatic() && (gflags != RTC_GEOMETRY_STATIC)) {
       throw_RTCError(RTC_INVALID_OPERATION,"static scenes can only contain static geometries");
       return -1;
@@ -656,12 +695,15 @@ namespace embree
     }
 #endif
     return add(geom);
-  }
+#else
+    return -1;
 #endif
+  }
 
-#if defined(EMBREE_GEOMETRY_LINES)
   unsigned Scene::newLineSegments (RTCGeometryFlags gflags, size_t numSegments, size_t numVertices, size_t numTimeSteps)
   {
+#if defined(EMBREE_GEOMETRY_LINES)
+
     if (isStatic() && (gflags != RTC_GEOMETRY_STATIC)) {
       throw_RTCError(RTC_INVALID_OPERATION,"static scenes can only contain static geometries");
       return -1;
@@ -673,8 +715,10 @@ namespace embree
     }
 
     return add(new LineSegments(this,gflags,numSegments,numVertices,numTimeSteps));
-  }
+#else
+    return -1;
 #endif
+  }
 
   unsigned Scene::add(Geometry* geometry) 
   {
@@ -918,11 +962,8 @@ namespace embree
 
   void Scene::setProgressMonitorFunction(RTCProgressMonitorFunc func, void* ptr) 
   {
-    static MutexSys mutex;
-    mutex.lock();
     progress_monitor_function = func;
     progress_monitor_ptr      = ptr;
-    mutex.unlock();
   }
 
   void Scene::progressMonitor(double dn)
@@ -934,4 +975,527 @@ namespace embree
       }
     }
   }
+
+  DeviceInterface* Scene::getDevice() {
+    return device;
+  }
+
+  GeometryInterface* Scene::getGeometry (unsigned geomID) {
+    return get(geomID);
+  }
+
+  GeometryInterface* Scene::getGeometryLocked (unsigned geomID) {
+    return get_locked(geomID);
+  }
+
+  void Scene::rtcGetBounds(RTCBounds& bounds_o)
+  {
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    BBox3fa bounds = this->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;
+  }
+
+  void Scene::rtcGetLinearBounds(RTCBounds* bounds_o)
+  {
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    bounds_o[0].lower_x = bounds.bounds0.lower.x;
+    bounds_o[0].lower_y = bounds.bounds0.lower.y;
+    bounds_o[0].lower_z = bounds.bounds0.lower.z;
+    bounds_o[0].align0  = 0;
+    bounds_o[0].upper_x = bounds.bounds0.upper.x;
+    bounds_o[0].upper_y = bounds.bounds0.upper.y;
+    bounds_o[0].upper_z = bounds.bounds0.upper.z;
+    bounds_o[0].align1  = 0;
+    bounds_o[1].lower_x = bounds.bounds1.lower.x;
+    bounds_o[1].lower_y = bounds.bounds1.lower.y;
+    bounds_o[1].lower_z = bounds.bounds1.lower.z;
+    bounds_o[1].align0  = 0;
+    bounds_o[1].upper_x = bounds.bounds1.upper.x;
+    bounds_o[1].upper_y = bounds.bounds1.upper.y;
+    bounds_o[1].upper_z = bounds.bounds1.upper.z;
+    bounds_o[1].align1  = 0;
+  }
+  
+  void Scene::rtcIntersect (RTCRay& ray) 
+  {
+#if defined(DEBUG)
+    if (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
+    STAT3(normal.travs,1,1,1);
+    IntersectContext context(this,nullptr);
+    intersect(ray,&context);
+  }
+
+  void Scene::rtcIntersect1Ex (const RTCIntersectContext* user_context, RTCRay& ray) 
+  {
+#if defined(DEBUG)
+    if (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
+    STAT3(normal.travs,1,1,1);
+    IntersectContext context(this,user_context);
+    intersect(ray,&context);
+  }
+
+  void Scene::rtcIntersect4 (const void* valid, RTCRay4& ray) 
+  {
+#if defined(__TARGET_SIMD4__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (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;);
+    STAT3(normal.travs,1,cnt,4);
+    IntersectContext context(this,nullptr);
+    intersect4(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersect4 not supported");  
+#endif
+  }
+
+  void Scene::rtcIntersect4Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay4& ray) 
+  {
+#if defined(__TARGET_SIMD4__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (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;);
+    STAT3(normal.travs,1,cnt,4);
+    IntersectContext context(this,user_context);
+    intersect4(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersect4Ex not supported");  
+#endif
+  }
+  
+  void Scene::rtcIntersect8 (const void* valid, RTCRay8& ray) 
+  {
+#if defined(__TARGET_SIMD8__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)valid) & 0x1F       ) throw_RTCError(RTC_INVALID_ARGUMENT, "mask not aligned to 32 bytes");   
+    if (((size_t)&ray ) & 0x1F       ) throw_RTCError(RTC_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(normal.travs,1,cnt,8);
+    IntersectContext context(this,nullptr);
+    intersect8(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersect8 not supported");      
+#endif
+  }
+
+  void Scene::rtcIntersect8Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay8& ray) 
+  {
+#if defined(__TARGET_SIMD8__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)valid) & 0x1F       ) throw_RTCError(RTC_INVALID_ARGUMENT, "mask not aligned to 32 bytes");   
+    if (((size_t)&ray ) & 0x1F       ) throw_RTCError(RTC_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(normal.travs,1,cnt,8);
+    IntersectContext context(this,user_context);
+    intersect8(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersect8Ex not supported");
+#endif
+  }
+  
+  void Scene::rtcIntersect16 (const void* valid, RTCRay16& ray) 
+  {
+#if defined(__TARGET_SIMD16__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)valid) & 0x3F       ) throw_RTCError(RTC_INVALID_ARGUMENT, "mask not aligned to 64 bytes");   
+    if (((size_t)&ray ) & 0x3F       ) throw_RTCError(RTC_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(normal.travs,1,cnt,16);
+    IntersectContext context(this,nullptr);
+    intersect16(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersect16 not supported");
+#endif
+  }
+
+  void Scene::rtcIntersect16Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay16& ray) 
+  {
+#if defined(__TARGET_SIMD16__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)valid) & 0x3F       ) throw_RTCError(RTC_INVALID_ARGUMENT, "mask not aligned to 64 bytes");   
+    if (((size_t)&ray ) & 0x3F       ) throw_RTCError(RTC_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(normal.travs,1,cnt,16);
+    IntersectContext context(this,user_context);
+    intersect16(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersect16Ex not supported");
+#endif
+  }
+
+  void Scene::rtcIntersect1M (const RTCIntersectContext* user_context, RTCRay* rays, const size_t M, const size_t stride) 
+  {
+#if defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)rays ) & 0x03) throw_RTCError(RTC_INVALID_ARGUMENT, "ray not aligned to 4 bytes");   
+#endif
+    STAT3(normal.travs,M,M,M);
+    IntersectContext context(this,user_context);
+
+    /* fast codepath for single rays */
+    if (likely(M == 1)) {
+      if (likely(rays->tnear <= rays->tfar)) 
+        intersect(*rays,&context);
+    } 
+
+    /* codepath for streams */
+    else {
+      device->rayStreamFilters.filterAOS(this,rays,M,stride,&context,true);   
+    }
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersect1M not supported");
+#endif
+  }
+
+  void Scene::rtcIntersect1Mp (const RTCIntersectContext* user_context, RTCRay** rays, const size_t M) 
+  {
+#if defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)rays ) & 0x03) throw_RTCError(RTC_INVALID_ARGUMENT, "ray not aligned to 4 bytes");   
+#endif
+    STAT3(normal.travs,M,M,M);
+    IntersectContext context(this,user_context);
+
+    /* fast codepath for single rays */
+    if (likely(M == 1)) {
+      if (likely(rays[0]->tnear <= rays[0]->tfar)) 
+        intersect(*rays[0],&context);
+    } 
+
+    /* codepath for streams */
+    else {
+      device->rayStreamFilters.filterAOP(this,rays,M,&context,true);   
+    }
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersect1Mp not supported");
+#endif
+  }
+
+  void Scene::rtcIntersectNM (const RTCIntersectContext* user_context, struct RTCRayN* rays, const size_t N, const size_t M, const size_t stride) 
+  {
+#if defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)rays ) & 0x03) throw_RTCError(RTC_INVALID_ARGUMENT, "ray not aligned to 4 bytes");   
+#endif
+    STAT3(normal.travs,N*M,N*M,N*M);
+    IntersectContext context(this,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(((RTCRay*)rays)->tnear <= ((RTCRay*)rays)->tfar))
+          intersect(*(RTCRay*)rays,&context);
+      } 
+      /* normal codepath for single ray streams */
+      else {
+        device->rayStreamFilters.filterAOS(this,(RTCRay*)rays,M,stride,&context,true);
+      }
+    }
+    /* code path for ray packet streams */
+    else {
+      device->rayStreamFilters.filterSOA(this,(char*)rays,N,M,stride,&context,true);
+    }
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersectNM not supported");
+#endif
+  }
+
+  void Scene::rtcIntersectNp (const RTCIntersectContext* user_context, const RTCRayNp& rays, const size_t N) 
+  {
+#if defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)rays.orgx   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.orgx not aligned to 4 bytes");   
+    if (((size_t)rays.orgy   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.orgy not aligned to 4 bytes");   
+    if (((size_t)rays.orgz   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.orgz not aligned to 4 bytes");   
+    if (((size_t)rays.dirx   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.dirx not aligned to 4 bytes");   
+    if (((size_t)rays.diry   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.diry not aligned to 4 bytes");   
+    if (((size_t)rays.dirz   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.dirz not aligned to 4 bytes");   
+    if (((size_t)rays.tnear  ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.dirx not aligned to 4 bytes");   
+    if (((size_t)rays.tfar   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.tnear not aligned to 4 bytes");   
+    if (((size_t)rays.time   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.time not aligned to 4 bytes");   
+    if (((size_t)rays.mask   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.mask not aligned to 4 bytes");   
+    if (((size_t)rays.Ngx    ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.Ngx not aligned to 4 bytes");   
+    if (((size_t)rays.Ngy    ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.Ngy not aligned to 4 bytes");   
+    if (((size_t)rays.Ngz    ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.Ngz not aligned to 4 bytes");   
+    if (((size_t)rays.u      ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.u not aligned to 4 bytes");   
+    if (((size_t)rays.v      ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.v not aligned to 4 bytes");   
+    if (((size_t)rays.geomID ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.geomID not aligned to 4 bytes");   
+    if (((size_t)rays.primID ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.primID not aligned to 4 bytes");   
+    if (((size_t)rays.instID ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.instID not aligned to 4 bytes");   
+#endif
+    STAT3(normal.travs,N,N,N);
+    IntersectContext context(this,user_context);
+    device->rayStreamFilters.filterSOP(this,rays,N,&context,true);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcIntersectNp not supported");
+#endif
+  }
+  
+  void Scene::rtcOccluded (RTCRay& ray) 
+  {
+    STAT3(shadow.travs,1,1,1);
+#if defined(DEBUG)
+    if (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
+    IntersectContext context(this,nullptr);
+    occluded(ray,&context);
+  }
+
+  void Scene::rtcOccluded1Ex (const RTCIntersectContext* user_context, RTCRay& ray) 
+  {
+    STAT3(shadow.travs,1,1,1);
+#if defined(DEBUG)
+    if (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
+    IntersectContext context(this,user_context);
+    occluded(ray,&context);
+  }
+  
+  void Scene::rtcOccluded4 (const void* valid, RTCRay4& ray) 
+  {
+#if defined(__TARGET_SIMD4__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (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;);
+    STAT3(shadow.travs,1,cnt,4);
+    IntersectContext context(this,nullptr);
+    occluded4(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccluded4 not supported");
+#endif
+  }
+
+  void Scene::rtcOccluded4Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay4& ray) 
+  {
+#if defined(__TARGET_SIMD4__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (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;);
+    STAT3(shadow.travs,1,cnt,4);
+    IntersectContext context(this,user_context);
+    occluded4(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccluded4Ex not supported");
+#endif
+  }
+ 
+  void Scene::rtcOccluded8 (const void* valid, RTCRay8& ray) 
+  {
+#if defined(__TARGET_SIMD8__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)valid) & 0x1F       ) throw_RTCError(RTC_INVALID_ARGUMENT, "mask not aligned to 32 bytes");   
+    if (((size_t)&ray ) & 0x1F       ) throw_RTCError(RTC_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,1,cnt,8);
+    IntersectContext context(this,nullptr);
+    occluded8(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccluded8 not supported");
+#endif
+  }
+
+  void Scene::rtcOccluded8Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay8& ray) 
+  {
+#if defined(__TARGET_SIMD8__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)valid) & 0x1F       ) throw_RTCError(RTC_INVALID_ARGUMENT, "mask not aligned to 32 bytes");   
+    if (((size_t)&ray ) & 0x1F       ) throw_RTCError(RTC_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,1,cnt,8);
+    IntersectContext context(this,user_context);
+    occluded8(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccluded8Ex not supported");
+#endif
+  }
+  
+  void Scene::rtcOccluded16 (const void* valid, RTCRay16& ray) 
+  {
+#if defined(__TARGET_SIMD16__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)valid) & 0x3F       ) throw_RTCError(RTC_INVALID_ARGUMENT, "mask not aligned to 64 bytes");   
+    if (((size_t)&ray ) & 0x3F       ) throw_RTCError(RTC_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,1,cnt,16);
+    IntersectContext context(this,nullptr);
+    occluded16(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccluded16 not supported");
+#endif
+  }
+
+  void Scene::rtcOccluded16Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay16& ray) 
+  {
+#if defined(__TARGET_SIMD16__) && defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)valid) & 0x3F       ) throw_RTCError(RTC_INVALID_ARGUMENT, "mask not aligned to 64 bytes");   
+    if (((size_t)&ray ) & 0x3F       ) throw_RTCError(RTC_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,1,cnt,16);
+    IntersectContext context(this,user_context);
+    occluded16(valid,ray,&context);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccluded16Ex not supported");
+#endif
+  }
+  
+  void Scene::rtcOccluded1M(const RTCIntersectContext* user_context, RTCRay* rays, const size_t M, const size_t stride) 
+  {
+#if defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)rays ) & 0x03) throw_RTCError(RTC_INVALID_ARGUMENT, "ray not aligned to 4 bytes");   
+#endif
+    STAT3(shadow.travs,M,M,M);
+    IntersectContext context(this,user_context);
+
+    /* fast codepath for streams of size 1 */
+    if (likely(M == 1)) {
+      if (likely(rays->tnear <= rays->tfar)) 
+        occluded (*rays,&context);
+    } 
+    /* codepath for normal streams */
+    else {
+      device->rayStreamFilters.filterAOS(this,rays,M,stride,&context,false);
+    }
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccluded1M not supported");
+#endif
+  }
+
+  void Scene::rtcOccluded1Mp(const RTCIntersectContext* user_context, RTCRay** rays, const size_t M) 
+  {
+#if defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)rays ) & 0x03) throw_RTCError(RTC_INVALID_ARGUMENT, "ray not aligned to 4 bytes");   
+#endif
+    STAT3(shadow.travs,M,M,M);
+    IntersectContext context(this,user_context);
+
+    /* fast codepath for streams of size 1 */
+    if (likely(M == 1)) {
+      if (likely(rays[0]->tnear <= rays[0]->tfar)) 
+        occluded (*rays[0],&context);
+    } 
+    /* codepath for normal streams */
+    else {
+      device->rayStreamFilters.filterAOP(this,rays,M,&context,false);
+    }
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccluded1Mp not supported");
+#endif
+  }
+
+  void Scene::rtcOccludedNM(const RTCIntersectContext* user_context, RTCRayN* rays, const size_t N, const size_t M, const size_t stride) 
+  {
+#if defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (stride < sizeof(RTCRay)) throw_RTCError(RTC_INVALID_OPERATION,"stride too small");
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)rays ) & 0x03) throw_RTCError(RTC_INVALID_ARGUMENT, "ray not aligned to 4 bytes");   
+#endif
+    STAT3(shadow.travs,N*M,N*N,N*N);
+    IntersectContext context(this,user_context);
+
+    /* codepath for single rays */
+    if (likely(N == 1))
+    {
+      /* fast path for streams of size 1 */
+      if (likely(M == 1)) {
+        if (likely(((RTCRay*)rays)->tnear <= ((RTCRay*)rays)->tfar))
+          occluded (*(RTCRay*)rays,&context);
+      } 
+      /* codepath for normal ray streams */
+      else {
+        device->rayStreamFilters.filterAOS(this,(RTCRay*)rays,M,stride,&context,false);
+      }
+    }
+    /* code path for ray packet streams */
+    else {
+      device->rayStreamFilters.filterSOA(this,(char*)rays,N,M,stride,&context,false);
+    }
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccludedNM not supported");
+#endif
+  }
+
+  void Scene::rtcOccludedNp(const RTCIntersectContext* user_context, const RTCRayNp& rays, const size_t N) 
+  {
+#if defined (EMBREE_RAY_PACKETS)
+#if defined(DEBUG)
+    if (isModified()) throw_RTCError(RTC_INVALID_OPERATION,"scene got not committed");
+    if (((size_t)rays.orgx   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.orgx not aligned to 4 bytes");   
+    if (((size_t)rays.orgy   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.orgy not aligned to 4 bytes");   
+    if (((size_t)rays.orgz   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.orgz not aligned to 4 bytes");   
+    if (((size_t)rays.dirx   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.dirx not aligned to 4 bytes");   
+    if (((size_t)rays.diry   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.diry not aligned to 4 bytes");   
+    if (((size_t)rays.dirz   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.dirz not aligned to 4 bytes");   
+    if (((size_t)rays.tnear  ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.dirx not aligned to 4 bytes");   
+    if (((size_t)rays.tfar   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.tnear not aligned to 4 bytes");   
+    if (((size_t)rays.time   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.time not aligned to 4 bytes");   
+    if (((size_t)rays.mask   ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.mask not aligned to 4 bytes");   
+    if (((size_t)rays.Ngx    ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.Ngx not aligned to 4 bytes");   
+    if (((size_t)rays.Ngy    ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.Ngy not aligned to 4 bytes");   
+    if (((size_t)rays.Ngz    ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.Ngz not aligned to 4 bytes");   
+    if (((size_t)rays.u      ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.u not aligned to 4 bytes");   
+    if (((size_t)rays.v      ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.v not aligned to 4 bytes");   
+    if (((size_t)rays.geomID ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.geomID not aligned to 4 bytes");   
+    if (((size_t)rays.primID ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.primID not aligned to 4 bytes");   
+    if (((size_t)rays.instID ) & 0x03 ) throw_RTCError(RTC_INVALID_ARGUMENT, "rays.instID not aligned to 4 bytes");   
+#endif
+    STAT3(shadow.travs,N,N,N);
+    IntersectContext context(this,user_context);
+    device->rayStreamFilters.filterSOP(this,rays,N,&context,false);
+#else
+    throw_RTCError(RTC_INVALID_OPERATION,"rtcOccludedNp not supported");
+#endif
+  }
+}
 }

kernels/common/scene.h

@@ -33,12 +33,61 @@
 #include "geometry.h"
 
 namespace embree
+{
+  struct DeviceInterface;
+  struct SceneInterface
+  {
+    virtual ~SceneInterface() {};
+    virtual DeviceInterface* getDevice() = 0;
+    virtual void setProgressMonitorFunction(RTCProgressMonitorFunc func, void* ptr) = 0;
+    virtual unsigned int newUserGeometry (RTCGeometryFlags gflags, size_t items, size_t numTimeSteps) = 0;
+    virtual unsigned int newInstance (SceneInterface* scene, size_t numTimeSteps) = 0;
+    virtual unsigned int newGeometryInstance (unsigned geomID) = 0;
+    virtual unsigned int newGeometryGroup (RTCGeometryFlags gflags, unsigned* geomIDs, size_t N) = 0;
+    virtual unsigned int newTriangleMesh (RTCGeometryFlags flags, size_t maxTriangles, size_t maxVertices, size_t numTimeSteps) = 0;
+    virtual unsigned int newQuadMesh (RTCGeometryFlags flags, size_t maxQuads, size_t maxVertices, size_t numTimeSteps) = 0;
+    virtual unsigned int newCurves (int subtype, int basis, RTCGeometryFlags flags, size_t maxCurves, size_t maxVertices, size_t numTimeSteps) = 0;
+    virtual unsigned int newLineSegments (RTCGeometryFlags flags, size_t maxSegments, size_t maxVertices, size_t numTimeSteps) = 0;
+    virtual unsigned int newSubdivisionMesh (RTCGeometryFlags flags, size_t numFaces, size_t numEdges, size_t numVertices, size_t numEdgeCreases, size_t numVertexCreases, size_t numHoles, size_t numTimeSteps) = 0;
+    virtual void commit (size_t threadIndex, size_t threadCount, bool useThreadPool) = 0;
+    virtual GeometryInterface* getGeometry(unsigned geomID) = 0;
+    virtual GeometryInterface* getGeometryLocked(unsigned geomID) = 0;
+    virtual void deleteGeometry(size_t geomID) = 0;
+    virtual void rtcGetBounds(RTCBounds& bounds_o) = 0;
+    virtual void rtcGetLinearBounds(RTCBounds* bounds_o) = 0;
+    virtual void rtcIntersect (RTCRay& ray) = 0;
+    virtual void rtcIntersect1Ex (const RTCIntersectContext* user_context, RTCRay& ray) = 0;
+    virtual void rtcIntersect4 (const void* valid, RTCRay4& ray) = 0;
+    virtual void rtcIntersect4Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay4& ray) = 0;
+    virtual void rtcIntersect8 (const void* valid, RTCRay8& ray) = 0;
+    virtual void rtcIntersect8Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay8& ray) = 0;
+    virtual void rtcIntersect16 (const void* valid, RTCRay16& ray) = 0;
+    virtual void rtcIntersect16Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay16& ray) = 0;
+    virtual void rtcIntersect1M (const RTCIntersectContext* user_context, RTCRay* rays, const size_t M, const size_t stride) = 0;
+    virtual void rtcIntersect1Mp (const RTCIntersectContext* user_context, RTCRay** rays, const size_t M) = 0;
+    virtual void rtcIntersectNM (const RTCIntersectContext* user_context, struct RTCRayN* rays, const size_t N, const size_t M, const size_t stride) = 0;
+    virtual void rtcIntersectNp (const RTCIntersectContext* user_context, const RTCRayNp& rays, const size_t N) = 0;
+    virtual void rtcOccluded (RTCRay& ray) = 0;
+    virtual void rtcOccluded1Ex (const RTCIntersectContext* user_context, RTCRay& ray) = 0;
+    virtual void rtcOccluded4 (const void* valid, RTCRay4& ray) = 0;
+    virtual void rtcOccluded4Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay4& ray) = 0;
+    virtual void rtcOccluded8 (const void* valid, RTCRay8& ray) = 0;
+    virtual void rtcOccluded8Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay8& ray) = 0;
+    virtual void rtcOccluded16 (const void* valid, RTCRay16& ray) = 0;
+    virtual void rtcOccluded16Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay16& ray) = 0;
+    virtual void rtcOccluded1M(const RTCIntersectContext* user_context, RTCRay* rays, const size_t M, const size_t stride) = 0;
+    virtual void rtcOccluded1Mp(const RTCIntersectContext* user_context, RTCRay** rays, const size_t M) = 0;
+    virtual void rtcOccludedNM(const RTCIntersectContext* user_context, RTCRayN* rays, const size_t N, const size_t M, const size_t stride) = 0;
+    virtual void rtcOccludedNp(const RTCIntersectContext* user_context, const RTCRayNp& rays, const size_t N) = 0;
+  };
+
+namespace isa
 {
   /*! Base class all scenes are derived from */
-  class Scene : public Accel
+  class Scene : public SceneInterface, public Accel
   {
     ALIGNED_CLASS;
-
+ 
   public:
     template<typename Ty, bool mblur = false>
       class Iterator
@@ -132,13 +181,15 @@ namespace embree
     unsigned int newUserGeometry (RTCGeometryFlags gflags, size_t items, size_t numTimeSteps);
 
     /*! Creates a new scene instance. */
-    unsigned int newInstance (Scene* scene, size_t numTimeSteps);
+    unsigned int newInstance (SceneInterface* scene, size_t numTimeSteps);
 
     /*! Creates a new geometry instance. */
     unsigned int newGeometryInstance (Geometry* geom);
+    unsigned int newGeometryInstance (unsigned geomID);
 
     /*! Creates a new geometry group. */
     unsigned int newGeometryGroup (RTCGeometryFlags gflags, const std::vector<Geometry*> geometries);
+    unsigned int newGeometryGroup (RTCGeometryFlags gflags, unsigned* geomIDs, size_t N);
 
     /*! Creates a new triangle mesh. */
     unsigned int newTriangleMesh (RTCGeometryFlags flags, size_t maxTriangles, size_t maxVertices, size_t numTimeSteps);
@@ -147,7 +198,7 @@ namespace embree
     unsigned int newQuadMesh (RTCGeometryFlags flags, size_t maxQuads, size_t maxVertices, size_t numTimeSteps);
 
     /*! Creates a new collection of quadratic bezier curves. */
-    unsigned int newCurves (NativeCurves::SubType subtype, NativeCurves::Basis basis, RTCGeometryFlags flags, size_t maxCurves, size_t maxVertices, size_t numTimeSteps);
+    unsigned int newCurves (int subtype, int basis, RTCGeometryFlags flags, size_t maxCurves, size_t maxVertices, size_t numTimeSteps);
 
     /*! Creates a new collection of line segments. */
     unsigned int newLineSegments (RTCGeometryFlags flags, size_t maxSegments, size_t maxVertices, size_t numTimeSteps);
@@ -228,10 +279,10 @@ namespace embree
     __forceinline bool isStreamMode() const { return embree::isStreamMode(aflags); }
 
     __forceinline bool isExclusiveIntersect1Mode() const { 
-      if (!embree::isIntersect1Mode(aflags)) return false;
-      if (embree::isIntersect4Mode(aflags))  return false;
-      if (embree::isIntersect8Mode(aflags))  return false;
-      if (embree::isIntersect16Mode(aflags)) return false;
+      if (!isIntersect1Mode(aflags)) return false;
+      if (isIntersect4Mode(aflags))  return false;
+      if (isIntersect8Mode(aflags))  return false;
+      if (isIntersect16Mode(aflags)) return false;
       return true;
     }
 
@@ -337,6 +388,37 @@ namespace embree
     std::atomic<size_t> numIntersectionFilters8;   //!< number of enabled intersection/occlusion filters for 8-wide ray packets
     std::atomic<size_t> numIntersectionFilters16;  //!< number of enabled intersection/occlusion filters for 16-wide ray packets
     std::atomic<size_t> numIntersectionFiltersN;   //!< number of enabled intersection/occlusion filters for N-wide ray packets
+
+ public:
+    virtual DeviceInterface* getDevice();
+    virtual GeometryInterface* getGeometry(unsigned geomID);
+    virtual GeometryInterface* getGeometryLocked(unsigned geomID);
+    virtual void rtcGetBounds(RTCBounds& bounds_o);
+    virtual void rtcGetLinearBounds(RTCBounds* bounds_o);
+    virtual void rtcIntersect (RTCRay& ray);
+    virtual void rtcIntersect1Ex (const RTCIntersectContext* user_context, RTCRay& ray);
+    virtual void rtcIntersect4 (const void* valid, RTCRay4& ray);
+    virtual void rtcIntersect4Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay4& ray);
+    virtual void rtcIntersect8 (const void* valid, RTCRay8& ray);
+    virtual void rtcIntersect8Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay8& ray);
+    virtual void rtcIntersect16 (const void* valid, RTCRay16& ray);
+    virtual void rtcIntersect16Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay16& ray);
+    virtual void rtcIntersect1M (const RTCIntersectContext* user_context, RTCRay* rays, const size_t M, const size_t stride);
+    virtual void rtcIntersect1Mp (const RTCIntersectContext* user_context, RTCRay** rays, const size_t M);
+    virtual void rtcIntersectNM (const RTCIntersectContext* user_context, struct RTCRayN* rays, const size_t N, const size_t M, const size_t stride);
+    virtual void rtcIntersectNp (const RTCIntersectContext* user_context, const RTCRayNp& rays, const size_t N);
+    virtual void rtcOccluded (RTCRay& ray);
+    virtual void rtcOccluded1Ex (const RTCIntersectContext* user_context, RTCRay& ray);
+    virtual void rtcOccluded4 (const void* valid, RTCRay4& ray);
+    virtual void rtcOccluded4Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay4& ray);
+    virtual void rtcOccluded8 (const void* valid, RTCRay8& ray);
+    virtual void rtcOccluded8Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay8& ray);
+    virtual void rtcOccluded16 (const void* valid, RTCRay16& ray);
+    virtual void rtcOccluded16Ex (const void* valid, const RTCIntersectContext* user_context, RTCRay16& ray);
+    virtual void rtcOccluded1M(const RTCIntersectContext* user_context, RTCRay* rays, const size_t M, const size_t stride);
+    virtual void rtcOccluded1Mp(const RTCIntersectContext* user_context, RTCRay** rays, const size_t M);
+    virtual void rtcOccludedNM(const RTCIntersectContext* user_context, RTCRayN* rays, const size_t N, const size_t M, const size_t stride);
+    virtual void rtcOccludedNp(const RTCIntersectContext* user_context, const RTCRayNp& rays, const size_t N);
   };
 
   template<> __forceinline size_t Scene::getNumPrimitives<TriangleMesh,false>() const { return world.numTriangles; }
@@ -352,3 +434,4 @@ namespace embree
   template<> __forceinline size_t Scene::getNumPrimitives<AccelSet,false>() const { return world.numUserGeometries; }
   template<> __forceinline size_t Scene::getNumPrimitives<AccelSet,true>() const { return worldMB.numUserGeometries; }
 }
+}

kernels/common/scene_bezier_curves.cpp

@@ -18,6 +18,8 @@
 #include "scene.h"
 
 namespace embree
+{
+namespace isa
 {
   NativeCurves::NativeCurves (Scene* parent, SubType subtype, Basis basis, RTCGeometryFlags flags, size_t numPrimitives, size_t numVertices, size_t numTimeSteps) 
     : Geometry(parent,BEZIER_CURVES,numPrimitives,numTimeSteps,flags), subtype(subtype), basis(basis), tessellationRate(4)
@@ -292,3 +294,4 @@ namespace embree
     interpolate_helper<BSplineCurveT<vfloatx>>(primID,u,v,buffer,P,dPdu,dPdv,ddPdudu,ddPdvdv,ddPdudv,numFloats);
   }
 }
+}

kernels/common/scene_bezier_curves.h

@@ -23,6 +23,8 @@
 #include "../subdiv/bspline_curve.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! represents an array of bicubic bezier curves */
   struct NativeCurves : public Geometry
@@ -310,3 +312,4 @@ namespace embree
     void interpolate(unsigned primID, float u, float v, RTCBufferType buffer, float* P, float* dPdu, float* dPdv, float* ddPdudu, float* ddPdvdv, float* ddPdudv, size_t numFloats);
   };
 }
+}

kernels/common/scene_geometry_instance.cpp

@@ -18,6 +18,8 @@
 #include "scene.h"
 
 namespace embree
+{
+namespace isa
 {
   GeometryInstance::GeometryInstance (Scene* parent, Geometry* geom) 
     : Geometry(parent,Type(geom->type | INSTANCE), 1, geom->numTimeSteps, geom->flags), local2world(one), world2local(one), geom(geom) 
@@ -120,3 +122,4 @@ namespace embree
     Geometry::update();
   } 
 }
+}

kernels/common/scene_geometry_instance.h

@@ -19,6 +19,8 @@
 #include "geometry.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! Instanced geometry */
   struct GeometryInstance : public Geometry
@@ -65,3 +67,4 @@ namespace embree
     std::vector<Geometry*> geometries; 
   };
 }
+}

kernels/common/scene_instance.cpp

@@ -18,6 +18,8 @@
 #include "scene.h"
 
 namespace embree
+{
+namespace isa
 {
   DECLARE_SYMBOL2(RTCBoundsFunc3,InstanceBoundsFunc);
   DECLARE_SYMBOL2(AccelSet::Intersector1,InstanceIntersector1);
@@ -76,3 +78,4 @@ namespace embree
     Geometry::update();
   }
 }
+}

kernels/common/scene_instance.h

@@ -19,6 +19,8 @@
 #include "accelset.h"
 
 namespace embree
+{
+namespace isa
 {
   class InstanceFactory
   {
@@ -90,3 +92,4 @@ namespace embree
     AffineSpace3fa local2world[1]; //!< transformation from local space to world space for each timestep
   };
 }
+}

kernels/common/scene_line_segments.cpp

@@ -18,6 +18,8 @@
 #include "scene.h"
 
 namespace embree
+{
+namespace isa
 {
   LineSegments::LineSegments (Scene* parent, RTCGeometryFlags flags, size_t numPrimitives, size_t numVertices, size_t numTimeSteps)
     : Geometry(parent,LINE_SEGMENTS,numPrimitives,numTimeSteps,flags)
@@ -192,3 +194,4 @@ namespace embree
     }
   }
 }
+}

kernels/common/scene_line_segments.h

@@ -21,6 +21,8 @@
 #include "buffer.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! represents an array of line segments */
   struct LineSegments : public Geometry
@@ -178,3 +180,4 @@ namespace embree
     vector<APIBuffer<char>> userbuffers;              //!< user buffers
   };
 }
+}

kernels/common/scene_quad_mesh.cpp

@@ -18,6 +18,8 @@
 #include "scene.h"
 
 namespace embree
+{
+namespace isa
 {
   QuadMesh::QuadMesh (Scene* parent, RTCGeometryFlags flags, size_t numQuads, size_t numVertices, size_t numTimeSteps)
     : Geometry(parent,QUAD_MESH,numQuads,numTimeSteps,flags)
@@ -207,3 +209,4 @@ namespace embree
     }
   }
 }
+}

kernels/common/scene_quad_mesh.h

@@ -20,6 +20,8 @@
 #include "buffer.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! Quad Mesh */
   struct QuadMesh : public Geometry
@@ -214,3 +216,4 @@ namespace embree
     vector<APIBuffer<char>> userbuffers;              //!< user buffers
   };
 }
+}

kernels/common/scene_subdiv_mesh.cpp

@@ -24,6 +24,8 @@
 #include "../../common/algorithms/parallel_for.h"
 
 namespace embree
+{
+namespace isa
 {
   SubdivMesh::SubdivMesh (Scene* parent, RTCGeometryFlags flags, size_t numFaces, size_t numEdges, size_t numVertices, 
 			  size_t numEdgeCreases, size_t numVertexCreases, size_t numHoles, size_t numTimeSteps)
@@ -804,7 +806,7 @@ namespace embree
     for (size_t i=0; i<numFloats; i+=4)
     {
       vfloat4 Pt, dPdut, dPdvt, ddPdudut, ddPdvdvt, ddPdudvt;
-      isa::PatchEval<vfloat4,vfloat4>(baseEntry->at(interpolationSlot(primID,i/4,stride)),parent->commitCounterSubdiv,
+      PatchEval<vfloat4,vfloat4>(baseEntry->at(interpolationSlot(primID,i/4,stride)),parent->commitCounterSubdiv,
                                       topo->getHalfEdge(primID),src+i*sizeof(float),stride,u,v,
                                       has_P ? &Pt : nullptr, 
                                       has_dP ? &dPdut : nullptr, 
@@ -884,7 +886,7 @@ namespace embree
         for (size_t j=0; j<numFloats; j+=4) 
         {
           const size_t M = min(size_t(4),numFloats-j);
-          isa::PatchEvalSimd<vbool4,vint4,vfloat4,vfloat4>(baseEntry->at(interpolationSlot(primID,j/4,stride)),parent->commitCounterSubdiv,
+          PatchEvalSimd<vbool4,vint4,vfloat4,vfloat4>(baseEntry->at(interpolationSlot(primID,j/4,stride)),parent->commitCounterSubdiv,
                                                            topo->getHalfEdge(primID),src+j*sizeof(float),stride,valid1,uu,vv,
                                                            P ? P+j*numUVs+i : nullptr,
                                                            dPdu ? dPdu+j*numUVs+i : nullptr,
@@ -898,3 +900,4 @@ namespace embree
     }
   }
 }
+}

kernels/common/scene_subdiv_mesh.h

@@ -26,6 +26,8 @@
 #include "../../common/algorithms/parallel_set.h"
 
 namespace embree
+{
+namespace isa
 {
   class SubdivMesh : public Geometry
   {
@@ -344,4 +346,5 @@ namespace embree
       void interpolateHelper(const vbool& valid1, const vint& primID, const vfloat& uu, const vfloat& vv, size_t numUVs, 
                              RTCBufferType buffer, float* P, float* dPdu, float* dPdv, float* ddPdudu, float* ddPdvdv, float* ddPdudv, size_t numFloats);
   };
-};
+}
+}

kernels/common/scene_subdiv_mesh_avx.cpp

@@ -14,12 +14,16 @@
 // limitations under the License.                                           //
 // ======================================================================== //
 
+#if defined (__AVX__)
+
 #include "scene_subdiv_mesh.h"
 #include "scene.h"
 #include "../subdiv/patch_eval.h"
 #include "../subdiv/patch_eval_simd.h"
 
 namespace embree
+{
+namespace isa
 {
   SubdivMeshAVX::SubdivMeshAVX(Scene* parent, RTCGeometryFlags flags, size_t numFaces, size_t numEdges, size_t numVertices, 
                                size_t numCreases, size_t numCorners, size_t numHoles, size_t numTimeSteps)
@@ -64,7 +68,7 @@ namespace embree
       if (i+4 >= numFloats)
       {
         vfloat4 Pt, dPdut, dPdvt, ddPdudut, ddPdvdvt, ddPdudvt;; 
-        isa::PatchEval<vfloat4>(baseEntry->at(interpolationSlot(primID,slot,stride)),parent->commitCounterSubdiv,
+        PatchEval<vfloat4>(baseEntry->at(interpolationSlot(primID,slot,stride)),parent->commitCounterSubdiv,
                                 topo->getHalfEdge(primID),src+i*sizeof(float),stride,u,v,
                                 has_P ? &Pt : nullptr, 
                                 has_dP ? &dPdut : nullptr, 
@@ -97,7 +101,7 @@ namespace embree
       else
       {
         vfloat8 Pt, dPdut, dPdvt, ddPdudut, ddPdvdvt, ddPdudvt; 
-        isa::PatchEval<vfloat8>(baseEntry->at(interpolationSlot(primID,slot,stride)),parent->commitCounterSubdiv,
+        PatchEval<vfloat8>(baseEntry->at(interpolationSlot(primID,slot,stride)),parent->commitCounterSubdiv,
                                 topo->getHalfEdge(primID),src+i*sizeof(float),stride,u,v,
                                 has_P ? &Pt : nullptr, 
                                 has_dP ? &dPdut : nullptr, 
@@ -165,7 +169,7 @@ namespace embree
         if (j+4 >= numFloats)
         {
           const size_t M = min(size_t(4),numFloats-j);
-          isa::PatchEvalSimd<vbool,vint,vfloat,vfloat4>(baseEntry->at(interpolationSlot(primID,slot,stride)),parent->commitCounterSubdiv,
+          PatchEvalSimd<vbool,vint,vfloat,vfloat4>(baseEntry->at(interpolationSlot(primID,slot,stride)),parent->commitCounterSubdiv,
                                                         topo->getHalfEdge(primID),src+j*sizeof(float),stride,valid1,uu,vv,
                                                         P ? P+j*numUVs : nullptr,
                                                         dPdu ? dPdu+j*numUVs : nullptr,
@@ -179,7 +183,7 @@ namespace embree
         else
         {
           const size_t M = min(size_t(8),numFloats-j);
-          isa::PatchEvalSimd<vbool,vint,vfloat,vfloat8>(baseEntry->at(interpolationSlot(primID,slot,stride)),parent->commitCounterSubdiv,
+          PatchEvalSimd<vbool,vint,vfloat,vfloat8>(baseEntry->at(interpolationSlot(primID,slot,stride)),parent->commitCounterSubdiv,
                                                         topo->getHalfEdge(primID),src+j*sizeof(float),stride,valid1,uu,vv,
                                                         P ? P+j*numUVs : nullptr,
                                                         dPdu ? dPdu+j*numUVs : nullptr,
@@ -240,3 +244,6 @@ namespace embree
     AVX_ZERO_UPPER();
   }
 }
+}
+
+#endif

kernels/common/scene_triangle_mesh.cpp

@@ -18,6 +18,8 @@
 #include "scene.h"
 
 namespace embree
+{
+namespace isa
 {
   TriangleMesh::TriangleMesh (Scene* parent, RTCGeometryFlags flags, size_t numTriangles, size_t numVertices, size_t numTimeSteps)
     : Geometry(parent,TRIANGLE_MESH,numTriangles,numTimeSteps,flags)
@@ -205,3 +207,4 @@ namespace embree
     }
   }
 }
+}

kernels/common/scene_triangle_mesh.h

@@ -20,6 +20,8 @@
 #include "buffer.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! Triangle Mesh */
   struct TriangleMesh : public Geometry
@@ -273,3 +275,4 @@ namespace embree
     vector<APIBuffer<char>> userbuffers;         //!< user buffers
   };
 }
+}

kernels/common/scene_user_geometry.cpp

@@ -18,6 +18,8 @@
 #include "scene.h"
 
 namespace embree
+{
+namespace isa
 {
   UserGeometry::UserGeometry (Scene* parent, RTCGeometryFlags gflags, size_t items, size_t numTimeSteps) 
     : AccelSet(parent,gflags,items,numTimeSteps) {}
@@ -200,3 +202,4 @@ namespace embree
     intersectors.intersectorN.occluded = occluded;
   }
 }
+}

kernels/common/scene_user_geometry.h

@@ -19,6 +19,8 @@
 #include "accelset.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! User geometry with user defined intersection functions */
   struct UserGeometry : public AccelSet
@@ -45,3 +47,4 @@ namespace embree
     virtual void build() {}
   };
 }
+}

kernels/common/stack_item.h

@@ -19,6 +19,8 @@
 #include "default.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! An item on the stack holds the node ID and distance of that node. */
   template<typename T>
@@ -83,3 +85,4 @@ namespace embree
     unsigned dist;
   };
 }
+}

kernels/common/stat.cpp

@@ -18,6 +18,8 @@
 
 namespace embree
 {
+//namespace isa
+//{
   Stat Stat::instance; 
   
   Stat::Stat () {
@@ -136,4 +138,5 @@ namespace embree
     cout << "#user7/user3 " << 100.0f*float(cntrs.user[7])/float(cntrs.user[3]) << "%" << std::endl;
     cout << std::endl;
   }
+//}
 }

kernels/common/stat.h

@@ -34,6 +34,8 @@
 
 namespace embree
 {
+//namespace isa
+//{
   /*! Gathers ray tracing statistics. We count 1) how often a code
    *  location is reached, 2) how many SIMD lanes are active, 3) how
    *  many SIMD lanes reach the code location */
@@ -125,4 +127,5 @@ namespace embree
   private:
     static Stat instance;
   };
+//}
 }

kernels/common/state.cpp

@@ -19,33 +19,9 @@
 
 namespace embree
 {
-  State::ErrorHandler State::g_errorHandler;
-
-  State::ErrorHandler::ErrorHandler()
-    : thread_error(createTls()) {}
-
-  State::ErrorHandler::~ErrorHandler()
-  {
-    Lock<MutexSys> lock(errors_mutex);
-    for (size_t i=0; i<thread_errors.size(); i++)
-      delete thread_errors[i];
-    destroyTls(thread_error);
-    thread_errors.clear();
-  }
-
-  RTCError* State::ErrorHandler::error() 
-  {
-    RTCError* stored_error = (RTCError*) getTls(thread_error);
-    if (stored_error) return stored_error;
-
-    Lock<MutexSys> lock(errors_mutex);
-    stored_error = new RTCError(RTC_NO_ERROR);
-    thread_errors.push_back(stored_error);
-    setTls(thread_error,stored_error);
-    return stored_error;
-  }
-
-  State::State (bool singledevice) 
+//namespace isa
+//{
+  State::State (const char* cfg, bool singledevice) 
     : enabled_cpu_features(getCPUFeatures()),
       enabled_builder_cpu_features(enabled_cpu_features)
   {
@@ -133,19 +109,19 @@ namespace embree
 #endif
     hugepages_success = true;
 
-    error_function = nullptr;
-    error_function2 = nullptr;
-    error_function_userptr = nullptr;
-
-    memory_monitor_function = nullptr;
-    memory_monitor_function2 = nullptr;
-    memory_monitor_userptr = nullptr;
+    /* initialize global state */
+    parseString(cfg);
+    if (!ignore_config_files && FileName::executableFolder() != FileName(""))
+      parseFile(FileName::executableFolder()+FileName(".embree" TOSTRING(__EMBREE_VERSION_MAJOR__)));
+    if (!ignore_config_files && FileName::homeFolder() != FileName(""))
+      parseFile(FileName::homeFolder()+FileName(".embree" TOSTRING(__EMBREE_VERSION_MAJOR__)));
+    verify();
   }
 
   State::~State() {
   }
 
-  bool State::hasISA(const int isa) {
+  bool State::hasISA(const int isa) const {
     return (enabled_cpu_features & isa) == isa;
   }
 
@@ -153,30 +129,6 @@ namespace embree
   {
     /* verify that calculations stay in range */
     assert(rcp(min_rcp_input)*FLT_LARGE+FLT_LARGE < 0.01f*FLT_MAX);
-
-    /* here we verify that CPP files compiled for a specific ISA only
-     * call that same or lower ISA version of non-inlined class member
-     * functions */
-#if defined(DEBUG)
-#if defined(__TARGET_SSE2__)
-    assert(sse2::getISA() <= SSE2);
-#endif
-#if defined(__TARGET_SSE42__)
-    assert(sse42::getISA() <= SSE42);
-#endif
-#if defined(__TARGET_AVX__)
-    assert(avx::getISA() <= AVX);
-#endif
-#if defined(__TARGET_AVX2__)
-    assert(avx2::getISA() <= AVX2);
-#endif
-#if defined (__TARGET_AVX512KNL__)
-    assert(avx512knl::getISA() <= AVX512KNL);
-#endif
-#if defined (__TARGET_AVX512SKX__)
-    assert(avx512skx::getISA() <= AVX512SKX);
-#endif
-#endif
   }
 
   const char* symbols[3] = { "=", ",", "|" };
@@ -472,4 +424,5 @@ namespace embree
     std::cout << "  min_leaf_size = " << object_accel_mb_min_leaf_size << std::endl;
     std::cout << "  max_leaf_size = " << object_accel_mb_max_leaf_size << std::endl;
   }
+//}
 }

kernels/common/state.h

@@ -20,11 +20,13 @@
 
 namespace embree
 {
+//namespace isa
+//{
   struct State
   {
   public:
     /*! state construction */
-    State (bool singledevice);
+    State (const char* cfg, bool singledevice);
 
     /*! state destruction */
     ~State();
@@ -48,7 +50,7 @@ namespace embree
     bool verbosity(size_t N);
 
     /*! checks if some particular ISA is enabled */
-    bool hasISA(const int isa);
+    bool hasISA(const int isa) const;
 
   public:
     std::string tri_accel;                 //!< acceleration structure to use for triangles
@@ -131,59 +133,6 @@ namespace embree
     bool enable_selockmemoryprivilege;     //!< configures the SeLockMemoryPrivilege under Windows to enable huge pages
     bool hugepages;                        //!< true if huge pages should get used
     bool hugepages_success;                //!< status for enabling huge pages
-
-  public:
-    struct ErrorHandler
-    {
-    public:
-      ErrorHandler();
-      ~ErrorHandler();
-      RTCError* error();
-
-    public:
-      tls_t thread_error;
-      std::vector<RTCError*> thread_errors;
-      MutexSys errors_mutex;
-    };
-    ErrorHandler errorHandler;
-    static ErrorHandler g_errorHandler;
-
-  public:
-    void setErrorFunction(RTCErrorFunc fptr) 
-    {
-      error_function = fptr;
-      error_function2 = nullptr;
-      error_function_userptr = nullptr;
-    }
-    
-    void setErrorFunction(RTCErrorFunc2 fptr, void* uptr) 
-    {
-      error_function = nullptr;
-      error_function2 = fptr;
-      error_function_userptr = uptr;
-    }
-
-    RTCErrorFunc error_function;
-    RTCErrorFunc2 error_function2;
-    void* error_function_userptr;
-
-  public:
-    void setMemoryMonitorFunction(RTCMemoryMonitorFunc fptr) 
-    {
-      memory_monitor_function = fptr;
-      memory_monitor_function2 = nullptr;
-      memory_monitor_userptr = nullptr;
-    }
-    
-    void setMemoryMonitorFunction(RTCMemoryMonitorFunc2 fptr, void* uptr) 
-    {
-      memory_monitor_function = nullptr;
-      memory_monitor_function2 = fptr;
-      memory_monitor_userptr = uptr;
-    }
-      
-    RTCMemoryMonitorFunc memory_monitor_function;
-    RTCMemoryMonitorFunc2 memory_monitor_function2;
-    void* memory_monitor_userptr;
   };
+//}
 }

kernels/common/vector.h

@@ -17,6 +17,8 @@
 #include "default.h"
 
 namespace embree
+{
+namespace isa
 {
   /*! invokes the memory monitor callback */
   struct MemoryMonitorInterface {
@@ -83,19 +85,23 @@ namespace embree
       bool hugepages;
     };
 }
+}
 
 /*! instantiate vector using monitored aligned allocations */
 #define VECTOR_INIT_ALLOCATOR
 #define vector_t mvector
-#define allocator_t aligned_monitored_allocator<T,std::alignment_of<T>::value>
+#define allocator_t isa::aligned_monitored_allocator<T,std::alignment_of<T>::value>
 #include "../common/sys/vector_t.h"
 #undef vector_t
 #undef allocator_t
 #undef VECTOR_INIT_ALLOCATOR
 
 namespace embree
+{
+namespace isa
 {
   /*! monitored vector */
   //template<typename T> // FIXME: unfortunately not supported in VS2012
   //using mvector = vector_t<T,aligned_monitored_allocator<T,std::alignment_of<T>::value> >;
 }
+}

kernels/geometry/bezier1i.h

@@ -20,6 +20,8 @@
 #include "bezier1v.h"
 
 namespace embree
+{
+namespace isa
 {
   struct Bezier1i
   {
@@ -27,7 +29,7 @@ namespace embree
       Type ();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -81,3 +83,4 @@ namespace embree
     unsigned prim;     //!< primitive ID
   };
 }
+}

kernels/geometry/bezier1v.h

@@ -21,6 +21,8 @@
 #include "../common/primref.h"
 
 namespace embree
+{
+namespace isa
 {
   struct BezierPrim // FIXME: rename to BezierRef, remove!!!
   {
@@ -130,7 +132,7 @@ namespace embree
       Type ();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -220,3 +222,4 @@ namespace embree
     unsigned prim;      //!< primitive ID
   };
 }
+}

kernels/geometry/linei.h

@@ -19,6 +19,8 @@
 #include "primitive.h"
 
 namespace embree
+{
+namespace isa
 {
   template <int M>
   struct LineMi
@@ -31,7 +33,7 @@ namespace embree
       Type();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -250,8 +252,9 @@ namespace embree
     p1 = lerp(a1,b1,ftime);
   }
 
-  template<int M>
-  typename LineMi<M>::Type LineMi<M>::type;
+  //template<int M>
+  //typename LineMi<M>::Type LineMi<M>::type;
 
   typedef LineMi<4> Line4i;
 }
+}

kernels/geometry/object.h

@@ -19,6 +19,8 @@
 #include "primitive.h"
 
 namespace embree
+{
+namespace isa
 {
   struct Object
   {
@@ -27,7 +29,7 @@ namespace embree
       Type ();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -71,3 +73,4 @@ namespace embree
     unsigned primID;  //!< primitive ID
   };
 }
+}

kernels/geometry/primitive.cpp

@@ -30,6 +30,8 @@
 #include "object.h"
 
 namespace embree
+{
+namespace isa
 {
   /********************** Bezier1v **************************/
 
@@ -40,7 +42,11 @@ namespace embree
     return 1;
   }
 
-  Bezier1v::Type Bezier1v::type;
+  const Bezier1v::Type& Bezier1v::type() 
+  {
+    static Bezier1v::Type ty;
+    return ty;
+  }
 
   /********************** Bezier1i **************************/
 
@@ -51,7 +57,11 @@ namespace embree
     return 1;
   }
 
-  Bezier1i::Type Bezier1i::type;
+  const Bezier1i::Type& Bezier1i::type() 
+  {
+    static Bezier1i::Type ty;
+    return ty;
+  }
 
   /********************** Line4i **************************/
 
@@ -63,6 +73,13 @@ namespace embree
   size_t Line4i::Type::size(const char* This) const {
     return ((Line4i*)This)->size();
   }
+
+  template<>
+  const Line4i::Type& Line4i::type() 
+  {
+    static Line4i::Type ty;
+    return ty;
+  }
   
   /********************** Triangle4 **************************/
 
@@ -75,6 +92,13 @@ namespace embree
     return ((Triangle4*)This)->size();
   }
 
+  template<>
+  const Triangle4::Type& Triangle4::type() 
+  {
+    static Triangle4::Type ty;
+    return ty;
+  }
+
   /********************** Triangle4v **************************/
 
   template<>
@@ -86,6 +110,13 @@ namespace embree
     return ((Triangle4v*)This)->size();
   }
 
+  template<>
+  const Triangle4v::Type& Triangle4v::type() 
+  {
+    static Triangle4v::Type ty;
+    return ty;
+  }
+
   /********************** Triangle4i **************************/
 
   template<>
@@ -97,6 +128,13 @@ namespace embree
     return ((Triangle4i*)This)->size();
   }
 
+  template<>
+  const Triangle4i::Type& Triangle4i::type() 
+  {
+    static Triangle4i::Type ty;
+    return ty;
+  }
+
   /********************** Triangle4vMB **************************/
 
   template<>
@@ -108,6 +146,13 @@ namespace embree
     return ((Triangle4vMB*)This)->size();
   }
 
+  template<>
+  const Triangle4vMB::Type& Triangle4vMB::type() 
+  {
+    static Triangle4vMB::Type ty;
+    return ty;
+  }
+
   /********************** Triangle4iMB **************************/
 
   template<>
@@ -119,6 +164,13 @@ namespace embree
     return ((Triangle4iMB*)This)->size();
   }
 
+  template<>
+  const Triangle4iMB::Type& Triangle4iMB::type() 
+  {
+    static Triangle4iMB::Type ty;
+    return ty;
+  }
+
   /********************** Quad4v **************************/
 
   template<>
@@ -130,6 +182,13 @@ namespace embree
     return ((Quad4v*)This)->size();
   }
 
+  template<>
+  const Quad4v::Type& Quad4v::type() 
+  {
+    static Quad4v::Type ty;
+    return ty;
+  }
+
   /********************** Quad4i **************************/
 
   template<>
@@ -141,6 +200,13 @@ namespace embree
     return ((Quad4i*)This)->size();
   }
 
+  template<>
+  const Quad4i::Type& Quad4i::type() 
+  {
+    static Quad4i::Type ty;
+    return ty;
+  }
+
   /********************** Quad4iMB **************************/
 
   template<>
@@ -152,6 +218,13 @@ namespace embree
     return ((Quad4iMB*)This)->size();
   }
 
+  template<>
+  const Quad4iMB::Type& Quad4iMB::type() 
+  {
+    static Quad4iMB::Type ty;
+    return ty;
+  }
+
   /********************** SubdivPatch1 **************************/
 
   SubdivPatch1Cached::Type::Type () 
@@ -161,7 +234,11 @@ namespace embree
     return 1;
   }
 
-  SubdivPatch1Cached::Type SubdivPatch1Cached::type;
+  const SubdivPatch1Cached::Type& SubdivPatch1Cached::type() 
+  {
+    static SubdivPatch1Cached::Type ty;
+    return ty;
+  }
 
   /********************** SubdivPatch1Cached **************************/
 
@@ -172,7 +249,11 @@ namespace embree
     return 1;
   }
 
-  SubdivPatch1Cached::TypeCached SubdivPatch1Cached::type_cached;
+  const SubdivPatch1Cached::TypeCached& SubdivPatch1Cached::type_cached() 
+  {
+    static SubdivPatch1Cached::TypeCached ty;
+    return ty;
+  }
 
   /********************** Virtual Object **************************/
 
@@ -183,5 +264,10 @@ namespace embree
     return 1;
   }
 
-  Object::Type Object::type;
+  const Object::Type& Object::type() 
+  {
+    static Object::Type ty;
+    return ty;
+  }
+}
 }

kernels/geometry/primitive.h

@@ -22,6 +22,8 @@
 #include "../common/primref.h"
 
 namespace embree
+{
+namespace isa
 {
   struct PrimitiveType
   {
@@ -151,3 +153,4 @@ namespace embree
       : RayKPrecalculationsMB<K>(valid, ray, numTimeSteps), Precalculations(valid, ray) {}
   };
 }
+}

kernels/geometry/quadi.h

@@ -20,6 +20,8 @@
 #include "../common/scene.h"
 
 namespace embree
+{
+namespace isa
 {
   /* Stores M quads from an indexed face set */
   template <int M>
@@ -33,7 +35,7 @@ namespace embree
       Type();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -262,8 +264,9 @@ namespace embree
 
 #endif
 
-  template<int M>
-  typename QuadMi<M>::Type QuadMi<M>::type;
+  //template<int M>
+  //typename QuadMi<M>::Type QuadMi<M>::type;
 
   typedef QuadMi<4> Quad4i;
 }
+}

kernels/geometry/quadi_mb.h

@@ -20,6 +20,8 @@
 #include "../common/scene.h"
 
 namespace embree
+{
+namespace isa
 {
   /* Stores M motion blur quads from an indexed face set */
   template <int M>
@@ -33,7 +35,7 @@ namespace embree
       Type();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -281,9 +283,10 @@ namespace embree
     p2 = lerp(a2,b2,ftime);
     p3 = lerp(a3,b3,ftime);
   }
-
-  template<int M>
-  typename QuadMiMB<M>::Type QuadMiMB<M>::type;
+  
+  //template<int M>
+  //typename QuadMiMB<M>::Type QuadMiMB<M>::type;
 
   typedef QuadMiMB<4> Quad4iMB;
 }
+}

kernels/geometry/quadv.h

@@ -19,6 +19,8 @@
 #include "primitive.h"
 
 namespace embree
+{
+namespace isa
 {
   /* Stores the vertices of M quads in struct of array layout */
   template <int M>
@@ -32,7 +34,7 @@ namespace embree
       Type();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -168,8 +170,9 @@ namespace embree
     vint<M> primIDs; // primitive ID
   };
 
-  template<int M>
-  typename QuadMv<M>::Type QuadMv<M>::type;
+  //template<int M>
+  //typename QuadMv<M>::Type QuadMv<M>::type;
 
   typedef QuadMv<4> Quad4v;
 }
+}

kernels/geometry/subdivpatch1cached.h

@@ -21,7 +21,8 @@
 
 namespace embree
 {
-
+namespace isa
+{
   struct __aligned(64) SubdivPatch1Cached : public SubdivPatch1Base
   {
     struct Type : public PrimitiveType 
@@ -30,7 +31,7 @@ namespace embree
       size_t size(const char* This) const;
     };
     
-    static Type type;
+    static const Type& type();
 
     struct TypeCached : public PrimitiveType 
     {
@@ -38,7 +39,7 @@ namespace embree
       size_t size(const char* This) const;
     };
     
-    static TypeCached type_cached;
+    static const TypeCached& type_cached();
 
   public:
 
@@ -55,3 +56,4 @@ namespace embree
       : SubdivPatch1Base(gID,pID,subPatch,mesh,time,uv,edge_level,subdiv,simd_width) {}
   };
 }
+}

kernels/geometry/triangle.h

@@ -19,6 +19,8 @@
 #include "primitive.h"
 
 namespace embree
+{
+namespace isa
 {
   /* Precalculated representation for M triangles. Stores for each
      triangle a base vertex, two edges, and the geometry normal to
@@ -34,7 +36,7 @@ namespace embree
       Type();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
     
   public:
 
@@ -169,8 +171,9 @@ namespace embree
     vint<M> primIDs; // primitive IDs
   };
 
-  template<int M>
-  typename TriangleM<M>::Type TriangleM<M>::type;
+  //template<int M>
+  //typename TriangleM<M>::Type TriangleM<M>::type;
 
   typedef TriangleM<4> Triangle4;
 }
+}

kernels/geometry/trianglei.h

@@ -19,6 +19,8 @@
 #include "primitive.h"
 
 namespace embree
+{
+namespace isa
 {
   /* Stores M triangles from an indexed face set */
   template <int M>
@@ -32,7 +34,7 @@ namespace embree
       Type();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -174,8 +176,9 @@ namespace embree
     }
   }
 
-  template<int M>
-  typename TriangleMi<M>::Type TriangleMi<M>::type;
+  //template<int M>
+  //typename TriangleMi<M>::Type TriangleMi<M>::type;
 
   typedef TriangleMi<4> Triangle4i;
 }
+}

kernels/geometry/trianglei_mb.h

@@ -20,6 +20,8 @@
 #include "../common/scene.h"
 
 namespace embree
+{
+namespace isa
 {
   /* Stores M motion blur triangles from an indexed face set */
   template <int M>
@@ -33,7 +35,7 @@ namespace embree
       Type();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -275,8 +277,9 @@ namespace embree
     p2 = lerp(a2,b2,ftime);
   }
 
-  template<int M>
-  typename TriangleMiMB<M>::Type TriangleMiMB<M>::type;
+  //template<int M>
+  //typename TriangleMiMB<M>::Type TriangleMiMB<M>::type;
 
   typedef TriangleMiMB<4> Triangle4iMB;
 }
+}

kernels/geometry/trianglev.h

@@ -19,6 +19,8 @@
 #include "primitive.h"
 
 namespace embree
+{
+namespace isa
 {
   /* Stores the vertices of M triangles in struct of array layout */
   template <int M>
@@ -32,7 +34,7 @@ namespace embree
       Type();
       size_t size(const char* This) const;
     };
-    static Type type;
+    static const Type& type();
 
   public:
 
@@ -160,8 +162,9 @@ namespace embree
     vint<M> primIDs; // primitive ID
   };
 
-  template<int M>
-  typename TriangleMv<M>::Type TriangleMv<M>::type;
+  //template<int M>
+  //typename TriangleMv<M>::Type TriangleMv<M>::type;
 
   typedef TriangleMv<4> Triangle4v;
 }
+}

kernels/geometry/trianglev_mb.h

@@ -19,6 +19,8 @@
 #include "primitive.h"
 
 namespace embree
+{
+namespace isa
 {
   /* Stores the vertices of M triangles in struct of array layout */
   template<int M>
@@ -33,7 +35,7 @@ namespace embree
       size_t size(const char* This) const;
     };
 
-    static Type type;
+    static const Type& type();
 
   public:
     
@@ -161,8 +163,9 @@ namespace embree
     vint<M> primIDs; // primitive ID
   };
 
-  template<int M>
-  typename TriangleMvMB<M>::Type TriangleMvMB<M>::type;
+  //template<int M>
+  //typename TriangleMvMB<M>::Type TriangleMvMB<M>::type;
 
   typedef TriangleMvMB<4> Triangle4vMB;
 }
+}

kernels/subdiv/bezier_curve.cpp

@@ -18,6 +18,8 @@
 
 namespace embree
 {
+//namespace isa
+//{
   PrecomputedBezierBasis::PrecomputedBezierBasis(int dj)
   {
     for (size_t i=0; i<=N; i++) 
@@ -40,4 +42,5 @@ namespace embree
   }
   PrecomputedBezierBasis bezier_basis0(0);
   PrecomputedBezierBasis bezier_basis1(1);
+//}
 }

kernels/subdiv/bezier_curve.h

@@ -20,6 +20,8 @@
 
 namespace embree
 {
+//namespace isa
+//{
   class BezierBasis
   {
   public:
@@ -107,6 +109,9 @@ namespace embree
   extern PrecomputedBezierBasis bezier_basis0;
   extern PrecomputedBezierBasis bezier_basis1;
 
+  namespace isa
+  {
+
   template<typename Vertex>
     struct BezierCurveT
     {
@@ -333,4 +338,5 @@ namespace embree
   #define CurveT BezierCurveT
   typedef BezierCurve3fa Curve3fa;
 #endif
+  }
 }

kernels/subdiv/bezier_patch.h

@@ -21,6 +21,8 @@
 
 namespace embree
 {  
+namespace isa
+{
   template<class T, class S>
     static __forceinline T deCasteljau(const S& uu, const T& v0, const T& v1, const T& v2, const T& v3)
   {
@@ -383,3 +385,4 @@ namespace embree
 
   typedef BezierPatchT<Vec3fa,Vec3fa_t> BezierPatch3fa;
 }
+}

kernels/subdiv/bilinear_patch.h

@@ -20,6 +20,8 @@
 #include "bezier_curve.h"
 
 namespace embree
+{
+namespace isa
 {
   template<typename Vertex, typename Vertex_t = Vertex>
     class __aligned(64) BilinearPatchT
@@ -202,3 +204,4 @@ namespace embree
   
   typedef BilinearPatchT<Vec3fa,Vec3fa_t> BilinearPatch3fa;
 }
+}

kernels/subdiv/bspline_curve.cpp

@@ -18,6 +18,8 @@
 
 namespace embree
 {
+//namespace isa
+//{
   PrecomputedBSplineBasis::PrecomputedBSplineBasis(int dj)
   {
     for (size_t i=0; i<=N; i++) 
@@ -40,4 +42,5 @@ namespace embree
   }
   PrecomputedBSplineBasis bspline_basis0(0);
   PrecomputedBSplineBasis bspline_basis1(1);
+//}
 }

kernels/subdiv/bspline_curve.h

@@ -21,6 +21,8 @@
 
 namespace embree
 {
+//namespace isa
+//{
   class BSplineBasis2 // FIXME: make compatible with basis from bspline_patch.h
   {
   public:
@@ -108,6 +110,9 @@ namespace embree
   extern PrecomputedBSplineBasis bspline_basis0;
   extern PrecomputedBSplineBasis bspline_basis1;
 
+  namespace isa
+  {
+
   template<typename Vertex>
     struct BSplineCurveT
     {
@@ -356,4 +361,5 @@ namespace embree
   #define CurveT BSplineCurveT
   typedef BSplineCurve3fa Curve3fa;
 #endif
+  }
 }

kernels/subdiv/bspline_patch.h

@@ -20,6 +20,8 @@
 #include "bspline_curve.h"
 
 namespace embree
+{
+namespace isa
 {
   class BSplineBasis // FIXME: factor of 1.0f/6.0f should be inside basis
   {
@@ -501,3 +503,4 @@ namespace embree
   
   typedef BSplinePatchT<Vec3fa,Vec3fa_t> BSplinePatch3fa;
 }
+}

kernels/subdiv/catmullclark_coefficients.cpp

@@ -16,9 +16,10 @@
 
 #include "catmullclark_coefficients.h"
 
-
 namespace embree
 {
+//namespace isa
+//{
   CatmullClarkPrecomputedCoefficients CatmullClarkPrecomputedCoefficients::table;
 
   CatmullClarkPrecomputedCoefficients::CatmullClarkPrecomputedCoefficients()
@@ -51,4 +52,5 @@ namespace embree
       delete [] table_limittangent_b[n];
     }
   }
+//}
 }

kernels/subdiv/catmullclark_coefficients.h

@@ -20,6 +20,8 @@
 
 namespace embree
 {
+//namespace isa
+//{
   static const size_t MAX_PATCH_VALENCE = 16;         //!< maximal number of vertices of a patch
   static const size_t MAX_RING_FACE_VALENCE = 32;     //!< maximal number of faces per ring
   static const size_t MAX_RING_EDGE_VALENCE = 2*32;   //!< maximal number of edges per ring
@@ -95,4 +97,5 @@ namespace embree
     CatmullClarkPrecomputedCoefficients();    
     ~CatmullClarkPrecomputedCoefficients();    
   };
+//}
 }

kernels/subdiv/catmullclark_patch.h

@@ -20,6 +20,8 @@
 #include "bezier_curve.h"
 
 namespace embree
+{
+namespace isa
 {
   template<typename Vertex, typename Vertex_t = Vertex>
     class __aligned(64) CatmullClarkPatchT
@@ -573,3 +575,4 @@ namespace embree
   
   typedef GeneralCatmullClarkPatchT<Vec3fa,Vec3fa_t> GeneralCatmullClarkPatch3fa;
 }
+}

kernels/subdiv/catmullclark_ring.h

@@ -22,6 +22,8 @@
 #include "catmullclark_coefficients.h"
 
 namespace embree
+{
+namespace isa
 {
   struct __aligned(64) FinalQuad {
     Vec3fa vtx[4];
@@ -833,3 +835,4 @@ namespace embree
     } 
   };  
 }
+}

kernels/subdiv/gregory_patch.h

@@ -23,6 +23,8 @@
 
 namespace embree
 {  
+namespace isa
+{
   template<typename Vertex, typename Vertex_t = Vertex>
   class __aligned(64) GregoryPatchT
   {
@@ -904,3 +906,4 @@ namespace embree
 	  matrix[y][x] = (Vertex_t)gpatch.v[y][x];
     }
 }
+}

kernels/subdiv/gregory_patch_dense.h

@@ -20,6 +20,8 @@
 
 namespace embree
 {  
+namespace isa
+{
   class __aligned(64) DenseGregoryPatch3fa
   {    
   public:
@@ -123,3 +125,4 @@ namespace embree
     Vec3fa matrix[4][4]; // f_p/m points are stored in 4th component
   };
 }
+}

kernels/subdiv/gridrange.h

@@ -19,6 +19,8 @@
 #include "../common/default.h"
 
 namespace embree
+{
+namespace isa
 {
   struct __aligned(16) GridRange
   {
@@ -107,3 +109,4 @@ namespace embree
     }
   };
 }
+}