added support for multi_level instancing mode to scene conversion and viewer

tutorials/buildbench/buildbench_device.cpp

@@ -34,7 +34,7 @@ namespace embree {
     }
     rtcSetSharedGeometryBuffer(geom, RTC_BUFFER_TYPE_INDEX, 0, RTC_FORMAT_UINT3, mesh->triangles, 0, sizeof(ISPCTriangle), mesh->numTriangles);
     rtcCommitGeometry(geom);
-    mesh->geom.geomID = rtcAttachGeometry(scene_out,geom);
+    rtcAttachGeometry(scene_out,geom);
     rtcReleaseGeometry(geom);
   }
 
@@ -48,7 +48,7 @@ namespace embree {
     }
     rtcSetSharedGeometryBuffer(geom, RTC_BUFFER_TYPE_INDEX, 0, RTC_FORMAT_UINT4, mesh->quads, 0, sizeof(ISPCQuad), mesh->numQuads);
     rtcCommitGeometry(geom);
-    mesh->geom.geomID = rtcAttachGeometry(scene_out,geom);
+    rtcAttachGeometry(scene_out,geom);
     rtcReleaseGeometry(geom);
   }
 
@@ -71,7 +71,7 @@ namespace embree {
     rtcSetSharedGeometryBuffer(geom, RTC_BUFFER_TYPE_VERTEX_CREASE_WEIGHT, 0, RTC_FORMAT_FLOAT, mesh->vertex_crease_weights, 0, sizeof(float),          mesh->numVertexCreases);
     rtcSetGeometrySubdivisionMode(geom, 0, mesh->position_subdiv_mode);
     rtcCommitGeometry(geom);
-    mesh->geom.geomID = rtcAttachGeometry(scene_out,geom);
+    rtcAttachGeometry(scene_out,geom);
     rtcReleaseGeometry(geom);
   }
 
@@ -88,7 +88,7 @@ namespace embree {
     if (hair->type != RTC_GEOMETRY_TYPE_FLAT_LINEAR_CURVE)
       rtcSetGeometryTessellationRate(geom,(float)hair->tessellation_rate);
     rtcCommitGeometry(geom);
-    hair->geom.geomID = rtcAttachGeometry(scene_out,geom);
+    rtcAttachGeometry(scene_out,geom);
     rtcReleaseGeometry(geom);
   }
 
@@ -154,26 +154,22 @@ namespace embree {
     return scene_in->numGeometries;
   }
 
-  void updateObjects(ISPCScene* scene_in, RTCScene scene_out)  // FIXME: geomID can be accessed easier now
+  void updateObjects(ISPCScene* scene_in, RTCScene scene_out)
   {
     size_t numGeometries = scene_in->numGeometries;
     for (size_t i=0; i<numGeometries; i++)
     {
-      ISPCGeometry* geometry = scene_in->geometries[i];
-      RTCGeometry geom = rtcGetGeometry(scene_out,geometry->geomID);
+      RTCGeometry geom = rtcGetGeometry(scene_out,i);
       rtcUpdateGeometryBuffer(geom,RTC_BUFFER_TYPE_VERTEX, 0);
       rtcCommitGeometry(geom);
     }
   }
 
-  void deleteObjects(ISPCScene* scene_in, RTCScene scene_out) // FIXME: geomID can be accessed easier now
+  void deleteObjects(ISPCScene* scene_in, RTCScene scene_out)
   {
     size_t numGeometries = scene_in->numGeometries;
     for (size_t i=0; i<numGeometries; i++)
-    {
-      ISPCGeometry* geometry = scene_in->geometries[i];
-      rtcDetachGeometry(scene_out,geometry->geomID);
-    }
+      rtcDetachGeometry(scene_out,i);
   }
   
 #ifdef USE_GOOGLE_BENCHMARK

tutorials/common/scenegraph/scenegraph.cpp

@@ -1750,14 +1750,15 @@ namespace embree
     
     SceneGraphFlattener (Ref<SceneGraph::Node> in, SceneGraph::InstancingMode instancing)
     {
-       in->calculateInDegree();
-       in->calculateClosed(instancing == SceneGraph::INSTANCING_GROUP);
+      in->calculateInDegree();
+      in->calculateClosed(instancing == SceneGraph::INSTANCING_GROUP);
 
       std::vector<Ref<SceneGraph::Node>> geometries;      
       if (instancing != SceneGraph::INSTANCING_NONE) 
       {
-        if (instancing == SceneGraph::INSTANCING_FLATTENED) convertFlattenedInstances(geometries,in);
-        else                                                convertInstances(geometries,in,one);
+        if      (instancing == SceneGraph::INSTANCING_FLATTENED  ) convertFlattenedInstances(geometries,in);
+        else if (instancing == SceneGraph::INSTANCING_MULTI_LEVEL) convertMultiLevelInstances(geometries,in);
+        else                                                       convertInstances(geometries,in,one);
         convertLightsAndCameras(geometries,in,one);
       }
       else
@@ -1856,6 +1857,53 @@ namespace embree
       }
     }
 
