implement new 1.2 spec aspect parameter behavior

devices/rtx/device/camera/Camera.cpp

@@ -45,9 +45,24 @@ Camera::Camera(DeviceGlobalState *s) : Object(ANARI_CAMERA, s)
   s->commitBuffer.addObjectToCommit(this);
 }
 
-void Camera::finalize()
+void Camera::commitParameters()
 {
-  upload();
+  m_region = vec4(0.f, 0.f, 1.f, 1.f);
+  getParam("imageRegion", ANARI_FLOAT32_BOX2, &m_region);
+  m_pos = getParam<vec3>("position", vec3(0.f));
+  m_dir = normalize(getParam<vec3>("direction", vec3(0.f, 0.f, 1.f)));
+  m_up = normalize(getParam<vec3>("up", vec3(0.f, 1.f, 0.f)));
+
+  m_aspect.reset();
+  float aspect = 1.f;
+  if (getParam("aspect", ANARI_FLOAT32, &aspect))
+    m_aspect = aspect;
+}
+
+void Camera::populateFrameData(CameraGPUData &fd, uvec2 /*frameSize*/) const
+{
+  populateBaseFrameData(fd);
+  fd.type = CameraType::UNKNOWN;
 }
 
 Camera *Camera::createInstance(std::string_view subtype, DeviceGlobalState *d)
@@ -60,19 +75,20 @@ Camera *Camera::createInstance(std::string_view subtype, DeviceGlobalState *d)
     return new UnknownCamera(subtype, d);
 }
 
-void *Camera::deviceData() const
+void Camera::populateBaseFrameData(CameraGPUData &fd) const
 {
-  return DeviceObject<CameraGPUData>::deviceData();
+  fd.region = m_region;
+  fd.pos = m_pos;
+  fd.dir = m_dir;
+  fd.up = m_up;
 }
 
-void Camera::readBaseParameters(CameraGPUData &hd)
+float Camera::effectiveAspect(uvec2 frameSize) const
 {
-  vec4 region = vec4(0.f, 0.f, 1.f, 1.f);
-  getParam("imageRegion", ANARI_FLOAT32_BOX2, &region);
-  hd.region = region;
-  hd.pos = getParam<vec3>("position", vec3(0.f));
-  hd.dir = normalize(getParam<vec3>("direction", vec3(0.f, 0.f, 1.f)));
-  hd.up = normalize(getParam<vec3>("up", vec3(0.f, 1.f, 0.f)));
+  if (m_aspect)
+    return *m_aspect;
+
+  return frameSize.y == 0 ? 1.f : float(frameSize.x) / float(frameSize.y);
 }
 
 } // namespace visrtx

devices/rtx/device/camera/Camera.h

@@ -33,23 +33,30 @@
 
 #include "Object.h"
 #include "gpu/gpu_objects.h"
-#include "utility/DeviceObject.h"
+// std
+#include <optional>
 
 namespace visrtx {
 
-struct Camera : public Object, public DeviceObject<CameraGPUData>
+struct Camera : public Object
 {
   Camera(DeviceGlobalState *d);
   ~Camera() override = default;
 
-  void finalize() override;
+  void commitParameters() override;
+  virtual void populateFrameData(CameraGPUData &fd, uvec2 frameSize) const;
 
   static Camera *createInstance(std::string_view subtype, DeviceGlobalState *d);
 
-  void *deviceData() const override;
-
  protected:
-  void readBaseParameters(CameraGPUData &hd);
+  void populateBaseFrameData(CameraGPUData &fd) const;
+  float effectiveAspect(uvec2 frameSize) const;
+
+  vec4 m_region{0.f, 0.f, 1.f, 1.f};
+  vec3 m_pos{0.f};
+  vec3 m_dir{0.f, 0.f, 1.f};
+  vec3 m_up{0.f, 1.f, 0.f};
+  std::optional<float> m_aspect;
 };
 
 } // namespace visrtx

