vtkWebGPURenderWindow.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 vtkWebGPURenderWindow_h
#define vtkWebGPURenderWindow_h
 
#include "vtkRenderWindow.h"
 
#include "vtkRenderingWebGPUModule.h"      // for export macro
#include "vtkTypeUInt8Array.h"             // for ivar
#include "vtkWebGPUComputePipeline.h"      // for the compute pipelines of this render window
#include "vtkWebGPUComputeRenderTexture.h" // for compute render textures
#include "vtkWebGPURenderPipelineCache.h"  // for vtkWebGPURenderPipelineCache
#include "vtkWebGPUShaderDatabase.h"       // for shader database
#include "vtk_wgpu.h"                      // for webgpu
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkWebGPUComputeOcclusionCuller;
class vtkWebGPUConfiguration;
 
class VTKRENDERINGWEBGPU_EXPORT vtkWebGPURenderWindow : public vtkRenderWindow
{
public:
  vtkTypeMacro(vtkWebGPURenderWindow, vtkRenderWindow);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  virtual bool WindowSetup() = 0;
 
  virtual void CreateAWindow() = 0;
 
  virtual void DestroyWindow() = 0;
 
  void Initialize() override;
 
  void Start() override;
 
  void End() override;
 
  void Render() override;
 
  void StereoMidpoint() override;
  void Frame() override;
 
  const char* GetRenderingBackend() override;
 
  void ReadPixels();
 
 
  unsigned char* GetPixelData(int x, int y, int x2, int y2, int front, int right) override;
  int GetPixelData(
    int x, int y, int x2, int y2, int front, vtkUnsignedCharArray* data, int right) override;
  int SetPixelData(
    int x, int y, int x2, int y2, unsigned char* data, int front, int right) override;
  int SetPixelData(
    int x, int y, int x2, int y2, vtkUnsignedCharArray* data, int front, int right) override;
 
 
  float* GetRGBAPixelData(int x, int y, int x2, int y2, int front, int right = 0) override;
  int GetRGBAPixelData(
    int x, int y, int x2, int y2, int front, vtkFloatArray* data, int right = 0) override;
  int SetRGBAPixelData(
    int x, int y, int x2, int y2, float* data, int front, int blend = 0, int right = 0) override;
  int SetRGBAPixelData(int x, int y, int x2, int y2, vtkFloatArray* data, int front, int blend = 0,
    int right = 0) override;
  void ReleaseRGBAPixelData(float* data) override;
  unsigned char* GetRGBACharPixelData(
    int x, int y, int x2, int y2, int front, int right = 0) override;
  int GetRGBACharPixelData(
    int x, int y, int x2, int y2, int front, vtkUnsignedCharArray* data, int right = 0) override;
  int SetRGBACharPixelData(int x, int y, int x2, int y2, unsigned char* data, int front,
    int blend = 0, int right = 0) override;
  int SetRGBACharPixelData(int x, int y, int x2, int y2, vtkUnsignedCharArray* data, int front,
    int blend = 0, int right = 0) override;
 
 
  float* GetZbufferData(int x1, int y1, int x2, int y2) override;
  int GetZbufferData(int x1, int y1, int x2, int y2, float* z) override;
  int GetZbufferData(int x1, int y1, int x2, int y2, vtkFloatArray* buffer) override;
  int SetZbufferData(int x1, int y1, int x2, int y2, float* buffer) override;
  int SetZbufferData(int x1, int y1, int x2, int y2, vtkFloatArray* buffer) override;
 
  int GetColorBufferSizes(int* rgba) override;
  void WaitForCompletion() override;
 
  int SupportsOpenGL() override;
 
  const char* ReportCapabilities() override;
 
  bool InitializeFromCurrentContext() override;
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
  void SetWGPUConfiguration(vtkWebGPUConfiguration* config);
  vtkGetSmartPointerMacro(WGPUConfiguration, vtkWebGPUConfiguration);
 
  vtkGetNewMacro(WGPUShaderDatabase, vtkWebGPUShaderDatabase);
 
  vtkGetNewMacro(WGPUPipelineCache, vtkWebGPURenderPipelineCache);
 
  std::string PreprocessShaderSource(const std::string& source) const;
 
  wgpu::RenderPassEncoder NewRenderPass(wgpu::RenderPassDescriptor& descriptor);
 
  wgpu::RenderBundleEncoder NewRenderBundleEncoder(wgpu::RenderBundleEncoderDescriptor& descriptor);
 
  wgpu::CommandEncoder GetCommandEncoder();
 
