Added getters for if the scene is modified, the progress monitor function, the progress user pointer, and the scene build quality. Also added getters for getting the number of attached geometries as well as the array of geometries attached to the scene. All of these are available in the C API.

Author: dbs4261

include/embree4/rtcore_scene.h

@@ -107,6 +107,14 @@ RTC_API void rtcAttachGeometryByID(RTCScene scene, RTCGeometry geometry, unsigne
 /* Detaches the geometry from the scene. */
 RTC_API void rtcDetachGeometry(RTCScene scene, unsigned int geomID);
 
+/* Gets the number of geometry IDs attached to the scene. To get the array of valid IDs allocate an array of the correct size and pass it as geomIDs. */
+RTC_API size_t rtcGetNumAttachedGeometryIDs(RTCScene scene);
+RTC_API void rtcGetAttachedGeometryIDs(RTCScene scene, size_t* numGeomIDs, unsigned int* geomIDs RTC_DEFAULT_VALUE(nullptr));
+
+/* Gets the number of geometries attached to the scene. To get the array of valid geometries allocate an array of the correct size and pass it as geometries. */
+RTC_API size_t rtcGetNumAttachedGeometries(RTCScene scene);
+RTC_API void rtcGetAttachedGeometries(RTCScene scene, size_t* numGeoms, RTCGeometry* geometries RTC_DEFAULT_VALUE(nullptr));
+
 /* Gets a geometry handle from the scene. This function is not thread safe and should get used during rendering. */
 RTC_API RTCGeometry rtcGetGeometry(RTCScene scene, unsigned int geomID);
 
@@ -120,16 +128,28 @@ RTC_API void rtcCommitScene(RTCScene scene);
 /* Commits the scene from multiple threads. */
 RTC_API void rtcJoinCommitScene(RTCScene scene);
 
+/* Returns if the scene has been modified since it was last committed. */
+RTC_API bool rtcIsSceneModified(RTCScene scene);
+
 
 /* Progress monitor callback function */
 typedef bool (*RTCProgressMonitorFunction)(void* ptr, double n);
 
 /* Sets the progress monitor callback function of the scene. */
 RTC_API void rtcSetSceneProgressMonitorFunction(RTCScene scene, RTCProgressMonitorFunction progress, void* ptr);
 
+/* Gets the progress monitor callback function of the scene. */
+RTC_API RTCProgressMonitorFunction rtcGetSceneProgressMonitorFunction(RTCScene scene);
+
+/* Gets the progress monitor callback function user pointer of the scene. */
+RTC_API void* rtcGetSceneProgressMonitorFunctionUserPtr(RTCScene scene);
+
 /* Sets the build quality of the scene. */
 RTC_API void rtcSetSceneBuildQuality(RTCScene scene, enum RTCBuildQuality quality);
 
+/* Gets the build quality of the scene. */
+RTC_API enum RTCBuildQuality rtcGetSceneBuildQuality(RTCScene scene);
+
 /* Sets the scene flags. */
 RTC_API void rtcSetSceneFlags(RTCScene scene, enum RTCSceneFlags flags);
 

kernels/common/rtcore.cpp

@@ -398,6 +398,32 @@ RTC_NAMESPACE_BEGIN;
     RTC_CATCH_END2(scene);
   }
 
+  RTC_API RTCProgressMonitorFunction rtcGetSceneProgressMonitorFunction(RTCScene hscene)
+  {
+    Scene* scene = (Scene*) hscene;
+    RTC_CATCH_BEGIN;
+    RTC_TRACE(rtcGetSceneProgressMonitorFunction);
+    RTC_VERIFY_HANDLE(hscene);
+    RTC_ENTER_DEVICE(hscene);
+    Lock<MutexSys> lock(g_mutex);
+    return scene->getProgressMonitorFunction();
+    RTC_CATCH_END2(scene);
+    return nullptr;
+  }
+
+  RTC_API void* rtcGetSceneProgressMonitorFunctionUserPtr(RTCScene hscene)
+  {
+    Scene* scene = (Scene*) hscene;
+    RTC_CATCH_BEGIN;
+    RTC_TRACE(rtcGetSceneProgressMonitorFunctionUserPtr);
+    RTC_VERIFY_HANDLE(hscene);
+    RTC_ENTER_DEVICE(hscene);
+    Lock<MutexSys> lock(g_mutex);
+    return scene->getProgressMonitorFunctionUserPtr();
+    RTC_CATCH_END2(scene);
+    return nullptr;
+  }
+
   RTC_API void rtcSetSceneBuildQuality (RTCScene hscene, RTCBuildQuality quality) 
   {
     Scene* scene = (Scene*) hscene;
@@ -412,6 +438,18 @@ RTC_NAMESPACE_BEGIN;
     RTC_CATCH_END2(scene);
   }
 
+  RTC_API RTCBuildQuality rtcGetSceneBuildQuality (RTCScene hscene)
+  {
+    Scene* scene = (Scene*) hscene;
+    RTC_CATCH_BEGIN;
+    RTC_TRACE(rtcGetSceneBuildQuality);
+    RTC_VERIFY_HANDLE(hscene);
+    RTC_ENTER_DEVICE(hscene);
+    return scene->getBuildQuality();
+    RTC_CATCH_END2(scene);
+    return RTC_BUILD_QUALITY_MEDIUM;
+  }
+
   RTC_API void rtcSetSceneFlags (RTCScene hscene, RTCSceneFlags flags) 
   {
     Scene* scene = (Scene*) hscene;
@@ -462,6 +500,18 @@ RTC_NAMESPACE_BEGIN;
     RTC_CATCH_END2(scene);
   }
 
