WIP: render real frames with TSD device

jeffamstutz · jeffamstutz · commit 166ce2d86c00 · 2026-01-09T13:12:00.000-06:00
diff --git a/tsd/src/anari_tsd/Device.cpp b/tsd/src/anari_tsd/Device.cpp
@@ -228,6 +228,8 @@ void Device::initDevice()
         "created ANARI device (%p) from library '%s'",
         (void *)state->device,
         libraryName.c_str());
+
+    state->scene.setUpdateDelegate(&state->anari.getUpdateDelegate());
   }
 
   m_initialized = true;
diff --git a/tsd/src/anari_tsd/Frame.cpp b/tsd/src/anari_tsd/Frame.cpp
@@ -6,19 +6,25 @@
 #include <helium/helium_math.h>
 // tsd_io
 #include "tsd/io/serialization.hpp"
+// std
+#include <algorithm>
 
 namespace tsd_device {
 
-Frame::Frame(DeviceGlobalState *s) : helium::BaseFrame(s) {}
+Frame::Frame(DeviceGlobalState *s) : helium::BaseFrame(s)
+{
+  m_anariFrame = anari::newObject<anari::Frame>(s->device);
+}
 
 Frame::~Frame()
 {
   wait();
+  anari::release(deviceState()->device, m_anariFrame);
 }
 
 bool Frame::isValid() const
 {
-  return m_world && m_world->isValid();
+  return m_world && m_world->isValid() && m_renderer && m_camera;
 }
 
 DeviceGlobalState *Frame::deviceState() const
@@ -49,6 +55,41 @@ void Frame::finalize()
     reportMessage(
         ANARI_SEVERITY_WARNING, "missing required parameter 'camera' on frame");
   }
+
+  if (!isValid())
+    return;
+
+  auto *state = deviceState();
+  auto d = state->device;
+  anari::unsetAllParameters(d, m_anariFrame);
+  std::for_each(params_begin(), params_end(), [&](auto &p) {
+    if (anari::isObject(p.second.type())) {
+      reportMessage(ANARI_SEVERITY_WARNING,
+          "skip forwarding object parameter '%s' on ANARIFrame",
+          p.first.c_str());
+    } else if (p.first == "name" && p.second.type() == ANARI_STRING) {
+      anari::setParameter(
+          d, m_anariFrame, p.first.c_str(), p.second.getString());
+    } else if (p.second.type() != ANARI_UNKNOWN) {
+      anari::setParameter(
+          d, m_anariFrame, p.first.c_str(), p.second.type(), p.second.data());
+    } else {
+      reportMessage(ANARI_SEVERITY_WARNING,
+          "skip setting parameter '%s' of unknown type on ANARIFrame",
+          p.first.c_str());
+    }
+  });
+
+  anari::setParameter(
+      d, m_anariFrame, "camera", (anari::Camera)m_camera->anariHandle());
+  anari::setParameter(
+      d, m_anariFrame, "renderer", (anari::Renderer)m_renderer->anariHandle());
+  anari::setParameter(d,
+      m_anariFrame,
+      "world",
+      (anari::World)m_world->getRenderIndex()->world());
+
+  anari::commitParameters(d, m_anariFrame);
 }
 
 bool Frame::getProperty(const std::string_view &name,
@@ -57,33 +98,48 @@ bool Frame::getProperty(const std::string_view &name,
     uint64_t size,
     uint32_t flags)
 {
-  return 0;
+  std::string nameStr(name);
+  return anariGetProperty(deviceState()->device,
+      m_anariFrame,
+      nameStr.c_str(),
+      type,
+      ptr,
+      size,
+      flags);
 }
 
 void Frame::renderFrame()
 {
   auto *state = deviceState();
   state->commitBuffer.flush();
-  reportMessage(
-      ANARI_SEVERITY_INFO, "exporting scene to 'tsd_device_export.tsd'");
-  tsd::io::save_Scene(state->scene, "tsd_device_export.tsd");
+
+  const char *filename = "live_capture.tsd";
+  reportMessage(ANARI_SEVERITY_INFO, "exporting scene to '%s'", filename);
+  tsd::io::save_Scene(state->scene, filename);
+
+  anari::render(state->device, m_anariFrame);
 }
 
 void *Frame::map(std::string_view channel,
     uint32_t *width,
     uint32_t *height,
     ANARIDataType *pixelType)
 {
-  wait();
-  *width = 0;
-  *height = 0;
-  *pixelType = ANARI_UNKNOWN;
-  return nullptr;
+  auto *state = deviceState();
+  std::string channelStr(channel);
+  return (void *)anariMapFrame(state->device,
+      m_anariFrame,
+      channelStr.c_str(),
+      width,
+      height,
+      pixelType);
 }
 
 void Frame::unmap(std::string_view channel)
 {
-  // no-op
+  auto *state = deviceState();
+  std::string channelStr(channel);
+  anari::unmap(state->device, m_anariFrame, channelStr.c_str());
 }
 
 int Frame::frameReady(ANARIWaitMask m)
@@ -98,17 +154,17 @@ int Frame::frameReady(ANARIWaitMask m)
 
 void Frame::discard()
 {
-  // no-op
+  anari::discard(deviceState()->device, m_anariFrame);
 }
 
 bool Frame::ready() const
 {
-  return true;
+  return anari::isReady(deviceState()->device, m_anariFrame);
 }
 
 void Frame::wait() const
 {
-  // no-op
+  anari::wait(deviceState()->device, m_anariFrame);
 }
 
 } // namespace tsd_device
