vtkWebGPUComputePassTextureStorageInternals.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 vtkWebGPUComputePassTextureStorageInternals_h
#define vtkWebGPUComputePassTextureStorageInternals_h
 
#include "vtkObject.h"
#include "vtkSmartPointer.h"               // for smart pointers
#include "vtkWeakPointer.h"                // for the weak pointer of the parent compute pass
#include "vtkWebGPUComputePass.h"          // for enum
#include "vtkWebGPUComputeRenderTexture.h" // for compute render textures
#include "vtkWebGPUComputeTexture.h"       // for compute textures
#include "vtkWebGPUComputeTextureView.h"   // for compute texture views
#include "vtkWebGPUConfiguration.h"        // for ivar
#include "vtk_wgpu.h"                      // for webgpu
 
#include <cstddef>
#include <unordered_map>
#include <unordered_set>
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkWebGPUComputePass;
 
class vtkWebGPUComputePassTextureStorageInternals : public vtkObject
{
public:
  static vtkWebGPUComputePassTextureStorageInternals* New();
  vtkTypeMacro(vtkWebGPUComputePassTextureStorageInternals, vtkObject);
 
  vtkSetSmartPointerMacro(ParentPassWGPUConfiguration, vtkWebGPUConfiguration);
 
  void SetComputePass(vtkWeakPointer<vtkWebGPUComputePass> parentComputePass);
 
  bool CheckTextureIndex(std::size_t textureIndex, const std::string& callerFunctionName);
 
  bool CheckTextureViewIndex(std::size_t textureViewIndex, const std::string& callerFunctionName);
 
  bool CheckTextureCorrectness(vtkWebGPUComputeTexture* texture);
 
  bool CheckTextureViewCorrectness(vtkWebGPUComputeTextureView* textureView);
 
  bool CheckParentComputePass(const std::string& callerFunctionName);
 
  void RecreateTexture(std::size_t textureIndex);
 
  vtkSmartPointer<vtkWebGPUComputeTexture> GetComputeTexture(std::size_t textureIndex);
 
  vtkSmartPointer<vtkWebGPUComputeTextureView> GetTextureView(std::size_t textureViewIndex);
 
  void RecreateComputeTexture(std::size_t textureIndex);
 
  void RecreateTextureViews(std::size_t textureIndex);
 
  void RecreateTextureView(std::size_t textureViewIndex);
 
  wgpu::TextureView CreateWebGPUTextureView(
    vtkSmartPointer<vtkWebGPUComputeTextureView> textureView, wgpu::Texture wgpuTexture);
 
  void UpdateComputeTextureAndViews(
    vtkSmartPointer<vtkWebGPUComputeTexture> texture, wgpu::Texture newWgpuTexture);
 
  int AddRenderTexture(vtkSmartPointer<vtkWebGPUComputeRenderTexture> renderTexture);
 
  int AddTexture(vtkSmartPointer<vtkWebGPUComputeTexture> texture);
 
  int AddTextureView(vtkSmartPointer<vtkWebGPUComputeTextureView> textureView);
 
  vtkSmartPointer<vtkWebGPUComputeTextureView> CreateTextureView(std::size_t textureIndex);
 
  void RecreateRenderTexture(vtkSmartPointer<vtkWebGPUComputeRenderTexture> renderTexture);
 
  void DeleteTextureViews(std::size_t textureIndex);
 
  void RebindTextureView(std::size_t group, uint32_t binding, std::size_t textureViewIndex);
 
  /*
   * This function maps the buffer, making it accessible to the CPU. This is
   * an asynchronous operation, meaning that the given callback will be called
   * when the mapping is done.
   *
   * The buffer data can then be read from the callback and stored
   * in a buffer (std::vector<>, vtkDataArray, ...) passed in via the userdata pointer for example
   */
  void ReadTextureFromGPU(std::size_t textureIndex, int mipLevel,
    vtkWebGPUComputePass::TextureMapAsyncCallback callback, void* userdata);
 