+    void convertMultiLevelInstances(std::vector<Ref<SceneGraph::Node>>& group, const Ref<SceneGraph::Node>& node)
+    {
+      if (Ref<SceneGraph::GroupNode> groupNode = node.dynamicCast<SceneGraph::GroupNode>()) {
+        for (const auto& child : groupNode->children) convertMultiLevelInstances(group,child);
+      }
+      else if (node.dynamicCast<SceneGraph::TriangleMeshNode>()) {
+        group.push_back(node);
+      }
+      else if (node.dynamicCast<SceneGraph::QuadMeshNode>()) {
+        group.push_back(node);
+      }
+      else if (node.dynamicCast<SceneGraph::GridMeshNode>()) {
+        group.push_back(node);
+      }
+      else if (node.dynamicCast<SceneGraph::SubdivMeshNode>()) {
+        group.push_back(node);
+      }
+      else if (node.dynamicCast<SceneGraph::HairSetNode>()) {
+        group.push_back(node);
+      }
+      else if (node.dynamicCast<SceneGraph::PointSetNode>()) {
+        group.push_back(node);
+      }
+      else if (object_mapping.find(node) != object_mapping.end()) {
+        group.push_back(object_mapping[node]);
+      }
+      else if (Ref<SceneGraph::TransformNode> xfmNode = node.dynamicCast<SceneGraph::TransformNode>())
+      {
+        auto new_node = new SceneGraph::TransformNode(xfmNode->spaces,convertMultiLevelInstances(xfmNode->child));
+        object_mapping[node] = new_node;
+        group.push_back(new_node);
+      } 
+    }
+      
+    Ref<SceneGraph::Node> convertMultiLevelInstances(const Ref<SceneGraph::Node>& node)
+    {
+      if (object_mapping.find(node) != object_mapping.end()) {
+        return object_mapping[node];
+      }
+      
+      std::vector<Ref<SceneGraph::Node>> group;
+      convertMultiLevelInstances(group,node);
+      auto new_node = new SceneGraph::GroupNode(group);
+      object_mapping[node] = new_node;
+      return new_node;
+    }
+
     void convertFlattenedInstances(std::vector<Ref<SceneGraph::Node>>& group, const Ref<SceneGraph::Node>& node)
     {
       if (Ref<SceneGraph::TransformNode> xfmNode = node.dynamicCast<SceneGraph::TransformNode>()) {

tutorials/common/scenegraph/scenegraph.h

@@ -1345,7 +1345,7 @@ namespace embree
     };
 
     
-    enum InstancingMode { INSTANCING_NONE, INSTANCING_GEOMETRY, INSTANCING_GROUP, INSTANCING_FLATTENED };
+    enum InstancingMode { INSTANCING_NONE, INSTANCING_GEOMETRY, INSTANCING_GROUP, INSTANCING_FLATTENED, INSTANCING_MULTI_LEVEL };
     Ref<Node> flatten(Ref<Node> node, InstancingMode mode);
     Ref<GroupNode> flatten(Ref<GroupNode> node, InstancingMode mode);
 

tutorials/common/tutorial/scene.cpp

@@ -20,28 +20,15 @@ namespace embree
       if (Ref<SceneGraph::LightNode> lightNode = node.dynamicCast<SceneGraph::LightNode>()) {
         lights.push_back(lightNode->light);
       } 
-      else if (Ref<SceneGraph::TransformNode> xfmNode = node.dynamicCast<SceneGraph::TransformNode>()) {
-        addGeometry(xfmNode->child);
-        addGeometry(node);
-      }
       else if (Ref<SceneGraph::PerspectiveCameraNode> cameraNode = node.dynamicCast<SceneGraph::PerspectiveCameraNode>()) {
         cameras.push_back(cameraNode);
       } 
       else {
-        addGeometry(node);
+        geometries.push_back(node);
       }
     }
   }
