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 "vtkWeakPtr.h"               // For vtkWeakPtr
#include "vtkWebGPUComputePipeline.h" // for the compute pipelines used by this renderer
#include "vtkWrappingHints.h"         // For VTK_MARSHALAUTO
#include "vtk_wgpu.h"                 // for webgpu C API
 
#include <unordered_set> // for the set of actors rendered last frame
#include <vector>        // for the list of visible props
 
class vtkAbstractMapper;
class vtkCuller;
class vtkRenderState;
class vtkFrameBufferObjectBase;
class vtkOverrideAttribute;
VTK_ABI_NAMESPACE_BEGIN
 
class vtkWebGPUComputeOcclusionCuller;
class vtkWebGPUDeepFramebuffer;
 
class VTKRENDERINGWEBGPU_EXPORT VTK_MARSHALAUTO vtkWebGPURenderer : public vtkRenderer
{
public:
  static vtkWebGPURenderer* New();
  VTK_NEWINSTANCE
  static vtkOverrideAttribute* CreateOverrideAttributes();
  vtkTypeMacro(vtkWebGPURenderer, vtkRenderer);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  // 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,
    SyncDeviceResources,
    RecordingCommands,
    Finished,
    RenderPostRasterization
  };

  void Clear() override;

  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;
 
  WGPURenderPassEncoder GetRenderPassEncoder() { return this->WGPURenderEncoder; }
  WGPURenderBundleEncoder GetRenderBundleEncoder() { return this->WGPUBundleEncoder; }
  WGPUBindGroup GetSceneBindGroup() { return this->SceneBindGroup; }
 
  void PopulateBindgroupLayouts(std::vector<WGPUBindGroupLayout>& layouts)
  {
    layouts.emplace_back(this->SceneBindGroupLayout);
  }


  void AddPreRenderComputePipeline(vtkSmartPointer<vtkWebGPUComputePipeline> pipeline);
  void AddPostRenderComputePipeline(vtkSmartPointer<vtkWebGPUComputePipeline> pipeline);

  std::unordered_set<vtkProp*> GetPropsRendered() { return this->PropsRendered; }


  vtkSetMacro(UseRenderBundles, bool);
  vtkBooleanMacro(UseRenderBundles, bool);
  vtkGetMacro(UseRenderBundles, bool);

  vtkSetMacro(UseDeepFramebufferTransparency, bool);
  vtkBooleanMacro(UseDeepFramebufferTransparency, bool);
  vtkGetMacro(UseDeepFramebufferTransparency, bool);

  vtkWebGPUDeepFramebuffer* GetDeepFramebuffer();

  bool PrepareDeepFramebuffer();


  vtkGetEnumMacro(RenderStage, RenderStageEnum);

  vtkProp* GetPropWithId(vtkTypeUInt32 id);

  vtkGetMacro(RecordingTranslucentPass, bool);

  void InvalidateBundle()
  {
    this->RebuildRenderBundle = true;
    this->Bundle = nullptr;
  }

  vtkGetMacro(RebuildRenderBundle, bool);
 
protected:
  vtkWebGPURenderer();
  ~vtkWebGPURenderer() override;

  int UpdateOpaquePolygonalGeometry() override;
  int UpdateTranslucentPolygonalGeometry() override;
 
private:
  friend class vtkWebGPUComputeOcclusionCuller;
  // For the mapper to access 'AddPostRasterizationActor'
  friend class vtkWebGPUComputePointCloudMapper;
  // For render window accessing PostRenderComputePipelines()
  friend class vtkWebGPURenderWindow;
  // For the actor to access RenderBundleBuildTime
  friend class vtkWebGPUActor;
 
  vtkWebGPURenderer(const vtkWebGPURenderer&) = delete;
  void operator=(const vtkWebGPURenderer&) = delete;
 
  // Setup scene and actor bindgroups. Actor has dynamic offsets.
  void SetupBindGroupLayouts();
  void CreateBuffers();
  void SetupSceneBindGroup();
 
  void BeginRecording();
  void EndRecording();
 
  std::size_t WriteLightsBuffer(std::size_t offset = 0);
  std::size_t WriteSceneTransformsBuffer(std::size_t offset = 0);

  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;

  WGPUCommandBuffer EncodePropListRenderCommand(vtkProp** propList, int listLength);

  void RecordRenderCommands();

  void ClearGradientBackground();
 
  WGPURenderPassEncoder WGPURenderEncoder = nullptr;
  WGPURenderBundleEncoder WGPUBundleEncoder = nullptr;
  WGPUBuffer SceneTransformBuffer = nullptr;
  WGPUBuffer SceneLightsBuffer = nullptr;
  // Holds the two gradient stop colors, the gradient mode and the dither flag
  // for the background quad drawn by Clear(). Only allocated when a gradient
  // background is requested.
  WGPUBuffer BackgroundGradientBuffer = nullptr;
 
  WGPUBindGroup SceneBindGroup = nullptr;
  WGPUBindGroupLayout SceneBindGroupLayout = nullptr;
 
  bool UseDeepFramebufferTransparency = true;
  bool DeepFramebufferPopulated = false;
  vtkSmartPointer<vtkWebGPUDeepFramebuffer> DeepFramebuffer;
  WGPUBuffer DeepFramebufferPlaceholders[3] = { nullptr, nullptr, nullptr };

  void ResolveDeepFramebuffer(WGPURenderPassEncoder encoder);
 
  std::string DeepFramebufferResolveKey;
 
  // Render bundles enable faster rendering.
  bool UseRenderBundles = true;
  bool RebuildRenderBundle = false;
  // the commands in bundle get reused every frame.
  WGPURenderBundle Bundle = nullptr;
 
  int LightingComplexity = 0;
  std::size_t NumberOfLightsUsed = 0;
  std::vector<std::size_t> LightIDs;
  std::size_t AllocatedLightsBufferSize = 0;
  std::size_t PreviousLightCount = 0;
 
  vtkMTimeType LightingUpdateTime;
  vtkTimeStamp LightingUploadTimestamp;

  bool ComputeBuffersInitialized = false;

  RenderStageEnum RenderStage = RenderStageEnum::AwaitingPreparation;
  bool RecordingTranslucentPass = false;

  bool DrawBackgroundInClearPass = true;

  std::unordered_set<vtkProp*> PropsRendered;

  std::vector<vtkProp*> LastVisibleProps;

  std::vector<vtkProp*> VisibleProps;

  bool VisiblePropSetChanged();

  bool CanReuseRenderBundle() const
  {
    return this->UseRenderBundles && !this->RebuildRenderBundle && this->Bundle != nullptr;
  }

  bool PropSupportsReusingRenderBundle(vtkProp*) const;

  void WarnIfCullingWithRenderBundles();

  vtkTimeStamp RenderBundleBuildTime;

  vtkWeakPtr<vtkCuller> DefaultCuller;
  bool WarnedAboutCullingWithRenderBundles = false;
};
 
#define vtkWebGPURenderer_OVERRIDE_ATTRIBUTES vtkWebGPURenderer::CreateOverrideAttributes()
VTK_ABI_NAMESPACE_END
#endif