devices/rtx/device/camera/Orthographic.cpp

@@ -37,18 +37,23 @@ Orthographic::Orthographic(DeviceGlobalState *s) : Camera(s) {}
 
 void Orthographic::commitParameters()
 {
-  const float aspect = getParam<float>("aspect", 1.f);
-  const float height = getParam<float>("height", 1.f);
-
-  vec2 imgPlaneSize(height * aspect, height);
-
-  auto &hd = data();
-  readBaseParameters(hd);
-  hd.type = CameraType::ORTHOGRAPHIC;
-  auto &o = hd.orthographic;
-  o.pos_du = normalize(cross(hd.dir, hd.up)) * imgPlaneSize.x;
-  o.pos_dv = normalize(cross(o.pos_du, hd.dir)) * imgPlaneSize.y;
-  o.pos_00 = hd.pos - 0.5f * o.pos_du - 0.5f * o.pos_dv;
+  Camera::commitParameters();
+
+  m_height = getParam<float>("height", 1.f);
+}
+
+void Orthographic::populateFrameData(CameraGPUData &fd, uvec2 frameSize) const
+{
+  populateBaseFrameData(fd);
+  fd.type = CameraType::ORTHOGRAPHIC;
+
+  const float aspect = effectiveAspect(frameSize);
+  vec2 imgPlaneSize(m_height * aspect, m_height);
+
+  auto &o = fd.orthographic;
+  o.pos_du = normalize(cross(fd.dir, fd.up)) * imgPlaneSize.x;
+  o.pos_dv = normalize(cross(o.pos_du, fd.dir)) * imgPlaneSize.y;
+  o.pos_00 = fd.pos - 0.5f * o.pos_du - 0.5f * o.pos_dv;
 }
 
 } // namespace visrtx

devices/rtx/device/camera/Orthographic.h

@@ -39,6 +39,10 @@ struct Orthographic : public Camera
 {
   Orthographic(DeviceGlobalState *d);
   void commitParameters() override;
+  void populateFrameData(CameraGPUData &fd, uvec2 frameSize) const override;
+
+ private:
+  float m_height{1.f};
 };
 
 } // namespace visrtx

devices/rtx/device/camera/Perspective.cpp