-  
-  unsigned TutorialScene::addGeometry(Ref<SceneGraph::Node> node) 
-  {
-    if (node->id == -1) {
-      geometries.push_back(node);
-      node->id = unsigned(geometries.size()-1);
-    }
-    return node->id;
-  }
-  
+
   unsigned TutorialScene::materialID(Ref<SceneGraph::MaterialNode> material) 
   {
     if (material->id == -1) {
@@ -51,12 +38,6 @@ namespace embree
     return material->id;
   }
   
-  unsigned TutorialScene::geometryID(Ref<SceneGraph::Node> geometry) 
-  {
-    assert(geometry->id != -1);
-    return geometry->id;
-  }
-  
   void TutorialScene::print_camera_names ()
   {
     if (cameras.size() == 0) {

tutorials/common/tutorial/scene.h

@@ -29,9 +29,7 @@ namespace embree
     ~TutorialScene();
     
     void add (Ref<SceneGraph::GroupNode> node);
-    unsigned addGeometry(Ref<SceneGraph::Node> node);
     unsigned materialID(Ref<SceneGraph::MaterialNode> material);
-    unsigned geometryID(Ref<SceneGraph::Node> geometry);
     void print_camera_names ();
     Ref<SceneGraph::PerspectiveCameraNode> getDefaultCamera();
     Ref<SceneGraph::PerspectiveCameraNode> getCamera(const std::string& name);

tutorials/common/tutorial/scene_device.cpp

@@ -11,8 +11,9 @@ namespace embree
   extern "C" {
     int g_instancing_mode = SceneGraph::INSTANCING_NONE;
     float g_min_width_max_radius_scale = 1.0f;
+    AssignShaderTy assignShadersFunc = nullptr;
   }
-
+  
   void deleteGeometry(ISPCGeometry* geom)
   {
     switch (geom->type) {
@@ -327,7 +328,6 @@ namespace embree
     : geom(INSTANCE), numTimeSteps(unsigned(in->spaces.size())) 
   {
     spaces = (AffineSpace3fa*) alignedMalloc(in->spaces.size()*sizeof(AffineSpace3fa),16);
-    geom.geomID = scene->geometryID(in->child);
     child = ISPCScene::convertGeometry(scene,in->child);
     startTime  = in->spaces.time_range.lower;
     endTime    = in->spaces.time_range.upper;
@@ -386,7 +386,7 @@ namespace embree
     return geom;
   }
 
-  unsigned int ConvertTriangleMesh(RTCDevice device, ISPCTriangleMesh* mesh, RTCBuildQuality quality, RTCScene scene_out, unsigned int geomID)
+  unsigned int ConvertTriangleMesh(RTCDevice device, ISPCTriangleMesh* mesh, RTCBuildQuality quality, RTCSceneFlags flags, RTCScene scene_out, unsigned int geomID)
   {
     RTCGeometry geom = rtcNewGeometry (device, RTC_GEOMETRY_TYPE_TRIANGLE);
     rtcSetGeometryTimeStepCount(geom,mesh->numTimeSteps);
@@ -401,11 +401,12 @@ namespace embree
     rtcAttachGeometryByID(scene_out,geom,geomID);
     mesh->geom.geometry = geom;
     mesh->geom.scene = scene_out;
-    mesh->geom.geomID = geomID;
+
+    if (assignShadersFunc) assignShadersFunc(&mesh->geom);
     return geomID;
   }
   
-  unsigned int ConvertQuadMesh(RTCDevice device, ISPCQuadMesh* mesh, RTCBuildQuality quality, RTCScene scene_out, unsigned int geomID)
+  unsigned int ConvertQuadMesh(RTCDevice device, ISPCQuadMesh* mesh, RTCBuildQuality quality, RTCSceneFlags flags, RTCScene scene_out, unsigned int geomID)
   {
     RTCGeometry geom = rtcNewGeometry (device, RTC_GEOMETRY_TYPE_QUAD);
     rtcSetGeometryTimeStepCount(geom,mesh->numTimeSteps);
@@ -420,11 +421,12 @@ namespace embree
     rtcAttachGeometryByID(scene_out,geom,geomID);
     mesh->geom.geometry = geom;
     mesh->geom.scene = scene_out;
-    mesh->geom.geomID = geomID;
+
+    if (assignShadersFunc) assignShadersFunc(&mesh->geom);
     return geomID;
   }
 
-  unsigned int ConvertGridMesh(RTCDevice device, ISPCGridMesh* mesh, RTCBuildQuality quality, RTCScene scene_out, unsigned int geomID)
+  unsigned int ConvertGridMesh(RTCDevice device, ISPCGridMesh* mesh, RTCBuildQuality quality, RTCSceneFlags flags, RTCScene scene_out, unsigned int geomID)
   {
     RTCGeometry geom = rtcNewGeometry (device, RTC_GEOMETRY_TYPE_GRID);
     rtcSetGeometryTimeStepCount(geom,mesh->numTimeSteps);
@@ -439,11 +441,12 @@ namespace embree
     rtcAttachGeometryByID(scene_out,geom,geomID);
     mesh->geom.geometry = geom;
     mesh->geom.scene = scene_out;
-    mesh->geom.geomID = geomID;
+
+    if (assignShadersFunc) assignShadersFunc(&mesh->geom);
     return geomID;
   }
   
-  unsigned int ConvertSubdivMesh(RTCDevice device, ISPCSubdivMesh* mesh, RTCBuildQuality quality, RTCScene scene_out, unsigned int geomID)
+  unsigned int ConvertSubdivMesh(RTCDevice device, ISPCSubdivMesh* mesh, RTCBuildQuality quality, RTCSceneFlags flags, RTCScene scene_out, unsigned int geomID)
   {
     RTCGeometry geom = rtcNewGeometry(device, RTC_GEOMETRY_TYPE_SUBDIVISION);
     rtcSetGeometryTimeStepCount(geom,mesh->numTimeSteps);
@@ -495,11 +498,12 @@ namespace embree
     rtcAttachGeometryByID(scene_out,geom,geomID);
     mesh->geom.geometry = geom;
     mesh->geom.scene = scene_out;
-    mesh->geom.geomID = geomID;
+
+    if (assignShadersFunc) assignShadersFunc(&mesh->geom);
     return geomID;
   }
   
-  unsigned int ConvertCurveGeometry(RTCDevice device, ISPCHairSet* mesh, RTCBuildQuality quality, RTCScene scene_out, unsigned int geomID)
+  unsigned int ConvertCurveGeometry(RTCDevice device, ISPCHairSet* mesh, RTCBuildQuality quality, RTCSceneFlags flags, RTCScene scene_out, unsigned int geomID)
   {
     RTCGeometry geom = rtcNewGeometry(device, mesh->type);
     rtcSetGeometryTimeStepCount(geom,mesh->numTimeSteps);
@@ -547,11 +551,12 @@ namespace embree
     rtcAttachGeometryByID(scene_out,geom,geomID);
     mesh->geom.geometry = geom;
     mesh->geom.scene = scene_out;
-    mesh->geom.geomID = geomID;
+
+    if (assignShadersFunc) assignShadersFunc(&mesh->geom);
     return geomID;
   }
 
-  unsigned int ConvertPoints(RTCDevice device, ISPCPointSet* mesh, RTCBuildQuality quality, RTCScene scene_out, unsigned int geomID)
+  unsigned int ConvertPoints(RTCDevice device, ISPCPointSet* mesh, RTCBuildQuality quality, RTCSceneFlags flags, RTCScene scene_out, unsigned int geomID)
   {
     RTCGeometry geom = rtcNewGeometry(device, mesh->type);
     rtcSetGeometryTimeStepCount(geom,mesh->numTimeSteps);
@@ -577,38 +582,55 @@ namespace embree
     rtcAttachGeometryByID(scene_out,geom,geomID);
     mesh->geom.geometry = geom;
     mesh->geom.scene = scene_out;
-    mesh->geom.geomID = geomID;
+
+    if (assignShadersFunc) assignShadersFunc(&mesh->geom);
     return geomID;
   }
 
-  void ConvertGroup(RTCDevice device, ISPCGroup* group, RTCBuildQuality quality, RTCScene scene_out, unsigned int geomID)
+  unsigned int ConvertInstance(RTCDevice device, ISPCInstance* instance, RTCBuildQuality quality, RTCSceneFlags flags, RTCScene scene_out, unsigned int geomID);
+
+  RTCScene ConvertGroup(RTCDevice device, ISPCGroup* group, RTCBuildQuality quality, RTCSceneFlags flags)
   {
+    if (group->geom.scene)
+      return group->geom.scene;
+    
+    RTCScene scene_out = rtcNewScene(device);
+    rtcSetSceneFlags(scene_out, flags);
+    
     for (unsigned int i=0; i<group->numGeometries; i++)
     {
       ISPCGeometry* geometry = group->geometries[i];
       if (geometry->type == SUBDIV_MESH)
-        ConvertSubdivMesh(device,(ISPCSubdivMesh*) geometry, quality, scene_out, i);
+        ConvertSubdivMesh(device,(ISPCSubdivMesh*) geometry, quality, flags, scene_out, i);
       else if (geometry->type == TRIANGLE_MESH)
-        ConvertTriangleMesh(device,(ISPCTriangleMesh*) geometry, quality, scene_out, i);
+        ConvertTriangleMesh(device,(ISPCTriangleMesh*) geometry, quality, flags, scene_out, i);
       else if (geometry->type == QUAD_MESH)
-        ConvertQuadMesh(device,(ISPCQuadMesh*) geometry, quality, scene_out, i);
+        ConvertQuadMesh(device,(ISPCQuadMesh*) geometry, quality, flags, scene_out, i);
       else if (geometry->type == CURVES)
-        ConvertCurveGeometry(device,(ISPCHairSet*) geometry, quality, scene_out, i);
+        ConvertCurveGeometry(device,(ISPCHairSet*) geometry, quality, flags, scene_out, i);
       else if (geometry->type == GRID_MESH)
-        ConvertGridMesh(device,(ISPCGridMesh*) geometry, quality, scene_out, i);
+        ConvertGridMesh(device,(ISPCGridMesh*) geometry, quality, flags, scene_out, i);
       else if (geometry->type == POINTS)
-        ConvertPoints(device,(ISPCPointSet*) geometry, quality, scene_out, i);
+        ConvertPoints(device,(ISPCPointSet*) geometry, quality, flags, scene_out, i);
+      else if (geometry->type == INSTANCE)
+        ConvertInstance(device,(ISPCInstance*) geometry, quality, flags, scene_out, i);
       else
         assert(false);
     }
     group->geom.geometry = nullptr;
     group->geom.scene = scene_out;
-    group->geom.geomID = geomID;
+
+    rtcCommitScene(scene_out);
+    return scene_out;
   }
 
-  unsigned int ConvertInstance(RTCDevice device, ISPCScene* scene_in, ISPCInstance* instance, RTCScene scene_out, unsigned int geomID)
+  unsigned int ConvertInstance(RTCDevice device, ISPCInstance* instance, RTCBuildQuality quality, RTCSceneFlags flags, RTCScene scene_out, unsigned int geomID)
   {
-    RTCScene scene_inst = instance->child->scene;
+    if (instance->child->type != GROUP)
+      THROW_RUNTIME_ERROR("invalid scene structure");
+    
+    RTCScene scene_inst = ConvertGroup(device, (ISPCGroup*) instance->child, quality, flags);
+      
     if (instance->numTimeSteps == 1) {
       RTCGeometry geom = rtcNewGeometry (device, RTC_GEOMETRY_TYPE_INSTANCE);
       rtcSetGeometryInstancedScene(geom,scene_inst);
@@ -624,7 +646,6 @@ namespace embree
       rtcAttachGeometryByID(scene_out,geom,geomID);
       instance->geom.geometry = geom;
       instance->geom.scene = scene_out;
-      instance->geom.geomID = geomID;
       return geomID;
     }
     else
@@ -646,7 +667,6 @@ namespace embree
       rtcAttachGeometryByID(scene_out,geom,geomID);
       instance->geom.geometry = geom;
       instance->geom.scene = scene_out;
-      instance->geom.geomID = geomID;
       return geomID;
     }
   }
@@ -654,50 +674,30 @@ namespace embree
   typedef ISPCInstance* ISPCInstance_ptr;
   typedef ISPCGeometry* ISPCGeometry_ptr;
   
-  extern "C" RTCScene ConvertScene(RTCDevice g_device, ISPCScene* scene_in, RTCBuildQuality quality)
+  extern "C" RTCScene ConvertScene(RTCDevice g_device, ISPCScene* scene_in, RTCBuildQuality quality, RTCSceneFlags flags)
   {
     RTCScene scene_out = rtcNewScene(g_device);
+    rtcSetSceneFlags(scene_out, flags);
     
-    /* use scene instancing feature */
-    if (g_instancing_mode != SceneGraph::INSTANCING_NONE)
+    for (unsigned int i=0; i<scene_in->numGeometries; i++)
     {
-      for (unsigned int i=0; i<scene_in->numGeometries; i++)
-      {
-        ISPCGeometry* geometry = scene_in->geometries[i];
-        if (geometry->type == GROUP) {
-          RTCScene objscene = rtcNewScene(g_device);
-          ConvertGroup(g_device,(ISPCGroup*) geometry,quality,objscene,i);
-          //rtcCommitScene(objscene);
-        }
-        else if (geometry->type == INSTANCE) {
-          ConvertInstance(g_device,scene_in, (ISPCInstance*) geometry, scene_out, i);
-        }
-        else
-          assert(false);
-      }
-    }
-    
-    /* no instancing */
-    else
-    {
-      for (unsigned int i=0; i<scene_in->numGeometries; i++)
-      {
-        ISPCGeometry* geometry = scene_in->geometries[i];
-        if (geometry->type == SUBDIV_MESH)
-          ConvertSubdivMesh(g_device,(ISPCSubdivMesh*) geometry, quality, scene_out, i);
-        else if (geometry->type == TRIANGLE_MESH)
-          ConvertTriangleMesh(g_device,(ISPCTriangleMesh*) geometry, quality, scene_out, i);
-        else if (geometry->type == QUAD_MESH)
-          ConvertQuadMesh(g_device,(ISPCQuadMesh*) geometry, quality, scene_out, i);
-        else if (geometry->type == CURVES)
-          ConvertCurveGeometry(g_device,(ISPCHairSet*) geometry, quality, scene_out, i);
-         else if (geometry->type == GRID_MESH)
-          ConvertGridMesh(g_device,(ISPCGridMesh*) geometry, quality, scene_out, i);
-         else if (geometry->type == POINTS)
-          ConvertPoints(g_device,(ISPCPointSet*) geometry, quality, scene_out, i);
-        else
-          assert(false);
-      }
+      ISPCGeometry* geometry = scene_in->geometries[i];
+      if (geometry->type == SUBDIV_MESH)
+        ConvertSubdivMesh(g_device,(ISPCSubdivMesh*) geometry, quality, flags, scene_out, i);
+      else if (geometry->type == TRIANGLE_MESH)
+        ConvertTriangleMesh(g_device,(ISPCTriangleMesh*) geometry, quality, flags, scene_out, i);
+      else if (geometry->type == QUAD_MESH)
+        ConvertQuadMesh(g_device,(ISPCQuadMesh*) geometry, quality, flags, scene_out, i);
+      else if (geometry->type == CURVES)
+        ConvertCurveGeometry(g_device,(ISPCHairSet*) geometry, quality, flags, scene_out, i);
+      else if (geometry->type == GRID_MESH)
+        ConvertGridMesh(g_device,(ISPCGridMesh*) geometry, quality, flags, scene_out, i);
+      else if (geometry->type == POINTS)
+        ConvertPoints(g_device,(ISPCPointSet*) geometry, quality, flags, scene_out, i);
+      else if (geometry->type == INSTANCE)
+        ConvertInstance(g_device, (ISPCInstance*) geometry, quality, flags, scene_out, i);
+      else
+        assert(false);
     }
 
     Application::instance->log(1,"creating Embree objects done");

tutorials/common/tutorial/scene_device.h

@@ -66,13 +66,13 @@ namespace embree
   struct ISPCGeometry
   {
 #if !defined(ISPC)
-    ISPCGeometry (ISPCType type) : type(type), geometry(nullptr), scene(nullptr), geomID(-1), materialID(-1) {}
+    ISPCGeometry (ISPCType type) : type(type), geometry(nullptr), scene(nullptr), unused(-1), materialID(-1) {}
     ~ISPCGeometry () { if (geometry) rtcReleaseGeometry(geometry); }
 #endif
     ISPCType type;
     RTCGeometry geometry;
     RTCScene scene;
-    unsigned int geomID;
+    unsigned int unused;
     unsigned int materialID;
   };
 
@@ -327,10 +327,18 @@ namespace embree
     unsigned int numLights;               //!< number of lights
   };
 
-#if !defined(ISPC)  
-  extern "C" RTCScene ConvertScene(RTCDevice g_device, ISPCScene* scene_in, RTCBuildQuality quality);
+#if !defined(ISPC)
+  typedef void (*AssignShaderTy)(ISPCGeometry* geometry);
+  extern "C" { extern AssignShaderTy assignShadersFunc; };
 #else
-  unmasked extern "C" RTCScene ConvertScene (RTCDevice g_device, ISPCScene* uniform scene_in, uniform RTCBuildQuality quality);
+  typedef unmasked void (*AssignShaderTy)(uniform ISPCGeometry* uniform geometry);
+  extern uniform AssignShaderTy assignShadersFunc;
+#endif
+  
+#if !defined(ISPC)  
+  extern "C" RTCScene ConvertScene(RTCDevice g_device, ISPCScene* scene_in, RTCBuildQuality quality, RTCSceneFlags flags = RTC_SCENE_FLAG_NONE);
+#else
+  unmasked extern "C" RTCScene ConvertScene (RTCDevice g_device, ISPCScene* uniform scene_in, uniform RTCBuildQuality quality, uniform RTCSceneFlags flags = RTC_SCENE_FLAG_NONE);
 #endif
 
 #if !defined(ISPC)                    

tutorials/common/tutorial/tutorial.cpp

@@ -435,12 +435,14 @@ namespace embree
         else if (mode == "geometry") instancing_mode = SceneGraph::INSTANCING_GEOMETRY;
         else if (mode == "group"   ) instancing_mode = SceneGraph::INSTANCING_GROUP;
         else if (mode == "flattened") instancing_mode = SceneGraph::INSTANCING_FLATTENED;
+        else if (mode == "multi_level") instancing_mode = SceneGraph::INSTANCING_MULTI_LEVEL;
         else throw std::runtime_error("unknown instancing mode: "+mode);
         g_instancing_mode = instancing_mode;
       }, "--instancing: set instancing mode\n"
-      "  none: no instancing\n"
+      "  none: perform no instancing and flatten entire scene\n"
       "  geometry: instance individual geometries as scenes\n"
       "  group: instance geometry groups as scenes\n"
+      "  multi_level: use multi-level instancing\n"
       "  flattened: assume flattened scene graph");
 
     registerOption("ambientlight", [this] (Ref<ParseStream> cin, const FileName& path) {

tutorials/next_hit/next_hit_device.cpp

@@ -124,20 +124,7 @@ RTCScene g_scene = nullptr;
 
 RTCScene convertScene(ISPCScene* scene_in)
 {
-  RTCScene scene_out = ConvertScene(g_device, g_ispc_scene, RTC_BUILD_QUALITY_MEDIUM);
-  rtcSetSceneFlags(scene_out, rtcGetSceneFlags(scene_out) | RTC_SCENE_FLAG_CONTEXT_FILTER_FUNCTION | RTC_SCENE_FLAG_ROBUST);
-
-  /* commit individual objects in case of instancing */
-  if (g_instancing_mode != ISPC_INSTANCING_NONE)
-  {
-    for (unsigned int i=0; i<scene_in->numGeometries; i++) {
-      ISPCGeometry* geometry = g_ispc_scene->geometries[i];
-      if (geometry->type == GROUP) {
-        rtcSetSceneFlags(geometry->scene, rtcGetSceneFlags(geometry->scene) | RTC_SCENE_FLAG_CONTEXT_FILTER_FUNCTION | RTC_SCENE_FLAG_ROBUST);
-        rtcCommitScene(geometry->scene);
-      }
-    }
-  }
+  RTCScene scene_out = ConvertScene(g_device, g_ispc_scene, RTC_BUILD_QUALITY_MEDIUM, RTC_SCENE_FLAG_CONTEXT_FILTER_FUNCTION | RTC_SCENE_FLAG_ROBUST);
   
   /* commit changes to scene */
   return scene_out;

tutorials/pathtracer/pathtracer_device.cpp

@@ -950,11 +950,6 @@ void assignShaders(ISPCGeometry* geometry)
     rtcSetGeometryOccludedFilterFunction(geom,occlusionFilterHair);
   }
 #endif
-  else if (geometry->type == GROUP) {
-    ISPCGroup* group = (ISPCGroup*) geometry;
-    for (unsigned int i=0; i<group->numGeometries; i++)
-      assignShaders(group->geometries[i]);
-  }
 }
 
 typedef ISPCInstance* ISPCInstance_ptr;
@@ -970,22 +965,10 @@ RTCScene convertScene(ISPCScene* scene_in)
     }
   }
 
+  assignShadersFunc = assignShaders;
+  
   RTCScene scene_out = ConvertScene(g_device, g_ispc_scene, RTC_BUILD_QUALITY_MEDIUM);
 
-  /* assign shaders */
-  for (unsigned int i=0; i<scene_in->numGeometries; i++) {
-    assignShaders(scene_in->geometries[i]);
-  }
-
-  /* commit individual objects in case of instancing */
-  if (g_instancing_mode != ISPC_INSTANCING_NONE)
-  {
-    for (unsigned int i=0; i<scene_in->numGeometries; i++) {
-      ISPCGeometry* geometry = g_ispc_scene->geometries[i];
-      if (geometry->type == GROUP) rtcCommitScene(geometry->scene);
-    }
-  }
-
   /* commit changes to scene */
   //progressStart();
   //rtcSetSceneProgressMonitorFunction(scene_out,progressMonitor,nullptr);

tutorials/pathtracer/pathtracer_device.ispc

@@ -876,7 +876,7 @@ void device_key_pressed_handler(uniform int key)
 }
 #endif
 
