Rendering/ANARI/vtkAnariDevice.cxx

@@ -11,8 +11,15 @@
 #include <memory>
 #include <sstream>
 
+#include <anari/anari_cpp/ext/std.h>
+
 VTK_ABI_NAMESPACE_BEGIN
 
+using namespace anari::std_types;
+using vec2_d = std::array<double, 2>;
+using vec3_d = std::array<double, 3>;
+using vec4_d = std::array<double, 4>;
+
 // ----------------------------------------------------------------------------
 static void AnariStatusCallback(const void* userData, anari::Device device, anari::Object source,
   anari::DataType sourceType, anari::StatusSeverity severity, anari::StatusCode code,
@@ -68,6 +75,10 @@ public:
     const char* deviceName = "default");
   void CleanupAnariObjects();
 
+  template <typename T>
+  void SetDeviceParameter(const char* p, const T& v);
+  void CommitDeviceParameters();
+
   std::string AnariLibraryName;
   std::string AnariDeviceName;
   std::string AnariDebugTraceDir;
@@ -215,6 +226,24 @@ void vtkAnariDeviceInternals::CleanupAnariObjects()
   this->AnariExtensions = {};
 }
 
+//------------------------------------------------------------------------------
+template <typename T>
+void vtkAnariDeviceInternals::SetDeviceParameter(const char* p, const T& v)
+{
+  if (!this->AnariDevice)
+  {
+    return;
+  }
+
+  anari::setParameter(this->AnariDevice, this->AnariDevice, p, v);
+}
+
+//------------------------------------------------------------------------------
+void vtkAnariDeviceInternals::CommitDeviceParameters()
+{
+  anari::commitParameters(this->AnariDevice, this->AnariDevice);
+}
+
 // ----------------------------------------------------------------------------
 vtkStandardNewMacro(vtkAnariDeviceInternals);
 
@@ -261,12 +290,91 @@ const anari::Extensions& vtkAnariDevice::GetAnariDeviceExtensions() const
   return this->Internal->AnariExtensions;
 }
 