+  RTC_API bool rtcIsSceneModified(RTCScene hscene)
+  {
+    Scene* scene = (Scene*) hscene;
+    RTC_CATCH_BEGIN;
+    RTC_TRACE(rtcIsSceneModified);
+    RTC_VERIFY_HANDLE(hscene);
+    RTC_ENTER_DEVICE(hscene);
+    return scene->isModified();
+    RTC_CATCH_END2(scene);
+    return false;
+  }
+
   RTC_API void rtcGetSceneBounds(RTCScene hscene, RTCBounds* bounds_o)
   {
     Scene* scene = (Scene*) hscene;
@@ -2361,6 +2411,84 @@ RTC_API void rtcSetGeometryTransform(RTCGeometry hgeometry, unsigned int timeSte
     RTC_CATCH_END2(geometry);
   }
 
+  RTC_API size_t rtcGetNumAttachedGeometryIDs (RTCScene hscene)
+  {
+    Scene* scene = (Scene*) hscene;
+    RTC_CATCH_BEGIN;
+    RTC_TRACE(rtcGetNumAttachedGeometryIDs);
+    RTC_VERIFY_HANDLE(hscene);
+    RTC_ENTER_DEVICE(hscene);
+    unsigned int numGeomIDs = scene->size();
+    for (unsigned int i = 0; i < scene->size(); ++i) {
+      Geometry* ptr = scene->get(i);
+      if (!ptr) {
+        numGeomIDs -= 1;
+      }
+    }
+    return numGeomIDs;
+    RTC_CATCH_END2(scene);
+    return 0;
+  }
+
+  RTC_API void rtcGetAttachedGeometryIDs (RTCScene hscene, size_t* numGeomIDs, unsigned int* geomIDs)
+  {
+    Scene* scene = (Scene*) hscene;
+    RTC_CATCH_BEGIN;
+    RTC_TRACE(rtcGetAttachedGeometryIDs);
+    RTC_VERIFY_HANDLE(hscene);
+    RTC_VERIFY_HANDLE(numGeomIDs);
+    RTC_ENTER_DEVICE(hscene);
+    *numGeomIDs = scene->size();
+    for (unsigned int i = 0; i < scene->size(); ++i) {
+      Geometry* ptr = scene->get(i);
+      if (!ptr) {
+        *numGeomIDs -= 1;
+      } else if (geomIDs) {
+        *geomIDs++ = i;
+      }
+    }
+    RTC_CATCH_END2(scene);
+  }
+
+  RTC_API size_t rtcGetNumAttachedGeometries (RTCScene hscene)
+  {
+    Scene* scene = (Scene*) hscene;
+    RTC_CATCH_BEGIN;
+    RTC_TRACE(rtcGetNumAttachedGeometryIDs);
+    RTC_VERIFY_HANDLE(hscene);
+    RTC_ENTER_DEVICE(hscene);
+    unsigned int numGeomIDs = scene->size();
+    for (unsigned int i = 0; i < scene->size(); ++i) {
+      Geometry* ptr = scene->get(i);
+      if (!ptr) {
+        numGeomIDs -= 1;
+      }
+    }
+    return numGeomIDs;
+    RTC_CATCH_END2(scene);
+    return 0;
+  }
+
+  RTC_API void rtcGetAttachedGeometries (RTCScene hscene, size_t* numGeoms, RTCGeometry* geometries)
+  {
+    Scene* scene = (Scene*) hscene;
+    RTC_CATCH_BEGIN;
+    RTC_TRACE(rtcGetAttachedGeometries);
+    RTC_VERIFY_HANDLE(hscene);
+    RTC_VERIFY_HANDLE(numGeoms);
+    RTC_ENTER_DEVICE(hscene);
+    *numGeoms = scene->size();
+    for (unsigned int i = 0; i < scene->size(); ++i) {
+      Geometry* ptr = scene->get(i);
+      if (!ptr) {
+        *numGeoms -= 1;
+      } else if (geometries) {
+        *geometries++ = (RTCGeometry) ptr;
+      }
+    }
+    RTC_CATCH_END2(scene);
+  }
+
   RTC_API RTCGeometry rtcGetGeometry (RTCScene hscene, unsigned int geomID)
   {
     Scene* scene = (Scene*) hscene;

kernels/common/scene.cpp

@@ -1089,6 +1089,16 @@ namespace embree
     progress_monitor_ptr      = ptr;
   }
 
+  RTCProgressMonitorFunction Scene::getProgressMonitorFunction() const
+  {
+    return progress_monitor_function;
+  }
+
+  void* Scene::getProgressMonitorFunctionUserPtr() const
+  {
+    return progress_monitor_ptr;
+  }
+
   void Scene::progressMonitor(double dn)
   {
     if (progress_monitor_function) {

kernels/common/scene.h

@@ -383,6 +383,8 @@ namespace embree
     std::atomic<size_t> progress_monitor_counter;
     void progressMonitor(double nprims);
     void setProgressMonitorFunction(RTCProgressMonitorFunction func, void* ptr);
+    RTCProgressMonitorFunction getProgressMonitorFunction() const;
+    void* getProgressMonitorFunctionUserPtr() const;
 
   private:
     GeometryCounts world;               //!< counts for geometry