  void CreateCommandEncoder();
 
  void FlushCommandBuffers(vtkTypeUInt32 count, wgpu::CommandBuffer* buffers);
 
  wgpu::TextureView GetOffscreenColorAttachmentView();
 
  wgpu::TextureView GetDepthStencilView();
 
  wgpu::TextureFormat GetDepthStencilFormat();
 
  bool HasStencil();
 
  wgpu::Device GetDevice();
 
  wgpu::Adapter GetAdapter();
 
  wgpu::TextureFormat GetPreferredSurfaceTextureFormat();
 
 
  vtkSmartPointer<vtkWebGPUComputeRenderTexture> AcquireDepthBufferRenderTexture();
 
  vtkSmartPointer<vtkWebGPUComputeRenderTexture> AcquireFramebufferRenderTexture();
 
protected:
  vtkWebGPURenderWindow();
  ~vtkWebGPURenderWindow() override;
 
  virtual std::string MakeDefaultWindowNameWithBackend() = 0;
 
  bool WGPUInit();
  void WGPUFinalize();
 
  void ConfigureSurface();
  void UnconfigureSurface();
 
  void CreateOffscreenColorAttachments();
  void DestroyOffscreenColorAttachments();
 
  void CreateDepthStencilTexture();
  void DestroyDepthStencilTexture();
 
  void CreateFSQGraphicsPipeline();
  void DestroyFSQGraphicsPipeline();
 
  void RecreateComputeRenderTextures();
 
  void RenderOffscreenTexture();
 
  bool RenderTexturesSetup = false;
 
  wgpu::Surface Surface;
  wgpu::CommandEncoder CommandEncoder;
  int SurfaceConfiguredSize[2];
  wgpu::TextureFormat PreferredSurfaceTextureFormat = wgpu::TextureFormat::BGRA8Unorm;
 
  struct vtkWGPUDeptStencil
  {
    wgpu::Texture Texture;
    wgpu::TextureView View;
    wgpu::TextureFormat Format;
    bool HasStencil;
  };
  vtkWGPUDeptStencil DepthStencil;
 
  struct vtkWGPUColorAttachment
  {
    wgpu::Texture Texture;
    wgpu::TextureView View;
    wgpu::TextureFormat Format;
    wgpu::Buffer OffscreenBuffer;
  };
  vtkWGPUColorAttachment ColorAttachment;
 
  struct vtkWGPUUserStagingPixelData
  {
    wgpu::Origin3D Origin;
    wgpu::Extent3D Extent;
    wgpu::TextureDataLayout Layout;
    wgpu::Buffer Buffer; // for SetPixelData
  };
  vtkWGPUUserStagingPixelData StagingPixelData;
 
  struct vtkWGPUFullScreenQuad
  {
    wgpu::RenderPipeline Pipeline;
    wgpu::BindGroup BindGroup;
  };
 
  vtkWGPUFullScreenQuad FSQ;
 
  struct MappingContext
  {
    vtkSmartPointer<vtkTypeUInt8Array> dst;
    wgpu::Buffer src;
    unsigned long size;
    vtkWebGPURenderWindow* window;
  } BufferMapReadContext;
 
  vtkNew<vtkTypeUInt8Array> CachedPixelBytes;
  vtkSmartPointer<vtkWebGPUConfiguration> WGPUConfiguration;
  vtkNew<vtkWebGPUShaderDatabase> WGPUShaderDatabase;
  vtkNew<vtkWebGPURenderPipelineCache> WGPUPipelineCache;
 
  int ScreenSize[2];
 
private:
  // For accessing SubmitCommandBuffer to submit custom prop render work
  friend class vtkWebGPUComputeOcclusionCuller;
 
  vtkWebGPURenderWindow(const vtkWebGPURenderWindow&) = delete;
  void operator=(const vtkWebGPURenderWindow&) = delete;
 
  void InitializeRendererComputePipelines();
 
  void SubmitCommandBuffer(int count, wgpu::CommandBuffer* commandBuffer);
 
  void PostRenderComputePipelines();
 
  void PostRasterizationRender();
 
  void CopyFramebufferToOffscreenBuffer();
 
  // Render textures acquired by the user on this render window. They are kept here in case the
  // render window is resized, in which case, we'll need to resize the render textures --> We need
  // access to the textures
  std::vector<vtkSmartPointer<vtkWebGPUComputeRenderTexture>> ComputeRenderTextures;
};
 
VTK_ABI_NAMESPACE_END
#endif