vtkWebGPUPolyDataMapper.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkWebGPUPolyDataMapper_h
#define vtkWebGPUPolyDataMapper_h
 
#include "vtkPolyDataMapper.h"
 
#include "vtkProperty.h"                       // for VTK_SURFACE constants
#include "vtkRenderingWebGPUModule.h"          // for export macro
#include "vtkWebGPUCellToPrimitiveConverter.h" // for TopologySourceType
#include "vtkWebGPUComputePipeline.h"          // for ivar
#include "vtkWrappingHints.h"                  // For VTK_MARSHALAUTO
#include "vtk_wgpu.h"                          // for webgpu C API
 
#include <array>         // for ivar
#include <unordered_set> // for the not set compute render buffers
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCellArray;
class vtkOverrideAttribute;
class vtkWebGPUActor;
class vtkWebGPURenderWindow;
class vtkWebGPURenderer;
class vtkWebGPUComputeRenderBuffer;
class vtkWebGPUTexture;
class vtkWebGPUConfiguration;
 
class VTKRENDERINGWEBGPU_EXPORT VTK_MARSHALAUTO vtkWebGPUPolyDataMapper : public vtkPolyDataMapper
{
public:
  static vtkWebGPUPolyDataMapper* New();
  VTK_NEWINSTANCE
  static vtkOverrideAttribute* CreateOverrideAttributes();
  vtkTypeMacro(vtkWebGPUPolyDataMapper, vtkPolyDataMapper);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum PointDataAttributes : int
  {
    POINT_POSITIONS = 0,
    POINT_COLORS,
    POINT_NORMALS,
    POINT_TANGENTS,
    POINT_UVS,
    POINT_COLOR_UVS,
    POINT_NB_ATTRIBUTES,
    POINT_UNDEFINED
  };

  enum CellDataAttributes : int
  {
    CELL_COLORS = 0,
    CELL_NORMALS,
    CELL_NB_ATTRIBUTES,
    CELL_UNDEFINED
  };

  enum GraphicsPipelineType : int
  {
    // Pipeline that renders points, is best suitable for rendering 1-pixel wide points.
    GFX_PIPELINE_POINTS = 0,
    GFX_PIPELINE_POINTS_HOMOGENEOUS_CELL_SIZE,
    // Pipeline that renders points using a square or circle shape.
    GFX_PIPELINE_POINTS_SHAPED,
    GFX_PIPELINE_POINTS_SHAPED_HOMOGENEOUS_CELL_SIZE,
    // Pipeline that is best suitable for rendering 1-pixel thick line segments
    GFX_PIPELINE_LINES,
    GFX_PIPELINE_LINES_HOMOGENEOUS_CELL_SIZE,
    // Pipeline that can render lines thicker than 1-pixel. This pipeline does not
    // create joining geometry between contiguous line segments in a polyline.
    GFX_PIPELINE_LINES_THICK,
    GFX_PIPELINE_LINES_THICK_HOMOGENEOUS_CELL_SIZE,
    // Pipeline that renders lines with rounded caps and rounded joins.
    GFX_PIPELINE_LINES_ROUND_CAP_ROUND_JOIN,
    GFX_PIPELINE_LINES_ROUND_CAP_ROUND_JOIN_HOMOGENEOUS_CELL_SIZE,
    // Pipeline that renders lines with miter joins.
    GFX_PIPELINE_LINES_MITER_JOIN,
    GFX_PIPELINE_LINES_MITER_JOIN_HOMOGENEOUS_CELL_SIZE,
    // Pipeline that renders triangles
    GFX_PIPELINE_TRIANGLES,
    GFX_PIPELINE_TRIANGLES_HOMOGENEOUS_CELL_SIZE,
    GFX_PIPELINE_NB_TYPES
  };
 
  vtkPolyDataMapper::MapperHashType GenerateHash(vtkPolyData* polydata) override;

  void RenderPiece(vtkRenderer* renderer, vtkActor* act) override;

  void ReleaseGraphicsResources(vtkWindow*) override;

  bool GetSupportsSelection() override { return false; }

  void MapDataArrayToVertexAttribute(const char* vertexAttributeName, const char* dataArrayName,
    int fieldAssociation, int componentno = -1) override;

  void MapDataArrayToMultiTextureAttribute(const char* tname, const char* dataArrayName,
    int fieldAssociation, int componentno = -1) override;

  void RemoveVertexAttributeMapping(const char* vertexAttributeName) override;

  void RemoveAllVertexAttributeMappings() override;

  void ProcessSelectorPixelBuffers(
    vtkHardwareSelector* sel, std::vector<unsigned int>& pixeloffsets, vtkProp* prop) override;

  vtkSmartPointer<vtkWebGPUComputeRenderBuffer> AcquirePointAttributeComputeRenderBuffer(
    PointDataAttributes attribute, int bufferGroup, int bufferBinding, int uniformsGroup,
    int uniformsBinding);

