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

    const auto wgpuTexture = this->WebGPUTextures[textureIndex];
    auto& 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;
    }

    // Uploading from std::vector or vtkDataArray if one of the two is present
    const std::string textureLabel = texture->GetLabel();
    const char* textureLabelCStr = textureLabel.c_str();
    const uint32_t bytesPerRow = texture->GetBytesPerPixel() * texture->GetWidth();
    this->ParentPassWGPUConfiguration->WriteTexture(wgpuTexture, bytesPerRow, numBytes, bytes,
      /*srcOffset=*/0, /*dstOffset=*/{ 0, 0, 0 }, /*dstMipLevel=*/0,
      /*textureLabel=*/textureLabelCStr);
  }

  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;

  vtkWebGPUComputePassTextureStorageInternals(
    const vtkWebGPUComputePassTextureStorageInternals&) = delete;
  void operator=(const vtkWebGPUComputePassTextureStorageInternals&) = delete;

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