diff --git a/tsd/src/anari_tsd/Frame.h b/tsd/src/anari_tsd/Frame.h
@@ -46,6 +46,8 @@ struct Frame : public helium::BaseFrame
   helium::IntrusivePtr<World> m_world;
   helium::IntrusivePtr<TSDObject> m_renderer;
   helium::IntrusivePtr<TSDObject> m_camera;
+
+  anari::Frame m_anariFrame{nullptr};
 };
 
 } // namespace tsd_device
diff --git a/tsd/src/anari_tsd/Object.cpp b/tsd/src/anari_tsd/Object.cpp
@@ -57,6 +57,8 @@ TSDObject::TSDObject(
   case ANARI_CAMERA:
     obj = s->scene.createObject<tsd::core::Camera>(subtype).data();
     name = "camera" + std::to_string(s->cameraCount++);
+    m_liveHandle =
+        anari::newObject<anari::Renderer>(s->device, subtype.c_str());
     break;
   case ANARI_SURFACE:
     obj = s->scene.createObject<tsd::core::Surface>().data();
@@ -89,6 +91,8 @@ TSDObject::TSDObject(
   case ANARI_RENDERER:
     obj = new tsd::core::Object(ANARI_RENDERER, subtype);
     name = "renderer" + std::to_string(s->rendererCount++);
+    m_liveHandle =
+        anari::newObject<anari::Renderer>(s->device, subtype.c_str());
     break;
   default:
     break;
@@ -107,6 +111,15 @@ TSDObject::TSDObject(
   obj->setName(name.c_str());
 }
 
+TSDObject::~TSDObject()
+{
+  auto *s = deviceState();
+  if (m_liveHandle) {
+    anari::release(s->device, m_liveHandle);
+    m_liveHandle = nullptr;
+  }
+}
+
 void TSDObject::commitParameters()
 {
   auto *object = tsdObject();
@@ -145,11 +158,23 @@ void TSDObject::commitParameters()
           p.first.c_str());
     }
   });
+
+  if (m_liveHandle) {
+    auto *state = deviceState();
+    object->updateAllANARIParameters(state->device, m_liveHandle);
+    anari::commitParameters(state->device, m_liveHandle);
+  }
 }
 
 tsd::core::Object *TSDObject::tsdObject() const
 {
-  return deviceState()->scene.getObject(m_object);
+  return m_rendererObject ? m_rendererObject.get()
+                          : deviceState()->scene.getObject(m_object);
+}
+
+anari::Object TSDObject::anariHandle() const
+{
+  return m_liveHandle;
 }
 
 } // namespace tsd_device
