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 C API
 
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);
  VTK_MAYSUSPEND
  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;


  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  VTK_MAYSUSPEND
  void SetWGPUConfiguration(vtkWebGPUConfiguration* config);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  vtkGetSmartPointerMacro(WGPUConfiguration, vtkWebGPUConfiguration);

  vtkGetNewMacro(WGPUShaderDatabase, vtkWebGPUShaderDatabase);

  vtkGetNewMacro(WGPUPipelineCache, vtkWebGPURenderPipelineCache);

  vtkGetNewMacro(WGPUTextureCache, vtkWebGPURenderTextureCache);

  std::string PreprocessShaderSource(const std::string& source) const;

  WGPURenderPassEncoder NewRenderPass(WGPURenderPassDescriptor& descriptor);

  WGPURenderBundleEncoder NewRenderBundleEncoder(WGPURenderBundleEncoderDescriptor& descriptor);

  WGPUCommandEncoder GetCommandEncoder();

  void CreateCommandEncoder();

  void FlushCommandBuffers(vtkTypeUInt32 count, WGPUCommandBuffer* buffers);

  WGPUTextureView GetOffscreenColorAttachmentView();
  WGPUTextureView GetHardwareSelectorAttachmentView();

  WGPUTextureView GetDepthStencilView();

  WGPUTextureFormat GetDepthStencilFormat();

  bool HasStencil();

  WGPUDevice GetDevice();

  WGPUAdapter GetAdapter();

  WGPUTextureFormat GetPreferredSurfaceTextureFormat();

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

  void SetInteractor(vtkRenderWindowInteractor*) override;

  bool EnsureDisplay() override;

  void* GetGenericDisplayId() override;


  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void SetCustomSurfaceDescriptor(const WGPUSurfaceDescriptor* descriptor);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  const WGPUSurfaceDescriptor* GetCustomSurfaceDescriptor() const;
 
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, WGPUCommandBuffer* commandBuffer);

  void PostRenderComputePipelines();

  void PostRasterizationRender();
 
  struct ComponentMapping
  {
    int Map[4];
    int InComponents;
    int OutComponents;
    bool Valid;
  };

  ComponentMapping GetComponentMapping(WGPUTextureFormat format, int desiredOutComponents);
 
  template <typename TOutput, typename TInput>
  struct PixelReadbackCallbackData
  {
    TOutput* OutputValues;
    uint32_t Width, Height;
    ComponentMapping Mapping;
    std::function<TOutput(TInput)> Converter;
    // Set once the mapped pixels have been copied into OutputValues. The caller
    // owns the flag and waits on it; see GetTextureDataInternal.
    bool* Mapped;
  };

  template <typename TOutput, typename TInput>
  TOutput* GetTextureDataInternal(WGPUTexture texture, WGPUTextureFormat 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(WGPUTexture& wgpuTexture, WGPUTextureFormat format, std::size_t mipLevel,
    WGPUTextureAspect aspect, WGPUOrigin3D offsets, WGPUExtent3D extents,
    TextureMapCallback callback, void* userData);

  void ReadTextureFromGPU(WGPUTexture& wgpuTexture, WGPUTextureFormat format, std::size_t mipLevel,
    WGPUTextureAspect aspect, TextureMapCallback callback, void* userData);

  bool WGPUInit();

  void WGPUFinalize();

  void CreateSurface();
  WGPUSurface CreateSurfaceFromHardwareWindow(WGPUInstance instance);

  void ConfigureSurface();

  void UnconfigureSurface();

  bool RendersOffScreenOnly();


  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;
 
  WGPUSurface Surface = nullptr;
  WGPUTexture SurfaceTexture = nullptr;
  WGPUCommandEncoder CommandEncoder = nullptr;
  int SurfaceConfiguredSize[2];
  WGPUTextureFormat PreferredSurfaceTextureFormat = WGPUTextureFormat_BGRA8Unorm;
  WGPUTextureFormat PreferredSelectorIdsTextureFormat = WGPUTextureFormat_RGBA32Uint;
  struct vtkWGPUDepthStencil
  {
    WGPUTexture Texture = nullptr;
    WGPUTextureView View = nullptr;
    WGPUTextureFormat Format;
    bool HasStencil;
  };
  vtkWGPUDepthStencil DepthStencilAttachment;
 
  struct vtkWGPUAttachment
  {
    WGPUTexture Texture = nullptr;
    WGPUTextureView View = nullptr;
    WGPUTextureFormat Format;
  };
  vtkWGPUAttachment ColorAttachment;
  vtkWGPUAttachment IdsAttachment;
 
  struct vtkWGPUUserStagingPixelData
  {
    // Defined out of line: the members need the WGPU_*_INIT defaults, and
    // vtkWrapHierarchy cannot expand those macros.
    vtkWGPUUserStagingPixelData();
    WGPUOrigin3D Origin;
    WGPUExtent3D Extent;
    WGPUTexelCopyBufferLayout Layout;
    WGPUBuffer Buffer = nullptr; // for SetPixelData
  };
  vtkWGPUUserStagingPixelData StagingPixelData;
 
  struct vtkWGPUFullScreenQuad
  {
    std::string Key;
    WGPUBindGroup BindGroup = nullptr;
  };
  vtkWGPUFullScreenQuad ColorCopyRenderPipeline;
 
  vtkSmartPointer<vtkWebGPUConfiguration> WGPUConfiguration;
  vtkNew<vtkWebGPUShaderDatabase> WGPUShaderDatabase;
  vtkNew<vtkWebGPURenderPipelineCache> WGPUPipelineCache;
  vtkNew<vtkWebGPURenderTextureCache> WGPUTextureCache;
 
  const WGPUSurfaceDescriptor* CustomSurfaceDescriptor = nullptr;
 
  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