-void assignShaders(ISPCGeometry* uniform geometry)
+unmasked void assignShaders(uniform ISPCGeometry* uniform uniform geometry)
 {
   RTCGeometry geom = geometry->geometry;
   if (geometry->type == SUBDIV_MESH)
@@ -948,11 +948,6 @@ void assignShaders(ISPCGeometry* uniform geometry)
     rtcSetGeometryOccludedFilterFunction(geom,occlusionFilterHair);
   }
 #endif
-  else if (geometry->type == GROUP) {
-    ISPCGroup* uniform group = (ISPCGroup* uniform) geometry;
-    for (uniform unsigned int i=0; i<group->numGeometries; i++)
-      assignShaders(group->geometries[i]);
-  }
 }
 
 typedef uniform ISPCInstance* uniform ISPCInstance_ptr;
@@ -968,22 +963,10 @@ RTCScene convertScene(uniform ISPCScene* uniform scene_in)
     }
   }
 
+  assignShadersFunc = assignShaders;
+  
   RTCScene scene_out = ConvertScene(g_device, g_ispc_scene, RTC_BUILD_QUALITY_MEDIUM);
 
-  /* assign shaders */
-  for (uniform unsigned int i=0; i<scene_in->numGeometries; i++) {
-    assignShaders(scene_in->geometries[i]);
-  }
-
-  /* commit individual objects in case of instancing */
-  if (g_instancing_mode != ISPC_INSTANCING_NONE)
-  {
-    for (uniform unsigned int i=0; i<scene_in->numGeometries; i++) {
-      ISPCGeometry* uniform geometry = g_ispc_scene->geometries[i];
-      if (geometry->type == GROUP) rtcCommitScene(geometry->scene);
-    }
-  }
-
   /* commit changes to scene */
   //progressStart();
   //rtcSetSceneProgressMonitorFunction(scene_out,progressMonitor,NULL);