+// ----------------------------------------------------------------------------
+const char* const* vtkAnariDevice::GetAnariDeviceExtensionStrings() const
+{
+  return (const char* const*)anariGetDeviceExtensions(
+    this->Internal->AnariLibrary, this->Internal->AnariDeviceName.c_str());
+}
+
 // ----------------------------------------------------------------------------
 void vtkAnariDevice::SetOnNewDeviceCallback(OnNewDeviceCallback&& cb)
 {
   this->Internal->NewDeviceCB = std::move(cb);
 }
 
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameterc(const char* param, char* c)
+{
+  this->Internal->SetDeviceParameter(param, c);
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameterb(const char* param, bool b)
+{
+  this->Internal->SetDeviceParameter(param, b);
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameteri(const char* param, int x)
+{
+  this->Internal->SetDeviceParameter(param, x);
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameter2i(const char* param, int x, int y)
+{
+  this->Internal->SetDeviceParameter(param, ivec2{ x, y });
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameter3i(const char* param, int x, int y, int z)
+{
+  this->Internal->SetDeviceParameter(param, ivec3{ x, y, z });
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameter4i(const char* param, int x, int y, int z, int w)
+{
+  this->Internal->SetDeviceParameter(param, ivec4{ x, y, z, w });
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameterf(const char* param, float x)
+{
+  this->Internal->SetDeviceParameter(param, x);
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameter2f(const char* param, float x, float y)
+{
+  this->Internal->SetDeviceParameter(param, vec2{ x, y });
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameter3f(const char* param, float x, float y, float z)
+{
+  this->Internal->SetDeviceParameter(param, vec3{ x, y, z });
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameter4f(const char* param, float x, float y, float z, float w)
+{
+  this->Internal->SetDeviceParameter(param, vec4{ x, y, z, w });
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::SetParameterd(const char* param, double x)
+{
+  this->Internal->SetDeviceParameter(param, x);
+}
+
+//----------------------------------------------------------------------------
+void vtkAnariDevice::CommitParameters()
+{
+  this->Internal->CommitDeviceParameters();
+}
+
 // ----------------------------------------------------------------------------
 vtkAnariDevice::vtkAnariDevice()
 {

Rendering/ANARI/vtkAnariDevice.h

@@ -64,11 +64,38 @@ public:
    */
   const anari::Extensions& GetAnariDeviceExtensions() const;
 
+  /**
+   * Get the current ANARI device extensions as list of strings
+   */
+  const char* const* GetAnariDeviceExtensionStrings() const;
+
   /**
    * Set a callback that gets called whenever a new device has been created
    */
   void SetOnNewDeviceCallback(OnNewDeviceCallback&& cb);
 
+  //@{
+  /**
+   * Methods to set/commit generic parameteters on the underlying
+   * anari::Renderer object.  These are primarily to support setting parameters
+   * from Python -- C++ users can also use the ANARI API directly by using
+   * anari::setParameter() and anari::commitParameters() directly as it is
+   * equivalent.
+   */
+  void SetParameterc(const char* param, char*);
+  void SetParameterb(const char* param, bool);
+  void SetParameteri(const char* param, int);
+  void SetParameter2i(const char* param, int, int);
+  void SetParameter3i(const char* param, int, int, int);
+  void SetParameter4i(const char* param, int, int, int, int);
+  void SetParameterf(const char* param, float);
+  void SetParameter2f(const char* param, float, float);
+  void SetParameter3f(const char* param, float, float, float);
+  void SetParameter4f(const char* param, float, float, float, float);
+  void SetParameterd(const char* param, double);
+  void CommitParameters();
+  //@}
+
 protected:
   /**
    * Default constructor.

Rendering/ANARI/vtkAnariGlyph3DMapperNode.h

+// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+// SPDX-License-Identifier: BSD-3-Clause
+/**
+ * @class   vtkAnariGlyph3DMapperNode
+ * @brief   A Glyph mapper node for ANARI (ANAlytic Rendering Interface).
+ *
+ *
+ * ANARI provides cross-vendor portability to diverse rendering engines,
+ * including those using state-of-the-art ray tracing. This is the Glyph
+ * Mapper node class, which is the ANARI equivalent of the vtkGlyph3DMapper
+ * for glyphs. It is built on top of the vtkAnariCompositePolyDataMapperNode
+ * to reuse existing composite structure traversal and point/mesh rendering
+ * capabilities of ANARI.
+ *
+ * @par Thanks:
+ * Kees van Kooten kvankooten@nvidia.com for creating and contributing the class
+ * and NVIDIA for supporting this work.
+ *
+ */
+
+#ifndef vtkAnariGlyph3DMapperNode_h
+#define vtkAnariGlyph3DMapperNode_h
+
+#include "vtkAnariCompositePolyDataMapperNode.h"
+#include "vtkRenderingAnariModule.h" // For export macro
+
+VTK_ABI_NAMESPACE_BEGIN
+
+class vtkAnariGlyph3DMapperNodeInternals;
+class vtkCompositeDataDisplayAttributes;
+class vtkMapper;
+class vtkProperty;
+class vtkPolyData;
+
+class VTKRENDERINGANARI_EXPORT vtkAnariGlyph3DMapperNode
+  : public vtkAnariCompositePolyDataMapperNode
+{
+public:
+  static vtkAnariGlyph3DMapperNode* New();
+  vtkTypeMacro(vtkAnariGlyph3DMapperNode, vtkAnariCompositePolyDataMapperNode);
+  void PrintSelf(ostream& os, vtkIndent indent) override;
+
+  /**
+   * Sync VTK and ANARI objects.
+   */
+  virtual void Synchronize(bool prepass) override;
+
+protected:
+  vtkAnariGlyph3DMapperNode();
+  ~vtkAnariGlyph3DMapperNode() override;
+
+  vtkCompositeDataDisplayAttributes* GetCompositeDisplayAttributes() override;
+
+  vtkAnariGlyph3DMapperNodeInternals* Internal = nullptr;
+
+private:
+  vtkAnariGlyph3DMapperNode(const vtkAnariGlyph3DMapperNode&) = delete;
+  void operator=(const vtkAnariGlyph3DMapperNode&) = delete;
+};
+
+VTK_ABI_NAMESPACE_END
+
+#endif

Rendering/ANARI/vtkAnariPass.cxx

@@ -237,7 +237,8 @@ void vtkAnariPass::Render(const vtkRenderState* s)
     if (rebuildSceneGraph)
     {
       this->SceneGraph = vtkAnariSceneGraph::SafeDownCast(this->Internal->Factory->CreateNode(ren));
-      this->SceneGraph->SetAnariDevice(device, ad->GetAnariDeviceExtensions());
+      this->SceneGraph->SetAnariDevice(
+        device, ad->GetAnariDeviceExtensions(), ad->GetAnariDeviceExtensionStrings());
       this->SceneGraph->SetAnariRenderer(ar->GetHandle());
     }
     else if (ar->GetHandle() != this->SceneGraph->GetRendererHandle())

Rendering/ANARI/vtkAnariPolyDataMapperInheritInterface.cxx

+// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include "vtkAnariPolyDataMapperInheritInterface.h"
+
+#include "vtkProperty.h"
+
+//----------------------------------------------------------------------------
+vtkAnariPolyDataMapperInheritInterface::~vtkAnariPolyDataMapperInheritInterface() {}
+
+//----------------------------------------------------------------------------
+void vtkAnariPolyDataMapperInheritInterface::SetDevice(
+  anari::Device& device, anari::Extensions& extensions, const char* const* anariExtensionStrings)
+{
+  this->AnariDevice = device;
+  this->AnariExtensions = extensions;
+  this->AnariExtensionStrings = anariExtensionStrings;
+}
+
+//----------------------------------------------------------------------------
+int vtkAnariPolyDataMapperInheritInterface::GetSurfaceRepresentation(vtkProperty* property) const
+{
+  return property->GetRepresentation();
+}
+
+//----------------------------------------------------------------------------
+vtkAnariPolyDataMapperInheritInterface::ParameterFlags
+vtkAnariPolyDataMapperInheritInterface::GetBaseUpdateResponsibility() const
+{
+  return ParameterFlags();
+}
+
+//----------------------------------------------------------------------------
+anari::Geometry vtkAnariPolyDataMapperInheritInterface::InitializeSpheres(vtkPolyData*,
+  vtkProperty*, std::vector<vec3>&, std::vector<uint32_t>&, double, vtkDataArray*,
+  vtkPiecewiseFunction*, std::vector<vec2>&, std::vector<float>&, std::vector<vec4>&, int)
+{
+  return anari::newObject<anari::Geometry>(this->AnariDevice, "sphere");
+}
+
+//----------------------------------------------------------------------------
+anari::Geometry vtkAnariPolyDataMapperInheritInterface::InitializeCurves(vtkPolyData*, vtkProperty*,
+  std::vector<vec3>&, std::vector<uint32_t>&, double, vtkDataArray*, vtkPiecewiseFunction*,
+  std::vector<vec2>&, std::vector<float>&, std::vector<vec4>&, int)
+{
+  return anari::newObject<anari::Geometry>(this->AnariDevice, "curve");
+}
+
+//----------------------------------------------------------------------------
+anari::Geometry vtkAnariPolyDataMapperInheritInterface::InitializeCylinders(vtkPolyData*,
+  vtkProperty*, std::vector<vec3>&, std::vector<uint32_t>&, double, vtkDataArray*,
+  vtkPiecewiseFunction*, std::vector<vec2>&, std::vector<float>&, std::vector<vec4>&, int)
+{
+  return anari::newObject<anari::Geometry>(this->AnariDevice, "cylinder");
+}
+
+//----------------------------------------------------------------------------
+anari::Geometry vtkAnariPolyDataMapperInheritInterface::InitializeTriangles(vtkPolyData*,
+  vtkProperty*, std::vector<vec3>&, std::vector<uint32_t>&, std::vector<vec3>&, std::vector<vec2>&,
+  std::vector<float>&, std::vector<vec4>&, int)
+{
+  return anari::newObject<anari::Geometry>(this->AnariDevice, "triangle");
+}
+
+//----------------------------------------------------------------------------
+const char* vtkAnariPolyDataMapperInheritInterface::GetSpheresPostfix() const
+{
+  return "_spheres_";
+}
+
+//----------------------------------------------------------------------------
+const char* vtkAnariPolyDataMapperInheritInterface::GetCurvesPostfix() const
+{
+  return "_curves_";
+}
+
+//----------------------------------------------------------------------------
+const char* vtkAnariPolyDataMapperInheritInterface::GetCylindersPostfix() const
+{
+  return "_cylinders_";
+}
+
+//----------------------------------------------------------------------------
+const char* vtkAnariPolyDataMapperInheritInterface::GetTrianglesPostfix() const
+{
+  return "_triangles_";
+}

Rendering/ANARI/vtkAnariPolyDataMapperInheritInterface.h

+// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+// SPDX-License-Identifier: BSD-3-Clause
+/**
+ * @class   vtkAnariPolyDataMapperInheritInterface
+ * @brief   Interface for inheriting classes for overriding mapper functionality
+ *
+ * Interface for inheriting classes for overriding mapper functionality
+ *
+ * @par Thanks:
+ * Kevin Griffin kgriffin@nvidia.com for creating and contributing the class
+ * and NVIDIA for supporting this work.
+ */
+
+#ifndef vtkAnariPolyDataMapperInheritInterface_h
+#define vtkAnariPolyDataMapperInheritInterface_h
+
+#include <anari/anari_cpp.hpp>
+#include <anari/anari_cpp/ext/std.h>
+
+#include <vector>
+
+class vtkDataArray;
+class vtkPiecewiseFunction;
+class vtkPolyData;
+class vtkProperty;
+
+using uvec2 = anari::std_types::uvec2;
+using uvec3 = anari::std_types::uvec3;
+using vec2 = anari::std_types::vec2;
+using vec3 = anari::std_types::vec3;
+using vec4 = anari::std_types::vec4;
+using mat4 = anari::std_types::mat4;
+
+class vtkAnariPolyDataMapperInheritInterface
+{
+public:
+  virtual ~vtkAnariPolyDataMapperInheritInterface();
+
+  /**
+   * Specifies parameter flags, which can be used by inheriting
+   * classes to specify which parameter it takes responsibility for.
+   */
+  struct ParameterFlags
+  {
+    bool Positions = true;
+    bool Indices = true;
+    bool Normals = true;
+    bool Scales = true;
+    bool Texcoords = true;
+    bool Colors = true;
+  };
+
+  /**
+   * Set the ANARI device to write to.
+   */
+  virtual void SetDevice(
+    anari::Device& device, anari::Extensions& extensions, const char* const* anariExtensionStrings);
+
+  /**
+   * Inheriting classes can own (override) representation choice,
+   * creation of anari geometries and parameter updates thereof.
+   */
+  virtual int GetSurfaceRepresentation(vtkProperty* property) const;
+  virtual ParameterFlags GetBaseUpdateResponsibility() const;
+
+  virtual anari::Geometry InitializeSpheres(vtkPolyData* polyData, vtkProperty* property,
+    std::vector<vec3>& vertices, std::vector<uint32_t>& indexArray, double pointSize,
+    vtkDataArray* scaleArray, vtkPiecewiseFunction* scaleFunction, std::vector<vec2>& textureCoords,
+    std::vector<float>& pointValueTextureCoords, std::vector<vec4>& pointColors, int cellFlag);
+  virtual anari::Geometry InitializeCurves(vtkPolyData* polyData, vtkProperty* property,
+    std::vector<vec3>& vertices, std::vector<uint32_t>& indexArray, double lineWidth,
+    vtkDataArray* scaleArray, vtkPiecewiseFunction* scaleFunction, std::vector<vec2>& textureCoords,
+    std::vector<float>& pointValueTextureCoords, std::vector<vec4>& pointColors, int cellFlag);
+  virtual anari::Geometry InitializeCylinders(vtkPolyData* polyData, vtkProperty* property,
+    std::vector<vec3>& vertices, std::vector<uint32_t>& indexArray, double lineWidth,
+    vtkDataArray* scaleArray, vtkPiecewiseFunction* scaleFunction, std::vector<vec2>& textureCoords,
+    std::vector<float>& pointValueTextureCoords, std::vector<vec4>& pointColors, int cellFlag);
+  virtual anari::Geometry InitializeTriangles(vtkPolyData* polyData, vtkProperty* property,
+    std::vector<vec3>& vertices, std::vector<uint32_t>& indexArray, std::vector<vec3>& normals,
+    std::vector<vec2>& textureCoords, std::vector<float>& pointValueTextureCoords,
+    std::vector<vec4>& pointColors, int cellFlag);
+
+  /**
+   * Inheriting classes can also influence the postfix of the created prim names.
+   */
+  virtual const char* GetSpheresPostfix() const;
+  virtual const char* GetCurvesPostfix() const;
+  virtual const char* GetCylindersPostfix() const;
+  virtual const char* GetTrianglesPostfix() const;
+
+  anari::Device AnariDevice{ nullptr };
+  anari::Extensions AnariExtensions{};
+  const char* const* AnariExtensionStrings{ nullptr };
+};
+
+#endif

Rendering/ANARI/vtkAnariPolyDataMapperNode.h

@@ -20,11 +20,11 @@
 VTK_ABI_NAMESPACE_BEGIN
 
 class vtkActor;
+class vtkAnariPolyDataMapperInheritInterface;
 class vtkAnariPolyDataMapperNodeInternals;
 class vtkAnariActorNode;
-class vtkPolyData;
-class vtkDataSetSurfaceFilter;
 class vtkAnariSceneGraph;
+class vtkPolyData;
 
 class VTKRENDERINGANARI_EXPORT vtkAnariPolyDataMapperNode : public vtkPolyDataMapperNode
 {
@@ -59,6 +59,9 @@ protected:
   bool ActorWasModified() const;
   void RenderSurfaceModels();
   void ClearSurfaces();
+  void SetActorNodeName();
+
+  void SetInheritInterface(vtkAnariPolyDataMapperInheritInterface* inheritInterface);
 
   void AnariRenderPoly(vtkAnariActorNode* const anariActorNode, vtkPolyData* const poly,
     double* const diffuse, const double opacity, const std::string& materialName);

Rendering/ANARI/vtkAnariRenderer.cxx

@@ -140,55 +140,55 @@ const char* vtkAnariRenderer::GetSubtype() const
 }
 
 //----------------------------------------------------------------------------
-void vtkAnariRenderer::SetParameter(const char* param, bool b)
+void vtkAnariRenderer::SetParameterb(const char* param, bool b)
 {
   this->Internal->SetRendererParameter(param, b);
 }
 
 //----------------------------------------------------------------------------
-void vtkAnariRenderer::SetParameter(const char* param, int x)
+void vtkAnariRenderer::SetParameteri(const char* param, int x)
 {
   this->Internal->SetRendererParameter(param, x);
 }
 
 //----------------------------------------------------------------------------
-void vtkAnariRenderer::SetParameter(const char* param, int x, int y)
+void vtkAnariRenderer::SetParameter2i(const char* param, int x, int y)
 {
   this->Internal->SetRendererParameter(param, ivec2{ x, y });
 }
 
 //----------------------------------------------------------------------------
-void vtkAnariRenderer::SetParameter(const char* param, int x, int y, int z)
+void vtkAnariRenderer::SetParameter3i(const char* param, int x, int y, int z)
 {
   this->Internal->SetRendererParameter(param, ivec3{ x, y, z });
 }
 
 //----------------------------------------------------------------------------
-void vtkAnariRenderer::SetParameter(const char* param, int x, int y, int z, int w)
+void vtkAnariRenderer::SetParameter4i(const char* param, int x, int y, int z, int w)
 {
   this->Internal->SetRendererParameter(param, ivec4{ x, y, z, w });
 }
 
 //----------------------------------------------------------------------------
-void vtkAnariRenderer::SetParameter(const char* param, float x)
+void vtkAnariRenderer::SetParameterf(const char* param, float x)
 {
   this->Internal->SetRendererParameter(param, x);
 }
 
 //----------------------------------------------------------------------------
-void vtkAnariRenderer::SetParameter(const char* param, float x, float y)
+void vtkAnariRenderer::SetParameter2f(const char* param, float x, float y)
 {
   this->Internal->SetRendererParameter(param, vec2{ x, y });
 }
 
 //----------------------------------------------------------------------------
-void vtkAnariRenderer::SetParameter(const char* param, float x, float y, float z)
+void vtkAnariRenderer::SetParameter3f(const char* param, float x, float y, float z)
 {
   this->Internal->SetRendererParameter(param, vec3{ x, y, z });
 }
 
 //----------------------------------------------------------------------------
-void vtkAnariRenderer::SetParameter(const char* param, float x, float y, float z, float w)
+void vtkAnariRenderer::SetParameter4f(const char* param, float x, float y, float z, float w)
 {
   this->Internal->SetRendererParameter(param, vec4{ x, y, z, w });
 }