vtkWebGPUContextDevice2D.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 vtkWebGPUContextDevice2D_h
#define vtkWebGPUContextDevice2D_h
 
#include "vtkContextDevice2D.h"
#include "vtkRenderingWebGPUModule.h" // for export macro
#include "vtk_wgpu.h"                 // for webgpu type
#include <cstdint>                    // For std::uintptr_t
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkImageData;
class vtkMatrix3x3;
class vtkMatrix4x4;
class vtkPolyData;
class vtkTransform;
class vtkUnsignedCharArray;
class vtkWebGPURenderWindow;
class vtkRenderer;
 
class VTKRENDERINGWEBGPU_EXPORT vtkWebGPUContextDevice2D : public vtkContextDevice2D
{
public:
  vtkTypeMacro(vtkWebGPUContextDevice2D, vtkContextDevice2D);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkWebGPUContextDevice2D* New();

  void Begin(vtkViewport* viewport) override;

  void End() override;

  void Flush();


  bool InitializeDeviceResources();
  void InitializeTexture();


  void BufferIdModeBegin(vtkAbstractContextBufferId* /*bufferId*/) override { /*noop*/ }
  void BufferIdModeEnd() override { /*noop*/ }
  void ReleaseCache(std::uintptr_t /*cacheIdentifier*/) override { /*noop*/ }

  void DrawPoly(float* points, int n, unsigned char* colors = nullptr, int nc_comps = 0) override;

  void DrawLines(float* points, int n, unsigned char* colors = nullptr, int nc_comps = 0) override;

  void DrawPoints(float* points, int n, unsigned char* colors = nullptr, int nc_comps = 0) override;
  void DrawPoints(
    vtkDataArray* positions, vtkUnsignedCharArray* colors, std::uintptr_t cacheIdentifier) override;

  void DrawPointSprites(vtkImageData* sprite, float* points, int n, unsigned char* colors = nullptr,
    int nc_comps = 0) override;
  void DrawPointSprites(vtkImageData* sprite, vtkDataArray* positions, vtkUnsignedCharArray* colors,
    std::uintptr_t cacheIdentifier) override;

  void DrawMarkers(int shape, bool highlight, float* points, int n, unsigned char* colors = nullptr,
    int nc_comps = 0) override;
  void DrawMarkers(int shape, bool highlight, vtkDataArray* positions, vtkUnsignedCharArray* colors,
    std::uintptr_t cacheIdentifier) override;

  void DrawQuad(float* points, int n) override;

  void DrawQuadStrip(float* points, int n) override;

  void DrawPolygon(float* points, int n) override;

  void DrawColoredPolygon(
    float* points, int numPoints, unsigned char* colors = nullptr, int nc_comps = 0) override;

  void DrawEllipseWedge(float x, float y, float outRx, float outRy, float inRx, float inRy,
    float startAngle, float stopAngle) override;

  void DrawEllipticArc(
    float x, float y, float rX, float rY, float startAngle, float stopAngle) override;

  void DrawString(float* point, const vtkStdString& string) override;

  void ComputeStringBounds(const vtkStdString& string, float bounds[4]) override;

  void ComputeJustifiedStringBounds(const char* string, float bounds[4]) override;

  void DrawMathTextString(float point[2], const vtkStdString& string) override;

  void DrawImage(float p[2], float scale, vtkImageData* image) override;

  void DrawImage(const vtkRectf& pos, vtkImageData* image) override;

  void DrawPolyData(float p[2], float scale, vtkPolyData* polyData, vtkUnsignedCharArray* colors,
    int scalarMode) override;

  void SetColor4(unsigned char color[4]) override;

  virtual void SetColor(unsigned char color[3]);

  void SetTexture(vtkImageData* image, int properties = 0) override;

  void SetPointSize(float size) override;

  void SetLineWidth(float width) override;

  void SetLineType(int type) override;

  void SetClipping(int* x) override;

  void EnableClipping(bool enable) override;

  void MultiplyMatrix(vtkMatrix3x3* m) override;

  void SetMatrix(vtkMatrix3x3* m) override;

  void GetMatrix(vtkMatrix3x3* m) override;

  void PushMatrix() override;

  void PopMatrix() override;

  virtual void ReleaseGraphicsResources(vtkWindow* /*window*/);
 
protected:
  vtkWebGPUContextDevice2D();
  ~vtkWebGPUContextDevice2D() override;
 
  vtkRenderer* Renderer = nullptr;
  vtkWebGPURenderWindow* RenderWindow = nullptr;
 
  class Private;
  Private* Storage;
 
  vtkTransform* ProjectionMatrix;
  vtkTransform* ModelMatrix;
 
  bool InRender = false;
 
private:
  vtkWebGPUContextDevice2D(const vtkWebGPUContextDevice2D&) = delete;
  void operator=(const vtkWebGPUContextDevice2D&) = delete;
 
  void UpdateCameraUniforms();
  void UpdatePaintUniforms(const unsigned char color[4]);

  WGPURenderPipeline CreatePipelineWithConstants(float haveTCoordsVal = 0.0f,
    float haveLinesVal = 0.0f, WGPUPrimitiveTopology topology = WGPUPrimitiveTopology_TriangleList);

  vtkImageData* GenerateMarker(int shape, int width, bool highlight);

  void ApplyScissorRect(WGPURenderPassEncoder passEncoder);


  void DrawThickLines(
    float* points, int n, unsigned char* colors, int nc, const std::vector<float>& distances);

  void DrawThinLines(
    float* points, int n, unsigned char* colors, int nc, const std::vector<float>& distances);
};
 
VTK_ABI_NAMESPACE_END
 
#endif // vtkWebGPUContextDevice2D_h