tutorials/viewer/viewer_device.cpp

@@ -63,7 +63,6 @@ void updateMeshEdgeLevelBufferTask (int taskIndex, int threadIndex,  ISPCScene*
   ISPCGeometry* geometry = g_ispc_scene->geometries[taskIndex];
   if (geometry->type != SUBDIV_MESH) return;
   ISPCSubdivMesh* mesh = (ISPCSubdivMesh*) geometry;
-  unsigned int geomID = mesh->geom.geomID;
   if (mesh->numFaces < 10000) {
     updateEdgeLevelBuffer(mesh,cam_pos,0,mesh->numFaces);
     rtcUpdateGeometryBuffer(geometry->geometry, RTC_BUFFER_TYPE_LEVEL, 0);
@@ -126,61 +125,10 @@ RTCScene convertScene(ISPCScene* scene_in)
   RTCScene scene_out = ConvertScene(g_device, g_ispc_scene, RTC_BUILD_QUALITY_MEDIUM);
   rtcSetSceneProgressMonitorFunction(scene_out,monitorProgressFunction,nullptr);
 
-  /* commit individual objects in case of instancing */
-  if (g_instancing_mode != ISPC_INSTANCING_NONE)
-  {
-    for (unsigned int i=0; i<scene_in->numGeometries; i++) {
-      ISPCGeometry* geometry = g_ispc_scene->geometries[i];
-      if (geometry->type == GROUP) rtcCommitScene(geometry->scene);
-    }
-  }
-
   /* commit changes to scene */
   return scene_out;
 }
 
-
-void postIntersectGeometry(const Ray& ray, DifferentialGeometry& dg, ISPCGeometry* geometry, int& materialID)
-{
-  if (geometry->type == TRIANGLE_MESH)
-  {
-    ISPCTriangleMesh* mesh = (ISPCTriangleMesh*) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == QUAD_MESH)
-  {
-    ISPCQuadMesh* mesh = (ISPCQuadMesh*) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == SUBDIV_MESH)
-  {
-    ISPCSubdivMesh* mesh = (ISPCSubdivMesh*) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == CURVES)
-  {
-    ISPCHairSet* mesh = (ISPCHairSet*) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == GRID_MESH)
-  {
-    ISPCGridMesh* mesh = (ISPCGridMesh*) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == POINTS)
-  {
-    ISPCPointSet* set = (ISPCPointSet*) geometry;
-    materialID = set->geom.materialID;
-  }
-  else if (geometry->type == GROUP) {
-    unsigned int geomID = ray.geomID; {
-      postIntersectGeometry(ray,dg,((ISPCGroup*) geometry)->geometries[geomID],materialID);
-    }
-  }
-  else
-    assert(false);
-}
-
 AffineSpace3fa calculate_interpolated_space (ISPCInstance* instance, float gtime)
 {
   if (instance->numTimeSteps == 1)
@@ -196,37 +144,29 @@ AffineSpace3fa calculate_interpolated_space (ISPCInstance* instance, float gtime
 
 typedef ISPCInstance* ISPCInstancePtr;
 
-inline int postIntersect(const TutorialData& data, const Ray& ray, DifferentialGeometry& dg)
+unsigned int postIntersect(const TutorialData& data, const Ray& ray, DifferentialGeometry& dg)
 {
-  int materialID = 0;
-  unsigned int instID = ray.instID[0]; {
-    unsigned int geomID = ray.geomID; {
-      ISPCGeometry* geometry = nullptr;
-      if (data.instancing_mode != ISPC_INSTANCING_NONE) {
-        ISPCInstance* instance = (ISPCInstancePtr) data.ispc_scene->geometries[instID];
-        geometry = instance->child;
-      } else {
-        geometry = data.ispc_scene->geometries[geomID];
-      }
-      postIntersectGeometry(ray,dg,geometry,materialID);
-    }
-  }
-
-  if (data.instancing_mode != ISPC_INSTANCING_NONE)
+  AffineSpace3fa local2world = one;
+  ISPCGeometry** geometries = data.ispc_scene->geometries;
+  
+  for (int i=0; i<RTC_MAX_INSTANCE_LEVEL_COUNT; i++)
   {
-    unsigned int instID = ray.instID[0];
-    {
-      /* get instance and geometry pointers */
-      ISPCInstance* instance = (ISPCInstancePtr) data.ispc_scene->geometries[instID];
+    const unsigned int instID = ray.instID[i];
+    if (instID == -1) break;
 
-      /* convert normals */
-      //AffineSpace3fa space = (1.0f-ray.time())*AffineSpace3fa(instance->space0) + ray.time()*AffineSpace3fa(instance->space1);
-      AffineSpace3fa space = calculate_interpolated_space(instance,ray.time());
-      dg.Ng = xfmVector(space,dg.Ng);
-      dg.Ns = xfmVector(space,dg.Ns);
-    }
+    ISPCInstance* instance = (ISPCInstancePtr) geometries[instID];
+    local2world = local2world * calculate_interpolated_space(instance,ray.time());
+
+    assert(instance->child->type == GROUP);
+    geometries = ((ISPCGroup*)instance->child)->geometries;
   }
 
+  ISPCGeometry* mesh = geometries[ray.geomID];
+  unsigned int materialID = mesh->materialID;
+  
+  dg.Ng = xfmVector(local2world,dg.Ng);
+  dg.Ns = xfmVector(local2world,dg.Ns);
+  
   return materialID;
 }
 

tutorials/viewer/viewer_device.ispc

@@ -61,7 +61,6 @@ task void updateMeshEdgeLevelBufferTask( uniform ISPCScene* uniform scene_in, co
   uniform ISPCGeometry* uniform geometry = g_ispc_scene->geometries[taskIndex];
   if (geometry->type != SUBDIV_MESH) return;
   uniform ISPCSubdivMesh* uniform mesh = (uniform ISPCSubdivMesh* uniform) geometry;
-  uniform unsigned int geomID = mesh->geom.geomID;
   if (mesh->numFaces < 10000) {
     updateEdgeLevelBuffer(mesh,cam_pos,0,mesh->numFaces);
     rtcUpdateGeometryBuffer(geometry->geometry, RTC_BUFFER_TYPE_LEVEL, 0);
@@ -116,62 +115,11 @@ RTCScene convertScene(uniform ISPCScene* uniform scene_in)
   RTCScene scene_out = ConvertScene(g_device, g_ispc_scene, RTC_BUILD_QUALITY_MEDIUM);
   rtcSetSceneProgressMonitorFunction(scene_out,monitorProgressFunction,NULL);
 
-  /* commit individual objects in case of instancing */
-  if (g_instancing_mode != ISPC_INSTANCING_NONE)
-  {
-    for (uniform unsigned int i=0; i<scene_in->numGeometries; i++) {
-      ISPCGeometry* uniform geometry = g_ispc_scene->geometries[i];
-      if (geometry->type == GROUP) rtcCommitScene(geometry->scene);
-    }
-  }
-
   /* commit changes to scene */
   return scene_out;
 }
 
-
-void postIntersectGeometry(const Ray& ray, DifferentialGeometry& dg, uniform ISPCGeometry* uniform geometry, int& materialID)
-{
-  if (geometry->type == TRIANGLE_MESH)
-  {
-    uniform ISPCTriangleMesh* uniform mesh = (uniform ISPCTriangleMesh* uniform) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == QUAD_MESH)
-  {
-    uniform ISPCQuadMesh* uniform mesh = (uniform ISPCQuadMesh* uniform) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == SUBDIV_MESH)
-  {
-    uniform ISPCSubdivMesh* uniform mesh = (uniform ISPCSubdivMesh* uniform) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == CURVES)
-  {
-    uniform ISPCHairSet* uniform mesh = (uniform ISPCHairSet* uniform) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == GRID_MESH)
-  {
-    uniform ISPCGridMesh* uniform mesh = (uniform ISPCGridMesh* uniform) geometry;
-    materialID = mesh->geom.materialID;
-  }
-  else if (geometry->type == POINTS)
-  {
-    uniform ISPCPointSet* uniform set = (uniform ISPCPointSet* uniform) geometry;
-    materialID = set->geom.materialID;
-  }
-  else if (geometry->type == GROUP) {
-    foreach_unique (geomID in ray.geomID) {
-      postIntersectGeometry(ray,dg,((uniform ISPCGroup*) geometry)->geometries[geomID],materialID);
-    }
-  }
-  else
-    assert(false);
-}
-
-AffineSpace3f calculate_interpolated_space (uniform ISPCInstance* uniform instance, float gtime)
+AffineSpace3f calculate_interpolated_space (uniform ISPCInstance* instance, float gtime)
 {
   if (instance->numTimeSteps == 1)
     return make_AffineSpace3f(instance->spaces[0]);
@@ -184,39 +132,31 @@ AffineSpace3f calculate_interpolated_space (uniform ISPCInstance* uniform instan
   return (1.0f-ftime)*make_AffineSpace3f(instance->spaces[itime+0]) + ftime*make_AffineSpace3f(instance->spaces[itime+1]);
 }
 
-typedef ISPCInstance* uniform ISPCInstancePtr;
+typedef ISPCInstance* ISPCInstancePtr;
 
-inline int postIntersect(const uniform TutorialData& data, const Ray& ray, DifferentialGeometry& dg)
+unsigned int postIntersect(const uniform TutorialData& data, const Ray& ray, DifferentialGeometry& dg)
 {
-  int materialID = 0;
-  foreach_unique (instID in ray.instID[0]) {
-    foreach_unique (geomID in ray.geomID) {
-      ISPCGeometry* uniform geometry = NULL;
-      if (data.instancing_mode != ISPC_INSTANCING_NONE) {
-        ISPCInstance* uniform instance = (ISPCInstancePtr) data.ispc_scene->geometries[instID];
-        geometry = instance->child;
-      } else {
-        geometry = data.ispc_scene->geometries[geomID];
-      }
-      postIntersectGeometry(ray,dg,geometry,materialID);
-    }
-  }
-
-  if (data.instancing_mode != ISPC_INSTANCING_NONE)
+  AffineSpace3f local2world = make_AffineSpace3f_scale(make_Vec3f(1));
+  ISPCGeometry* uniform* geometries = data.ispc_scene->geometries;
+  
+  for (uniform int i=0; i<RTC_MAX_INSTANCE_LEVEL_COUNT; i++)
   {
-    foreach_unique (instID in ray.instID[0])
-    {
-      /* get instance and geometry pointers */
-      ISPCInstance* uniform instance = (ISPCInstancePtr) data.ispc_scene->geometries[instID];
+    const unsigned int instID = ray.instID[i];
+    if (instID == -1) break;
 
-      /* convert normals */
-      //AffineSpace3f space = (1.0f-ray.time)*make_AffineSpace3f(instance->space0) + ray.time*make_AffineSpace3f(instance->space1);
-      AffineSpace3f space = calculate_interpolated_space(instance,ray.time);
-      dg.Ng = xfmVector(space,dg.Ng);
-      dg.Ns = xfmVector(space,dg.Ns);
-    }
+    ISPCInstance* instance = (ISPCInstancePtr) geometries[instID];
+    local2world = local2world * calculate_interpolated_space(instance,ray.time);
+
+    assert(instance->child->type == GROUP);
+    geometries = ((ISPCGroup*)instance->child)->geometries;
   }
 
+  ISPCGeometry* mesh = geometries[ray.geomID];
+  unsigned int materialID = mesh->materialID;
+  
+  dg.Ng = xfmVector(local2world,dg.Ng);
+  dg.Ns = xfmVector(local2world,dg.Ns);
+  
   return materialID;
 }
 

tutorials/viewer_anim/viewer_anim_device.cpp

@@ -39,7 +39,7 @@ void convertTriangleMesh(ISPCTriangleMesh* mesh, RTCScene scene_out)
   rtcSetSharedGeometryBuffer(geom, RTC_BUFFER_TYPE_INDEX, 0, RTC_FORMAT_UINT3, mesh->triangles, 0, sizeof(ISPCTriangle), mesh->numTriangles);
   rtcCommitGeometry(geom);
   mesh->geom.geometry = geom;
-  mesh->geom.geomID = rtcAttachGeometry(scene_out,geom);
+  rtcAttachGeometry(scene_out,geom);
 }
 
 void convertQuadMesh(ISPCQuadMesh* mesh, RTCScene scene_out)
@@ -53,7 +53,7 @@ void convertQuadMesh(ISPCQuadMesh* mesh, RTCScene scene_out)
   rtcSetSharedGeometryBuffer(geom, RTC_BUFFER_TYPE_INDEX, 0, RTC_FORMAT_UINT4, mesh->quads, 0, sizeof(ISPCQuad), mesh->numQuads);
   rtcCommitGeometry(geom);
   mesh->geom.geometry = geom;
-  mesh->geom.geomID = rtcAttachGeometry(scene_out,geom);
+  rtcAttachGeometry(scene_out,geom);
 }
 
 void convertSubdivMesh(ISPCSubdivMesh* mesh, RTCScene scene_out)
@@ -76,7 +76,7 @@ void convertSubdivMesh(ISPCSubdivMesh* mesh, RTCScene scene_out)
   rtcSetGeometrySubdivisionMode(geom, 0, mesh->position_subdiv_mode);
   rtcCommitGeometry(geom);
   mesh->geom.geometry = geom;
-  mesh->geom.geomID = rtcAttachGeometry(scene_out,geom);
+  rtcAttachGeometry(scene_out,geom);
 }
 
 void convertCurveGeometry(ISPCHairSet* hair, RTCScene scene_out)
@@ -94,7 +94,7 @@ void convertCurveGeometry(ISPCHairSet* hair, RTCScene scene_out)
     rtcSetGeometryTessellationRate(geom,(float)hair->tessellation_rate);
   rtcCommitGeometry(geom);
   hair->geom.geometry = geom;
-  hair->geom.geomID = rtcAttachGeometry(scene_out,geom);
+  rtcAttachGeometry(scene_out,geom);
 }
 
 unsigned int getNumObjects(ISPCScene* scene_in) {

tutorials/viewer_anim/viewer_anim_device.ispc

@@ -37,7 +37,7 @@ void convertTriangleMesh(uniform ISPCTriangleMesh* uniform mesh, RTCScene scene_
   rtcSetSharedGeometryBuffer(geom, RTC_BUFFER_TYPE_INDEX, 0, RTC_FORMAT_UINT3, mesh->triangles, 0, sizeof(uniform ISPCTriangle), mesh->numTriangles);
   rtcCommitGeometry(geom);
   mesh->geom.geometry = geom;
-  mesh->geom.geomID = rtcAttachGeometry(scene_out,geom);
+  rtcAttachGeometry(scene_out,geom);
 }
 
 void convertQuadMesh(uniform ISPCQuadMesh* uniform mesh, RTCScene scene_out)
@@ -51,7 +51,7 @@ void convertQuadMesh(uniform ISPCQuadMesh* uniform mesh, RTCScene scene_out)
   rtcSetSharedGeometryBuffer(geom, RTC_BUFFER_TYPE_INDEX, 0, RTC_FORMAT_UINT4, mesh->quads, 0, sizeof(uniform ISPCQuad), mesh->numQuads);
   rtcCommitGeometry(geom);
   mesh->geom.geometry = geom;
-  mesh->geom.geomID = rtcAttachGeometry(scene_out,geom);
+  rtcAttachGeometry(scene_out,geom);
 }
 
 void convertSubdivMesh(uniform ISPCSubdivMesh* uniform mesh, RTCScene scene_out)
@@ -74,7 +74,7 @@ void convertSubdivMesh(uniform ISPCSubdivMesh* uniform mesh, RTCScene scene_out)
   rtcSetGeometrySubdivisionMode(geom, 0, mesh->position_subdiv_mode);
   rtcCommitGeometry(geom);
   mesh->geom.geometry = geom;
-  mesh->geom.geomID = rtcAttachGeometry(scene_out,geom);
+  rtcAttachGeometry(scene_out,geom);
 }
 
 void convertCurveGeometry(uniform ISPCHairSet* uniform hair, RTCScene scene_out)
