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 "vtkWebGPUComputePipeline.h"      // for the compute pipelines of this render window
#include "vtkWebGPUComputeRenderTexture.h" // for compute render textures
#include "vtkWebGPURenderPipelineCache.h"  // for vtkWebGPURenderPipelineCache
#include "vtkWebGPURenderTextureCache.h"   // for texture cache
#include "vtkWebGPUShaderDatabase.h"       // for shader database
#include "vtkWrappingHints.h"              // For VTK_MARSHALAUTO
#include "vtk_wgpu.h"                      // for webgpu

VTK_ABI_NAMESPACE_BEGIN

class vtkOverrideAttribute;
class vtkWebGPUComputeOcclusionCuller;
class vtkWebGPUConfiguration;
class vtkWebGPUTextureCache;
class vtkImageData;
class vtkTypeUInt32Array;
class VTKRENDERINGWEBGPU_EXPORT VTK_MARSHALAUTO vtkWebGPURenderWindow : public vtkRenderWindow
{
public:
  static vtkWebGPURenderWindow* New();
  VTK_NEWINSTANCE
  static vtkOverrideAttribute* CreateOverrideAttributes();
  vtkTypeMacro(vtkWebGPURenderWindow, vtkRenderWindow);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual void CreateAWindow();

  virtual void DestroyWindow();

  void Initialize() override;

  void Finalize() override;

  void Start() override;

  void End() override;

  void Render() override;

  void StereoMidpoint() override;
  void Frame() override;

  const char* GetRenderingBackend() override;

  void* GetGenericContext() override;


  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;


  vtkTypeUInt32* GetIdsData(int x1, int y1, int x2, int y2);
  void GetIdsData(int x1, int y1, int x2, int y2, vtkTypeUInt32Array* data);

  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);

  vtkGetNewMacro(WGPUTextureCache, vtkWebGPURenderTextureCache);

  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 GetHardwareSelectorAttachmentView();

  wgpu::TextureView GetDepthStencilView();

  wgpu::TextureFormat GetDepthStencilFormat();

  bool HasStencil();

  wgpu::Device GetDevice();

  wgpu::Adapter GetAdapter();

  wgpu::TextureFormat GetPreferredSurfaceTextureFormat();

  wgpu::TextureFormat GetPreferredSelectorIdsTextureFormat();


  vtkSmartPointer<vtkWebGPUComputeRenderTexture> AcquireDepthBufferRenderTexture();
  vtkSmartPointer<vtkWebGPUComputeRenderTexture> AcquireFramebufferRenderTexture();

  using TextureMapCallback =
    std::function<void(const void* mappedData, int bytesPerRow, void* userdata)>;

  enum class AttachmentTypeForVTISnapshot
  {
    ColorRGBA,
    ColorRGB,
    Depth,
    Ids,
  };
  vtkSmartPointer<vtkImageData> SaveAttachmentToVTI(AttachmentTypeForVTISnapshot type);

  bool EnsureDisplay() override;

  void* GetGenericDisplayId() override;

protected:
  vtkWebGPURenderWindow();
  ~vtkWebGPURenderWindow() override;

  virtual std::string MakeDefaultWindowNameWithBackend();

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();

  struct ComponentMapping
  {
    int Map[4];
    int InComponents;
    int OutComponents;
    bool Valid;
  };

  ComponentMapping GetComponentMapping(wgpu::TextureFormat format, int desiredOutComponents);

  template <typename TOutput, typename TInput>
  struct PixelReadbackCallbackData
  {
    TOutput* OutputValues;
    uint32_t Width, Height;
    ComponentMapping Mapping;
    std::function<TOutput(TInput)> Converter;
  };

  template <typename TOutput, typename TInput>
  TOutput* GetTextureDataInternal(wgpu::Texture texture, wgpu::TextureFormat format, int x1, int y1,
    int x2, int y2, const ComponentMapping& componentMapping,
    std::function<TOutput(TInput)> converter = nullptr);

  std::uint32_t FlipY(std::uint32_t y);

  void ReadTextureFromGPU(wgpu::Texture& wgpuTexture, wgpu::TextureFormat format,
    std::size_t mipLevel, wgpu::TextureAspect aspect, wgpu::Origin3D offsets,
    wgpu::Extent3D extents, TextureMapCallback callback, void* userData);

  void ReadTextureFromGPU(wgpu::Texture& wgpuTexture, wgpu::TextureFormat format,
    std::size_t mipLevel, wgpu::TextureAspect aspect, TextureMapCallback callback, void* userData);

  bool WGPUInit();

  void WGPUFinalize();

  void CreateSurface();

  void ConfigureSurface();

  void UnconfigureSurface();


  void CreateOffscreenColorAttachment();
  void DestroyOffscreenColorAttachment();


  void CreateIdsAttachment();
  void DestroyIdsAttachment();


  void CreateDepthStencilAttachment();
  void DestroyDepthStencilAttachment();


  void CreateColorCopyPipeline();
  void DestroyColorCopyPipeline();

  void RecreateComputeRenderTextures();

  void RenderOffscreenTexture();

  virtual void SyncWithHardware();

  bool RenderTexturesSetup = false;

  wgpu::Surface Surface;
  wgpu::CommandEncoder CommandEncoder;
  int SurfaceConfiguredSize[2];
  wgpu::TextureFormat PreferredSurfaceTextureFormat = wgpu::TextureFormat::BGRA8Unorm;
  wgpu::TextureFormat PreferredSelectorIdsTextureFormat = wgpu::TextureFormat::RGBA32Uint;
  struct vtkWGPUDepthStencil
  {
    wgpu::Texture Texture;
    wgpu::TextureView View;
    wgpu::TextureFormat Format;
    bool HasStencil;
  };
  vtkWGPUDepthStencil DepthStencilAttachment;

  struct vtkWGPUAttachment
  {
    wgpu::Texture Texture;
    wgpu::TextureView View;
    wgpu::TextureFormat Format;
  };
  vtkWGPUAttachment ColorAttachment;
  vtkWGPUAttachment IdsAttachment;

  struct vtkWGPUUserStagingPixelData
  {
    wgpu::Origin3D Origin;
    wgpu::Extent3D Extent;
    wgpu::TexelCopyBufferLayout Layout;
    wgpu::Buffer Buffer; // for SetPixelData
  };
  vtkWGPUUserStagingPixelData StagingPixelData;

  struct vtkWGPUFullScreenQuad
  {
    std::string Key;
    wgpu::BindGroup BindGroup;
  };
  vtkWGPUFullScreenQuad ColorCopyRenderPipeline;

  vtkSmartPointer<vtkWebGPUConfiguration> WGPUConfiguration;
  vtkNew<vtkWebGPUShaderDatabase> WGPUShaderDatabase;
  vtkNew<vtkWebGPURenderPipelineCache> WGPUPipelineCache;
  vtkNew<vtkWebGPURenderTextureCache> WGPUTextureCache;

  vtkSmartPointer<vtkWebGPUComputePipeline> DepthCopyPipeline;
  vtkSmartPointer<vtkWebGPUComputePass> DepthCopyPass;
  int DepthCopyBufferIndex = 0;
  int DepthCopyTextureIndex = 0;

  int ScreenSize[2];

  // 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;
};

#define vtkWebGPURenderWindow_OVERRIDE_ATTRIBUTES vtkWebGPURenderWindow::CreateOverrideAttributes()
VTK_ABI_NAMESPACE_END
#endif