  void WriteTexture(std::size_t textureIndex, const void* bytes, std::size_t numBytes)
  {
    if (!CheckTextureIndex(textureIndex, "UpdateTextureData"))
    {
      return;
    }
 
    wgpu::Texture wgpuTexture;
    vtkSmartPointer<vtkWebGPUComputeTexture> texture;
    wgpuTexture = this->WebGPUTextures[textureIndex];
    texture = this->Textures[textureIndex];
 
    if (numBytes > static_cast<std::size_t>(texture->GetByteSize()))
    {
      vtkLog(ERROR,
        "The given data is larger than what the texture \""
          << texture->GetLabel() << "\" with byte size: " << texture->GetByteSize());
 
      return;
    }
 
    wgpu::Extent3D textureExtents = { texture->GetWidth(), texture->GetHeight(),
      texture->GetDepth() };
 
    wgpu::ImageCopyTexture copyTexture;
    copyTexture.aspect = wgpu::TextureAspect::All;
    copyTexture.mipLevel = 0;
    copyTexture.origin = { 0, 0, 0 };
    copyTexture.texture = wgpuTexture;
 
    wgpu::TextureDataLayout textureDataLayout;
    textureDataLayout.nextInChain = nullptr;
    textureDataLayout.bytesPerRow = texture->GetBytesPerPixel() * textureExtents.width;
    textureDataLayout.offset = 0;
    textureDataLayout.rowsPerImage = textureExtents.height;
 
    // Uploading from std::vector or vtkDataArray if one of the two is present
    this->ParentPassWGPUConfiguration->GetDevice().GetQueue().WriteTexture(
      &copyTexture, bytes, numBytes, &textureDataLayout, &textureExtents);
  }
 
  void ReleaseResources();
 
  static wgpu::TextureDimension ComputeTextureDimensionToWebGPU(
    vtkWebGPUComputeTexture::TextureDimension dimension);
 
  static wgpu::TextureViewDimension ComputeTextureDimensionToViewDimension(
    vtkWebGPUComputeTexture::TextureDimension dimension);
 
  static wgpu::TextureFormat ComputeTextureFormatToWebGPU(
    vtkWebGPUComputeTexture::TextureFormat format);
 
  static wgpu::TextureUsage ComputeTextureModeToUsage(
    vtkWebGPUComputeTexture::TextureMode mode, const std::string& textureLabel);
 
  static wgpu::StorageTextureAccess ComputeTextureModeToShaderStorage(
    vtkWebGPUComputeTexture::TextureMode mode, const std::string& textureLabel);
 
  static wgpu::StorageTextureAccess ComputeTextureViewModeToShaderStorage(
    vtkWebGPUComputeTextureView::TextureViewMode mode, const std::string& textureViewLabel);
 
  static wgpu::TextureSampleType ComputeTextureSampleTypeToWebGPU(
    vtkWebGPUComputeTexture::TextureSampleType sampleType);
 
  static wgpu::TextureAspect ComputeTextureViewAspectToWebGPU(
    vtkWebGPUComputeTextureView::TextureViewAspect aspect);
 
protected:
  vtkWebGPUComputePassTextureStorageInternals() = default;
  ~vtkWebGPUComputePassTextureStorageInternals() override;
 
private:
  friend class vtkWebGPUComputePassInternals;
 
  // Compute pass that uses this texture storage
  vtkWeakPointer<vtkWebGPUComputePass> ParentComputePass = nullptr;
  // Device of the parent compute pass that is used when creating textures and texture views
  vtkSmartPointer<vtkWebGPUConfiguration> ParentPassWGPUConfiguration;
 
  // Compute textures of the storage
  std::vector<vtkSmartPointer<vtkWebGPUComputeTexture>> Textures;
  // Compute render textures of this the storage
  std::vector<vtkSmartPointer<vtkWebGPUComputeRenderTexture>> RenderTextures;
  // Maps the compute render texture to the internal wgpu::Texture that they use
  std::unordered_map<vtkSmartPointer<vtkWebGPUComputeRenderTexture>, wgpu::Texture>
    RenderTexturesToWebGPUTexture;
  // WebGPU textures associated with the compute texture in the same order
  std::vector<wgpu::Texture> WebGPUTextures;
 
  // A map of the compute textures associated with all the texture views of it
  // that have been created
  std::unordered_map<vtkSmartPointer<vtkWebGPUComputeTexture>,
    std::unordered_set<vtkSmartPointer<vtkWebGPUComputeTextureView>>>
    ComputeTextureToViews;
  // List of the texture views added by the user. Can be used to find a texture
  // view from its index (indices which the user manipulates)
  std::vector<vtkSmartPointer<vtkWebGPUComputeTextureView>> TextureViews;
  // Compute textures views mapped to their WebGPU textures views
  std::unordered_map<vtkSmartPointer<vtkWebGPUComputeTextureView>, wgpu::TextureView>
    TextureViewsToWebGPUTextureViews;
};
 
VTK_ABI_NAMESPACE_END
 
#endif