diff --git a/tsd/src/anari_tsd/Object.h b/tsd/src/anari_tsd/Object.h
@@ -35,15 +35,21 @@ struct TSDObject : public Object
   TSDObject(anari::DataType type,
       DeviceGlobalState *s,
       tsd::core::Token subtype = tsd::core::tokens::none);
-  virtual ~TSDObject() = default;
+  virtual ~TSDObject();
 
   virtual void commitParameters() override;
 
   tsd::core::Object *tsdObject() const;
+  anari::Object anariHandle() const;
 
  private:
   tsd::core::Any m_object; // scene ref for non-renderer objects
   std::unique_ptr<tsd::core::Object> m_rendererObject; // only if ANARI_RENDERER
+
+  // Renderers + cameras track a live ANARI object to be used by the Frame, all
+  // other objects are created + managed via a render index to populate the
+  // World.
+  anari::Object m_liveHandle{nullptr};
 };
 
 } // namespace tsd_device
diff --git a/tsd/src/anari_tsd/World.cpp b/tsd/src/anari_tsd/World.cpp
@@ -13,7 +13,10 @@ World::World(DeviceGlobalState *s)
       m_instanceData(this)
 {
   m_layerName = "world" + std::to_string(s->worldCount++);
-  s->scene.addLayer(m_layerName);
+  auto *l = s->scene.addLayer(m_layerName);
+  m_renderIndex =
+      (tsd::rendering::RenderIndexAllLayers *)s->anari.acquireRenderIndex(
+          s->scene, s->device);
 }
 
 World::~World()
@@ -22,6 +25,22 @@ World::~World()
   s->scene.removeLayer(m_layerName);
 }
 
+bool World::getProperty(const std::string_view &name,
+    ANARIDataType type,
+    void *ptr,
+    uint64_t size,
+    uint32_t flags)
+{
+  std::string nameStr(name);
+  return anariGetProperty(deviceState()->device,
+      m_renderIndex->world(),
+      nameStr.c_str(),
+      type,
+      ptr,
+      size,
+      flags);
+}
+
 void World::commitParameters()
 {
   m_zeroSurfaceData = getParamObject<helium::ObjectArray>("surface");
@@ -36,6 +55,11 @@ void World::finalize()
   updateLayer();
 }
 
+const tsd::rendering::RenderIndexAllLayers *World::getRenderIndex() const
+{
+  return m_renderIndex;
+}
+
 tsd::core::Layer *World::layer() const
 {
   auto *s = deviceState();
diff --git a/tsd/src/anari_tsd/World.h b/tsd/src/anari_tsd/World.h
@@ -6,17 +6,27 @@
 #include "Instance.h"
 // std
 #include <vector>
+// tsd_rendering
+#include "tsd/rendering/index/RenderIndexAllLayers.hpp"
 
 namespace tsd_device {
 
 struct World : public Object
 {
   World(DeviceGlobalState *s);
-   ~World() override;
+  ~World() override;
+
+  bool getProperty(const std::string_view &name,
+      ANARIDataType type,
+      void *ptr,
+      uint64_t size,
+      uint32_t flags) override;
 
   void commitParameters() override;
   void finalize() override;
 
+  const tsd::rendering::RenderIndexAllLayers *getRenderIndex() const;
+
  private:
   tsd::core::Layer *layer() const;
 
@@ -34,6 +44,7 @@ struct World : public Object
   std::vector<TSDObject *> m_zeroLights;
 
   tsd::core::Token m_layerName;
+  tsd::rendering::RenderIndexAllLayers *m_renderIndex{nullptr};
 };
 
 } // namespace tsd_device

Original file line number	Diff line number	Diff line change
`@@ -228,6 +228,8 @@ void Device::initDevice()`
`228`	`228`	`"created ANARI device (%p) from library '%s'",`
`229`	`229`	`(void *)state->device,`
`230`	`230`	`libraryName.c_str());`
	`231`	`+`
	`232`	`+ state->scene.setUpdateDelegate(&state->anari.getUpdateDelegate());`
`231`	`233`	`}`
`232`	`234`
`233`	`235`	`m_initialized = true;`