  vtkSmartPointer<vtkWebGPUComputeRenderBuffer> AcquireCellAttributeComputeRenderBuffer(
    CellDataAttributes attribute, int bufferGroup, int bufferBinding, int uniformsGroup,
    int uniformsBinding);
 
protected:
  vtkWebGPUPolyDataMapper();
  ~vtkWebGPUPolyDataMapper() override;

  void ComputeBounds() override;

  void RecordDrawCommands(
    vtkRenderer* renderer, vtkActor* actor, const WGPURenderPassEncoder& passEncoder);
  void RecordDrawCommands(
    vtkRenderer* renderer, vtkActor* actor, const WGPURenderBundleEncoder& bundleEncoder);

  virtual void DeducePointCellAttributeAvailability();

  virtual std::vector<WGPUBindGroupLayoutEntry> GetMeshBindGroupLayoutEntries();

  virtual std::vector<WGPUBindGroupLayoutEntry> GetTopologyBindGroupLayoutEntries(
    bool homogeneousCellSize, bool useEdgeArray);

  virtual std::vector<WGPUBindGroupEntry> GetMeshBindGroupEntries();

  virtual std::vector<WGPUBindGroupEntry> GetTopologyBindGroupEntries(
    vtkWebGPUCellToPrimitiveConverter::TopologySourceType topologySourceType,
    bool homogeneousCellSize, bool useEdgeArray);

  virtual unsigned long GetPointAttributeByteSize(
    vtkWebGPUPolyDataMapper::PointDataAttributes attribute);

  virtual unsigned long GetCellAttributeByteSize(
    vtkWebGPUPolyDataMapper::CellDataAttributes attribute);

  virtual bool ShouldReleaseGraphicsResourcesOnSync();

  virtual void BeginUpdateMeshGeometryBuffers();
  virtual void UpdateMeshGeometryBuffers(vtkWebGPUConfiguration* wgpuConfiguration);

  virtual void EndUpdateMeshGeometryBuffers();

  virtual bool EnsureInput();

  virtual void UpdateMeshTopologyBuffers(
    vtkWebGPUConfiguration* wgpuConfiguration, vtkProperty* displayProperty);
 
  virtual std::vector<WGPUVertexBufferLayout> GetVertexBufferLayouts() { return {}; }
 
  virtual void SetVertexBuffers(const WGPURenderPassEncoder& vtkNotUsed(passEncoder)) {}
  virtual void SetVertexBuffers(const WGPURenderBundleEncoder& vtkNotUsed(bundleEncoder)) {}

