vtkWebGPURenderer.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 vtkWebGPURenderer_h
#define vtkWebGPURenderer_h
 
#include "vtkRenderer.h"
 
#include "vtkRenderingWebGPUModule.h" // for export macro
#include "vtkSmartPointer.h"          // for ivar
#include "vtkWebGPUComputePipeline.h" // for the compute pipelines used by this renderer
#include "vtk_wgpu.h"                 // for webgpu
 
#include <string>        // for ivar
#include <unordered_map> // for ivar
#include <unordered_set> // for the set of actors rendered last frame
 
class vtkAbstractMapper;
class vtkRenderState;
class vtkFrameBufferObjectBase;
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkWebGPUComputeOcclusionCuller;
 
class VTKRENDERINGWEBGPU_EXPORT vtkWebGPURenderer : public vtkRenderer
{
public:
  static vtkWebGPURenderer* New();
  vtkTypeMacro(vtkWebGPURenderer, vtkRenderer);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  struct RenderPipelineBatch
  {
    vtkSmartPointer<vtkPropCollection> Props;
    wgpu::RenderPipeline Pipeline;
  };
 
  // get the complexity of the current lights as a int
  // 0 = no lighting
  // 1 = headlight
  // 2 = directional lights
  // 3 = positional lights
  enum LightingComplexityEnum
  {
    NoLighting = 0,
    Headlight = 1,
    Directional = 2,
    Positional = 3
  };
  vtkGetMacro(LightingComplexity, int);
 
  enum RenderStageEnum
  {
    AwaitingPreparation,
    UpdatingBuffers,
    RecordingCommands,
    Finished,
    RenderPostRasterization
  };
 
  void DeviceRender() override;
 
  void UpdateBuffers();
 
  int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr) override;
 
  void ConfigureComputeRenderBuffers(vtkSmartPointer<vtkWebGPUComputePipeline> computePipeline);
 
  void ConfigureComputePipelines();
 
 
  const std::vector<vtkSmartPointer<vtkWebGPUComputePipeline>>& GetSetupPreRenderComputePipelines();
  const std::vector<vtkSmartPointer<vtkWebGPUComputePipeline>>&
  GetSetupPostRenderComputePipelines();
 
  int UpdateLights() override;
 
  void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false) override;
 
  void ReleaseGraphicsResources(vtkWindow* w) override;
 
  inline wgpu::RenderPassEncoder GetRenderPassEncoder() { return this->WGPURenderEncoder; }
  inline wgpu::RenderBundleEncoder GetRenderBundleEncoder() { return this->WGPUBundleEncoder; }
  inline wgpu::BindGroup GetActorBindGroup() { return this->ActorBindGroup; }
  inline wgpu::BindGroup GetSceneBindGroup() { return this->SceneBindGroup; }
 
  inline void PopulateBindgroupLayouts(std::vector<wgpu::BindGroupLayout>& layouts)
  {
    layouts.emplace_back(this->SceneBindGroupLayout);
    layouts.emplace_back(this->ActorBindGroupLayout);
  }
 
 
  void AddPreRenderComputePipeline(vtkSmartPointer<vtkWebGPUComputePipeline> pipeline);
  void AddPostRenderComputePipeline(vtkSmartPointer<vtkWebGPUComputePipeline> pipeline);
 
  std::unordered_set<vtkProp*> GetPropsRendered() { return this->PropsRendered; }
 
 
  void SetUserLightTransform(vtkTransform* transform);
  vtkTransform* GetUserLightTransform();
 
 
  vtkSetMacro(UseRenderBundles, bool);
  vtkBooleanMacro(UseRenderBundles, bool);
  vtkGetMacro(UseRenderBundles, bool);
 
  vtkGetEnumMacro(RenderStage, RenderStageEnum);
 