@@ -39,31 +39,37 @@ Perspective::Perspective(DeviceGlobalState *s) : Camera(s) {}
 
 void Perspective::commitParameters()
 {
-  auto &hd = data();
-  readBaseParameters(hd);
-  hd.type = CameraType::PERSPECTIVE;
+  Camera::commitParameters();
 
-  const float fovy = getParam<float>("fovy", glm::radians(60.f));
-  const float aspect = getParam<float>("aspect", 1.f);
+  m_fovy = getParam<float>("fovy", glm::radians(60.f));
+  m_focusDistance = getParam<float>("focusDistance", 1.f);
+  m_apertureRadius = getParam<float>("apertureRadius", 0.f);
+}
+
+void Perspective::populateFrameData(CameraGPUData &fd, uvec2 frameSize) const
+{
+  populateBaseFrameData(fd);
+  fd.type = CameraType::PERSPECTIVE;
+
+  const float aspect = effectiveAspect(frameSize);
 
   vec2 imgPlaneSize;
-  imgPlaneSize.y = 2.f * tanf(0.5f * fovy);
+  imgPlaneSize.y = 2.f * tanf(0.5f * m_fovy);
   imgPlaneSize.x = imgPlaneSize.y * aspect;
 
-  vec3 dir_du = normalize(cross(hd.dir, hd.up)) * imgPlaneSize.x;
-  vec3 dir_dv = normalize(cross(dir_du, hd.dir)) * imgPlaneSize.y;
-  vec3 dir_00 = hd.dir - .5f * dir_du - .5f * dir_dv;
+  vec3 dir_du = normalize(cross(fd.dir, fd.up)) * imgPlaneSize.x;
+  vec3 dir_dv = normalize(cross(dir_du, fd.dir)) * imgPlaneSize.y;
+  vec3 dir_00 = fd.dir - .5f * dir_du - .5f * dir_dv;
 
-  const float focusDistance = getParam<float>("focusDistance", 1.f);
   const float apertureRadius =
-      getParam<float>("apertureRadius", 0.f) / (imgPlaneSize.x * focusDistance);
+      m_apertureRadius / (imgPlaneSize.x * m_focusDistance);
   if (apertureRadius > 0.f) {
-    dir_du *= focusDistance;
-    dir_dv *= focusDistance;
-    dir_00 *= focusDistance;
+    dir_du *= m_focusDistance;
+    dir_dv *= m_focusDistance;
+    dir_00 *= m_focusDistance;
   }
 
-  auto &p = hd.perspective;
+  auto &p = fd.perspective;
   p.dir_du = dir_du;
   p.dir_dv = dir_dv;
   p.dir_00 = dir_00;

devices/rtx/device/camera/Perspective.h

@@ -32,13 +32,21 @@
 #pragma once
 
 #include "camera/Camera.h"
+// glm
+#include <glm/trigonometric.hpp>
 
 namespace visrtx {
 
 struct Perspective : public Camera
 {
   Perspective(DeviceGlobalState *d);
   void commitParameters() override;
+  void populateFrameData(CameraGPUData &fd, uvec2 frameSize) const override;
+
+ private:
+  float m_fovy{glm::radians(60.f)};
+  float m_focusDistance{1.f};
+  float m_apertureRadius{0.f};
 };
 
 } // namespace visrtx

devices/rtx/device/frame/Frame.cu

@@ -519,8 +519,7 @@ void Frame::renderFrame()
   cudaEventRecord(m_eventStart, state.stream);
 
   m_renderer->populateFrameData(hd);
-
-  hd.camera = (CameraGPUData *)m_camera->deviceData();
+  m_camera->populateFrameData(hd.camera, hd.fb.size);
   hd.world = m_world->gpuData();
 
   hd.registry.samplers = state.registry.samplers.devicePtr();

devices/rtx/device/gpu/cameraCreateRay.h

@@ -35,17 +35,17 @@
 
 namespace visrtx {
 
-VISRTX_DEVICE Ray cameraCreateRay(const CameraGPUData *c, vec2 screen, vec2 r)
+VISRTX_DEVICE Ray cameraCreateRay(const CameraGPUData &c, vec2 screen, vec2 r)
 {
   Ray ray;
 
-  screen.x = glm::mix(c->region[0], c->region[2], screen.x);
-  screen.y = glm::mix(c->region[1], c->region[3], screen.y);
+  screen.x = glm::mix(c.region[0], c.region[2], screen.x);
+  screen.y = glm::mix(c.region[1], c.region[3], screen.y);
 
-  switch (c->type) {
+  switch (c.type) {
   case CameraType::PERSPECTIVE: {
-    const auto &p = c->perspective;
-    ray.org = c->pos;
+    const auto &p = c.perspective;
+    ray.org = c.pos;
     ray.dir = p.dir_00 + screen.x * p.dir_du + screen.y * p.dir_dv;
 
     if (p.scaledAperture > 0.f) {
@@ -59,8 +59,8 @@ VISRTX_DEVICE Ray cameraCreateRay(const CameraGPUData *c, vec2 screen, vec2 r)
     break;
   }
   case CameraType::ORTHOGRAPHIC: {
-    const auto &o = c->orthographic;
-    ray.dir = c->dir;
+    const auto &o = c.orthographic;
+    ray.dir = c.dir;
     ray.org = o.pos_00 + screen.x * o.pos_du + screen.y * o.pos_dv;
     break;
   }

devices/rtx/device/gpu/gpu_objects.h

@@ -105,7 +105,7 @@ struct OrthographicCameraGPUData
 
 struct CameraGPUData
 {
-  CameraType type{CameraType::UNKNOWN};
+  CameraType type;
   vec4 region;
   vec3 pos;
   vec3 dir;
@@ -774,7 +774,7 @@ struct FrameGPUData
   FramebufferGPUData fb;
   RendererGPUData renderer;
   WorldGPUData world;
-  CameraGPUData *camera;
+  CameraGPUData camera;
 
   // Objects //
 

tsd/src/tsd/rendering/pipeline/passes/AnariSceneRenderPass.cpp

@@ -80,11 +80,7 @@ void AnariSceneRenderPass::setCamera(anari::Camera c)
   anari::commitParameters(m_device, m_frame);
   anari::release(m_device, m_camera);
   m_camera = c;
-  if (m_camera) {
-    auto size = getDimensions();
-    anari::setParameter(m_device, m_camera, "aspect", size.x / float(size.y));
-    anari::commitParameters(m_device, m_camera);
-  }
+  updateCameraAspect();
 }
 
 void AnariSceneRenderPass::setRenderer(anari::Renderer r)
@@ -217,6 +213,15 @@ void AnariSceneRenderPass::setEnableNormals(bool on)
   anari::commitParameters(m_device, m_frame);
 }
 
+void AnariSceneRenderPass::setUseImplicitAspectRatio(bool on)
+{
+  if (on == m_useImplicitAspectRatio)
+    return;
+
+  m_useImplicitAspectRatio = on;
+  updateCameraAspect();
+}
+
 void AnariSceneRenderPass::startFirstFrame(bool waitForCompletion)
 {
   if (!m_firstFrame)
@@ -240,17 +245,28 @@ anari::Frame AnariSceneRenderPass::getFrame() const
   return m_frame;
 }
 
+void AnariSceneRenderPass::updateCameraAspect()
+{
+  auto size = getDimensions();
+  if (!m_camera || size.y == 0)
+    return;
+
+  if (m_useImplicitAspectRatio)
+    anari::unsetParameter(m_device, m_camera, "aspect");
+  else
+    anari::setParameter(m_device, m_camera, "aspect", size.x / float(size.y));
+
+  anari::commitParameters(m_device, m_camera);
+}
+
 void AnariSceneRenderPass::updateSize()
 {
   cleanup();
   auto size = getDimensions();
   anari::setParameter(m_device, m_frame, "size", size);
   anari::commitParameters(m_device, m_frame);
 
-  if (m_camera) {
-    anari::setParameter(m_device, m_camera, "aspect", size.x / float(size.y));
-    anari::commitParameters(m_device, m_camera);
-  }
+  updateCameraAspect();
 
   const size_t totalSize = size_t(size.x) * size_t(size.y);
   m_buffers.color = detail::allocate<uint32_t>(totalSize);

tsd/src/tsd/rendering/pipeline/passes/AnariSceneRenderPass.h

@@ -33,6 +33,7 @@ struct AnariSceneRenderPass : public ImagePass
   void setEnableInstanceId(bool on);
   void setEnableAlbedo(bool on);
   void setEnableNormals(bool on);
+  void setUseImplicitAspectRatio(bool on);
 
   void startFirstFrame(bool waitForCompletion = false);
 
@@ -43,6 +44,7 @@ struct AnariSceneRenderPass : public ImagePass
 
  private:
   void updateSize() override;
+  void updateCameraAspect();
   void render(ImageBuffers &b, int stageId) override;
   void copyFrameData();
   void composite(ImageBuffers &b, int stageId);
@@ -58,6 +60,7 @@ struct AnariSceneRenderPass : public ImagePass
   bool m_enableAlbedo{false};
   bool m_enableNormals{false};
   bool m_runAsync{true};
+  bool m_useImplicitAspectRatio{false};
 
   anari::DataType m_format{ANARI_UFIXED8_RGBA_SRGB};