vtkWebGPUContextDevice2DPrivate.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 vtkWebGPUContextDevice2DPrivate_h
#define vtkWebGPUContextDevice2DPrivate_h
 
#include "vtkWebGPUContextDevice2D.h"
#include "vtkWebGPUHandle.h"
#include "vtkWebGPURenderWindow.h"
#include <unordered_map>
#include <webgpu/webgpu.h>
 
VTK_ABI_NAMESPACE_BEGIN

 
class vtkWebGPULinearAllocator
{
public:
  vtkWebGPULinearAllocator(const std::string& label)
    : Label(label)
  {
  }
 
  ~vtkWebGPULinearAllocator()
  {
    if (this->CurrentBuffer)
      wgpuBufferRelease(this->CurrentBuffer);
    for (WGPUBuffer buf : this->StaleBuffers)
      wgpuBufferRelease(buf);
  }

  void Reset()
  {
    this->CurrentOffset = 0;
 
    for (WGPUBuffer buf : this->StaleBuffers)
    {
      wgpuBufferRelease(buf);
    }
    this->StaleBuffers.clear();
  }

  uint64_t Allocate(vtkWebGPUConfiguration* config, uint64_t sizeInBytes, WGPUBufferUsage usage)
  {
    uint64_t alignedSize = (sizeInBytes + 3) & ~3ull;
 
    if (!this->CurrentBuffer || this->CurrentOffset + alignedSize > this->Capacity)
    {
      if (this->CurrentBuffer)
      {
        this->StaleBuffers.push_back(this->CurrentBuffer);
      }
 
      this->Capacity =
        std::max({ this->Capacity * 2, alignedSize, static_cast<uint64_t>(4194304) });
 
      this->CurrentBuffer = config->CreateBuffer(
        this->Capacity, usage | WGPUBufferUsage_CopyDst, false, this->Label.c_str());
 
      this->CurrentOffset = 0;
    }
 
    uint64_t allocatedOffset = this->CurrentOffset;
    this->CurrentOffset += alignedSize;
    return allocatedOffset;
  }

  WGPUBuffer GetBuffer() const { return this->CurrentBuffer; }
 
private:
  std::string Label;
  WGPUBuffer CurrentBuffer = nullptr;
  uint64_t Capacity = 0;
  uint64_t CurrentOffset = 0;
  std::vector<WGPUBuffer> StaleBuffers;
};

class vtkWebGPUContextDevice2D::Private
{
public:
  vtkWebGPUConfiguration* Config = nullptr;
  vtkWebGPURenderPipelineCache* PipelineCache = nullptr;

  struct PipelineConfig
  {
    WGPUPrimitiveTopology topology;
    double haveColors;
    double haveTCoords;
    double haveLines;
    vtkWebGPU::RenderPipeline* outPipeline;
  };

  struct CachedTexture
  {
    WGPUTexture Texture = nullptr;
    WGPUTextureView View = nullptr;
    WGPUBindGroup BindGroup = nullptr;
    WGPUSampler Sampler = nullptr;
    vtkMTimeType ModifiedTime = 0;
    int Properties = 0;
    int Width = 0;
    int Height = 0;
  };

  struct CachedTextData
  {
    vtkSmartPointer<vtkImageData> Image;
    int BBox[4];
  };
 
  WGPURenderPipeline TrianglePipeline = nullptr;
  WGPURenderPipeline LinePipeline = nullptr;
  WGPURenderPipeline TexturedPipeline = nullptr;
 
  vtkWebGPULinearAllocator VertexAllocator{ "Context2D Dynamic VBO" };
  WGPUBuffer ColorBuffer = nullptr;
  WGPUBuffer MatrixUniformBuffer = nullptr;
  WGPUBindGroup TransformBindGroup;
  WGPUPipelineLayout PipelineLayout = nullptr;
  WGPUVertexBufferLayout VertexBufferLayout;
 
  WGPUTexture DummyTexture = nullptr;
  WGPUTextureView DummyTextureView = nullptr;
  WGPUSampler DefaultSampler = nullptr;
  WGPUBindGroup ActiveTextureBindGroup = nullptr;
  WGPUBindGroupLayout BindGroupLayout = nullptr;
 
  std::unordered_map<vtkImageData*, CachedTexture> ImageCache;
  std::unordered_map<std::string, CachedTexture> TextCache;
  std::unordered_map<std::string, CachedTextData> TextImageCache;
 
  std::vector<float> BatchedVertices;
  WGPURenderPipeline CurrentBatchPipeline = nullptr;
  WGPUBindGroup CurrentBatchBindGroup = nullptr;
 
  bool ClippingEnabled = false;
  int ClipRect[4] = { 0, 0, 0, 0 };
 
  bool MatricesDirty = true;
};
 
VTK_ABI_NAMESPACE_END
 
#endif // vtkWebGPUContextDevice2DPrivate_h