@@ -92,7 +92,7 @@ void convertCurveGeometry(uniform ISPCHairSet* uniform hair, RTCScene scene_out)
     rtcSetGeometryTessellationRate(geom,(float)hair->tessellation_rate);
   rtcCommitGeometry(geom);
   hair->geom.geometry = geom;
-  hair->geom.geomID = rtcAttachGeometry(scene_out,geom);
+  rtcAttachGeometry(scene_out,geom);
 }
 
 uniform unsigned int getNumObjects(uniform ISPCScene* uniform scene_in) {

tutorials/viewer_stream/viewer_stream_device.cpp

@@ -67,7 +67,6 @@ void updateMeshEdgeLevelBufferTask (int taskIndex, int threadIndex,  ISPCScene*
   ISPCGeometry* geometry = g_ispc_scene->geometries[taskIndex];
   if (geometry->type != SUBDIV_MESH) return;
   ISPCSubdivMesh* mesh = (ISPCSubdivMesh*) geometry;
-  unsigned int geomID = mesh->geom.geomID;
   if (mesh->numFaces < 10000) {
     updateEdgeLevelBuffer(mesh,cam_pos,0,mesh->numFaces);
     rtcUpdateGeometryBuffer(geometry->geometry,RTC_BUFFER_TYPE_LEVEL,0);
@@ -112,15 +111,6 @@ RTCScene convertScene(ISPCScene* scene_in)
 {
   RTCScene scene_out = ConvertScene(g_device, scene_in,RTC_BUILD_QUALITY_MEDIUM);
 
-  /* commit individual objects in case of instancing */
-  if (g_instancing_mode != ISPC_INSTANCING_NONE)
-  {
-    for (unsigned int i=0; i<scene_in->numGeometries; i++) {
-      ISPCGeometry* geometry = g_ispc_scene->geometries[i];
-      if (geometry->type == GROUP) rtcCommitScene(geometry->scene);
-    }
-  }
-
   return scene_out;
 }
 

tutorials/viewer_stream/viewer_stream_device.ispc

@@ -65,7 +65,6 @@ task void updateMeshEdgeLevelBufferTask( uniform ISPCScene* uniform scene_in, co
   uniform ISPCGeometry* uniform geometry = g_ispc_scene->geometries[taskIndex];
   if (geometry->type != SUBDIV_MESH) return;
   uniform ISPCSubdivMesh* uniform mesh = (uniform ISPCSubdivMesh* uniform) geometry;
-  uniform unsigned int geomID = mesh->geom.geomID;
   if (mesh->numFaces < 10000) {
     updateEdgeLevelBuffer(mesh,cam_pos,0,mesh->numFaces);
     rtcUpdateGeometryBuffer(geometry->geometry,RTC_BUFFER_TYPE_LEVEL,0);
@@ -101,16 +100,6 @@ void updateEdgeLevels(uniform ISPCScene* uniform scene_in, const uniform Vec3fa&
 RTCScene convertScene(uniform ISPCScene* uniform scene_in)
 {
   RTCScene scene_out = ConvertScene(g_device, scene_in,RTC_BUILD_QUALITY_MEDIUM);
-
-  /* commit individual objects in case of instancing */
-  if (g_instancing_mode != ISPC_INSTANCING_NONE)
-  {
-    for (uniform unsigned int i=0; i<scene_in->numGeometries; i++) {
-      ISPCGeometry* uniform geometry = g_ispc_scene->geometries[i];
-      if (geometry->type == GROUP) rtcCommitScene(geometry->scene);
-    }
-  }
-
   return scene_out;
 }