protected:
  vtkWebGPURenderer();
  ~vtkWebGPURenderer() override;
 
  int UpdateOpaquePolygonalGeometry() override;
  int UpdateTranslucentPolygonalGeometry() override;
 
  // Setup scene and actor bindgroups. Actor has dynamic offsets.
  void SetupBindGroupLayouts();
  // Create buffers for the bind groups.
  void CreateBuffers();
  // Create scene bind group.
  void SetupSceneBindGroup();
  // Create actor bind group.
  void SetupActorBindGroup();
 
  // Start, finish recording commands with render pass encoder
  void BeginRecording();
  void EndRecording();
 
  std::size_t WriteLightsBuffer(std::size_t offset = 0);
  std::size_t WriteSceneTransformsBuffer(std::size_t offset = 0);
  std::size_t WriteActorBlocksBuffer(std::size_t offset = 0);
 
  wgpu::RenderPassEncoder WGPURenderEncoder;
  wgpu::RenderBundleEncoder WGPUBundleEncoder;
  wgpu::Buffer SceneTransformBuffer;
  wgpu::Buffer SceneLightsBuffer;
  wgpu::Buffer ActorBlocksBuffer;
  std::size_t LastActorBufferSize = 0;
  wgpu::BindGroup SceneBindGroup;
  wgpu::BindGroupLayout SceneBindGroupLayout;
 
  wgpu::BindGroup ActorBindGroup;
  wgpu::BindGroupLayout ActorBindGroupLayout;
 
#ifdef __EMSCRIPTEN__
  bool UseRenderBundles = true;
#else
  bool UseRenderBundles = false;
#endif
  // one bundle per actor. bundle gets reused every frame.
  // these bundles can be built in parallel with vtkSMPTools. holding off because not
  // sure how to get emscripten to thread.
  std::vector<wgpu::RenderBundle> Bundles;
  struct vtkWGPUPropItem
  {
    wgpu::RenderBundle Bundle = nullptr;
    vtkTypeUInt32 DynamicOffset = 0;
  };
  std::unordered_map<vtkProp*, vtkWGPUPropItem> PropWGPUItems;
 
  int LightingComplexity = 0;
  std::size_t NumberOfLightsUsed = 0;
  std::vector<std::size_t> LightIDs;
 
  vtkMTimeType LightingUpdateTime;
  vtkTimeStamp LightingUploadTimestamp;
 
  struct
  {
    uint32_t Hits = 0;
    uint32_t Misses = 0;
    uint32_t TotalRequests = 0;
  } BundleCacheStats;
 
  vtkSmartPointer<vtkTransform> UserLightTransform;
 
private:
  friend class vtkWebGPUComputeOcclusionCuller;
  // For the mapper to access 'AddPostRasterizationActor'
  friend class vtkWebGPUComputePointCloudMapper;
  // For render window accessing PostRenderComputePipelines()
  friend class vtkWebGPURenderWindow;
 
  vtkWebGPURenderer(const vtkWebGPURenderer&) = delete;
  void operator=(const vtkWebGPURenderer&) = delete;
 
  void InitComputePipeline(vtkSmartPointer<vtkWebGPUComputePipeline> pipeline);
 
 
  void PreRenderComputePipelines();
  void PostRenderComputePipelines();
 
  void PostRasterizationRender();
 
  void AddPostRasterizationActor(vtkActor* actor);
 
  std::vector<vtkSmartPointer<vtkWebGPUComputePipeline>> SetupPreRenderComputePipelines;
  std::vector<vtkSmartPointer<vtkWebGPUComputePipeline>> SetupPostRenderComputePipelines;
 
  std::vector<vtkSmartPointer<vtkWebGPUComputePipeline>> NotSetupPreRenderComputePipelines;
  std::vector<vtkSmartPointer<vtkWebGPUComputePipeline>> NotSetupPostRenderComputePipelines;
 
  std::vector<vtkActor*> PostRasterizationActors;
 
  wgpu::CommandBuffer EncodePropListRenderCommand(vtkProp** propList, int listLength);
 
  bool ComputeBuffersInitialized = false;
 
  RenderStageEnum RenderStage = RenderStageEnum::AwaitingPreparation;
 
  bool DoClearPass = true;
 
  std::unordered_set<vtkProp*> PropsRendered;
};
 
VTK_ABI_NAMESPACE_END
#endif