  virtual void ApplyShaderReplacements(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
 
  virtual void ReplaceShaderConstantsDef(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
  virtual void ReplaceShaderActorDef(GraphicsPipelineType pipelineType, vtkWebGPURenderer* renderer,
    vtkWebGPUActor* actor, std::string& vss, std::string& fss);
  virtual void ReplaceShaderClippingPlanesDef(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
  virtual void ReplaceShaderCustomDef(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
 
  virtual void ReplaceShaderRendererBindings(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
  virtual void ReplaceShaderActorBindings(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
  virtual void ReplaceShaderClippingPlanesBindings(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
  virtual void ReplaceShaderMeshAttributeBindings(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
  virtual void ReplaceShaderCustomBindings(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
  virtual void ReplaceShaderTopologyBindings(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
  virtual void ReplaceShaderVertexOutputDef(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss, std::string& fss);
 
  virtual void ReplaceVertexShaderInputDef(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderMainStart(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderCamera(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderNormalTransform(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderVertexId(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderPrimitiveId(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderCellId(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderPosition(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderClippingPlanes(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderPositionVC(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderPicking(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderColors(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderUVs(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderEdges(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderNormals(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderTangents(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
  virtual void ReplaceVertexShaderMainEnd(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& vss);
 
  virtual void ReplaceFragmentShaderOutputDef(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);
 
  virtual void ReplaceFragmentShaderMainStart(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);
  virtual void ReplaceFragmentShaderClippingPlanes(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);
  virtual void ReplaceFragmentShaderColors(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);
  virtual void ReplaceFragmentShaderNormals(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);
  virtual void ReplaceFragmentShaderEdges(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);
  virtual void ReplaceFragmentShaderLights(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);
  virtual void ReplaceFragmentShaderPicking(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);
  virtual void ReplaceFragmentShaderCoincidentOffset(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);
  virtual void ReplaceFragmentShaderMainEnd(GraphicsPipelineType pipelineType,
    vtkWebGPURenderer* renderer, vtkWebGPUActor* actor, std::string& fss);

  virtual bool IsPipelineSupported(GraphicsPipelineType vtkNotUsed(pipelineType)) { return true; }
  static bool IsPipelineForHomogeneousCellSize(GraphicsPipelineType pipelineType);

  virtual WGPUPrimitiveTopology GetPrimitiveTopologyForPipeline(GraphicsPipelineType pipelineType);
 
  struct DrawCallArgs
  {
    std::uint32_t VertexOffset = 0;
    std::uint32_t VertexCount = 0;
    std::uint32_t InstanceOffset = 0;
    std::uint32_t InstanceCount = 0;
  };
  virtual DrawCallArgs GetDrawCallArgs(GraphicsPipelineType pipelineType,
    vtkWebGPUCellToPrimitiveConverter::TopologySourceType topologySourceType);
  virtual DrawCallArgs GetDrawCallArgsForDrawingVertices(
    vtkWebGPUCellToPrimitiveConverter::TopologySourceType topologySourceType);

  WGPUBindGroup CreateMeshAttributeBindGroup(const WGPUDevice& device, const std::string& label);

  WGPUBindGroup CreateTopologyBindGroup(const WGPUDevice& device, const std::string& label,
    vtkWebGPUCellToPrimitiveConverter::TopologySourceType topologySourceType);
 
  struct AttributeBuffer
  {
    WGPUBuffer Buffer = nullptr;
    uint64_t Size = 0;
    uint64_t Watermark = 0;
    bool Touched = false;
  };
  AttributeBuffer PointBuffers[POINT_NB_ATTRIBUTES];
  AttributeBuffer CellBuffers[CELL_NB_ATTRIBUTES];
  struct
  {
    vtkTypeFloat32 PlaneEquations[6][4];
    vtkTypeUInt32 PlaneCount = 0;
  } ClippingPlanesData;
  WGPUBuffer ClippingPlanesBuffer = nullptr;

  vtkTimeStamp CellAttributesBuildTimestamp[CELL_NB_ATTRIBUTES];
  vtkTimeStamp PointAttributesBuildTimestamp[POINT_NB_ATTRIBUTES];
  vtkTimeStamp ClippingPlanesBuildTimestamp;
 
  bool HasPointAttributes[POINT_NB_ATTRIBUTES];
  bool HasCellAttributes[CELL_NB_ATTRIBUTES];
  bool RebuildGraphicsPipelines = true;
  // used by RenderPiece and functions it calls to reduce
  // calls to get the input and allow for rendering of
  // other polydata (not the input)
  vtkPolyData* CurrentInput = nullptr;
  // vtkRenderer culls props to frustum. At that point, it requests
  // mappers for bounds of the geometry. We cache the vtkAlgorithm output
  // so that `UpdateMeshGeometryBuffers` can reuse it without climbing up
  // vtkAlgorithm pipeline.
  vtkPolyData* CachedInput = nullptr;
  vtkSmartPointer<vtkWebGPUTexture> ColorTextureHostResource;
 
  // 1 bind group for this polydata mesh
  WGPUBindGroup MeshAttributeBindGroup = nullptr;
  std::vector<std::uint32_t> MeshAttributeDynamicOffsets;
 
  struct TopologyBindGroupInfo
  {
    // buffer for point ids.
    WGPUBuffer ConnectivityBuffer = nullptr;
    // buffer for the cell ids.
    WGPUBuffer CellIdBuffer = nullptr;
    // buffer for edge array. this lets fragment shader hide internal edges of a polygon
    // when edge visibility is turned on.
    WGPUBuffer EdgeArrayBuffer = nullptr;
    // uniform buffer for cell id offset.
    WGPUBuffer CellIdOffsetUniformBuffer = nullptr;
    // // buffer for indirect draw command
    // WGPUBuffer IndirectDrawBuffer;
    // bind group for the primitive size uniform.
    WGPUBindGroup BindGroup = nullptr;
    // maximum number of vertices in a cell
    vtkTypeUInt32 MaxCellSize = 0;
    // vertexCount for draw call.
    vtkTypeUInt32 VertexCount = 0;
    // composite vertex offset and counts for drawing composite data
    std::vector<std::pair<vtkTypeUInt32, vtkTypeUInt32>> VertexOffsetAndCounts;
  };
 
  enum BindingGroup : int
  {
    GROUP_RENDERER = 0,
    GROUP_ACTOR = 1,
    GROUP_TEXTURES = GROUP_ACTOR,
    GROUP_MESH = 2,
    // Clipping planes are bound to the same group as the mesh attributes
    // because they vary based on the mapper's shift/scale and the actor's
    // transformation matrix.
    GROUP_CLIPPING_PLANES = GROUP_MESH,
    GROUP_TOPOLOGY = 3,
    GROUP_NB_BINDGROUPS = 4
  };
  static_assert(GROUP_NB_BINDGROUPS <= 4,
    "Number of bind groups exceeds 4! Most devices can support only up to 4 bind groups");
  std::array<std::uint32_t, GROUP_NB_BINDGROUPS> NumberOfBindings = {};
  vtkNew<vtkWebGPUCellToPrimitiveConverter> CellConverter;
  TopologyBindGroupInfo
    TopologyBindGroupInfos[vtkWebGPUCellToPrimitiveConverter::NUM_TOPOLOGY_SOURCE_TYPES] = {};
  std::string GraphicsPipelineKeys[GFX_PIPELINE_NB_TYPES] = {};
 
private:
  vtkWebGPUPolyDataMapper(const vtkWebGPUPolyDataMapper&) = delete;
  void operator=(const vtkWebGPUPolyDataMapper&) = delete;
  friend class vtkWebGPUComputeRenderBuffer;
  friend class vtkWebGPURenderer;

  WGPUBuffer GetPointDataWGPUBuffer(PointDataAttributes attribute)
  {
    return this->PointBuffers[attribute].Buffer;
  }

  WGPUBuffer GetCellDataWGPUBuffer(CellDataAttributes attribute)
  {
    return this->CellBuffers[attribute].Buffer;
  }

  void UploadAttributeToGPUBuffer(vtkWebGPUConfiguration* wgpuConfiguration,
    vtkDataArray* dataArray, PointDataAttributes attributeType, float denominator = 1.0f);
  void UploadAttributeToGPUBuffer(vtkWebGPUConfiguration* wgpuConfiguration,
    vtkDataArray* dataArray, CellDataAttributes attributeType, float denominator = 1.0f);

  bool GetNeedToRebuildGraphicsPipelines(vtkActor* actor, vtkRenderer* renderer);

  bool CacheActorRendererProperties(vtkActor* actor, vtkRenderer* renderer);

  void ResetPointCellAttributeState();

  WGPUBindGroupLayout CreateMeshAttributeBindGroupLayout(
    const WGPUDevice& device, const std::string& label);

  WGPUBindGroupLayout CreateTopologyBindGroupLayout(const WGPUDevice& device,
    const std::string& label, bool homogeneousCellSize, bool useEdgeArray);

  unsigned long GetPointAttributeElementSize(
    vtkWebGPUPolyDataMapper::PointDataAttributes attribute);

  unsigned long GetCellAttributeElementSize(vtkWebGPUPolyDataMapper::CellDataAttributes attribute);

  unsigned long GetExactPointBufferSize(PointDataAttributes attribute);

  unsigned long GetExactCellBufferSize(CellDataAttributes attribute);

  bool AllocateAttributeBuffers(vtkWebGPUConfiguration* wgpuConfiguration);

  const char* GetGraphicsPipelineTypeAsString(GraphicsPipelineType graphicsPipelineType);

  void SetupGraphicsPipelines(const WGPUDevice& device, vtkRenderer* renderer, vtkActor* actor);

  void UpdateClippingPlanesBuffer(vtkWebGPUConfiguration* wgpuConfiguration, vtkActor* actor);

  std::vector<vtkSmartPointer<vtkWebGPUComputeRenderBuffer>> SetupComputeRenderBuffers;

  std::unordered_set<vtkSmartPointer<vtkWebGPUComputeRenderBuffer>> NotSetupComputeRenderBuffers;

  const PointDataAttributes PointDataAttributesOrder[PointDataAttributes::POINT_NB_ATTRIBUTES] = {
    PointDataAttributes::POINT_POSITIONS, PointDataAttributes::POINT_COLORS,
    PointDataAttributes::POINT_NORMALS, PointDataAttributes::POINT_TANGENTS,
    PointDataAttributes::POINT_UVS, PointDataAttributes::POINT_COLOR_UVS
  };

  const CellDataAttributes CellDataAttributesOrder[CellDataAttributes::CELL_NB_ATTRIBUTES] = {
    CellDataAttributes::CELL_COLORS, CellDataAttributes::CELL_NORMALS
  };
 
  // Cache these so that subsequent executions of UpdateMeshGeometryBuffers() do not unnecessarily
  // invoke MapScalars().
  int LastScalarMode = -1;
  bool LastScalarVisibility = false;
  vtkTypeUInt32 LastNumClipPlanes = 0;
  struct ActorState
  {
    bool LastActorBackfaceCulling = false;
    bool LastActorFrontfaceCulling = false;
    bool LastVertexVisibility = false;
    int LastRepresentation = VTK_SURFACE;
    bool LastHasRenderingTranslucentGeometry = false;
    int LastPointSize = 1;
    int LastLineWidth = 1;
  };
  std::map<std::pair<vtkActor*, vtkRenderer*>, ActorState> CachedActorRendererProperties;
};
#define vtkWebGPUPolyDataMapper_OVERRIDE_ATTRIBUTES                                                \
  vtkWebGPUPolyDataMapper::CreateOverrideAttributes()
VTK_ABI_NAMESPACE_END
#endif