vtkOpenGLContextDevice2D.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkOpenGLContextDevice2D.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/

#ifndef vtkOpenGLContextDevice2D_h
#define vtkOpenGLContextDevice2D_h

#include "vtkRenderingContextOpenGL2Module.h" // For export macro
#include "vtkContextDevice2D.h"

#include <vector> // STL Header
#include <list> // for std::list

class vtkMatrix4x4;
class vtkOpenGLExtensionManager;
class vtkOpenGLHelper;
class vtkOpenGLRenderWindow;
class vtkPath;
class vtkRenderer;
class vtkShaderProgram;
class vtkStringToImage;
class vtkTransform;
class vtkViewport;
class vtkWindow;

class VTKRENDERINGCONTEXTOPENGL2_EXPORT vtkOpenGLContextDevice2D : public vtkContextDevice2D
{
public:
  vtkTypeMacro(vtkOpenGLContextDevice2D, vtkContextDevice2D);
  void PrintSelf(ostream &os, vtkIndent indent) override;

  static vtkOpenGLContextDevice2D *New();

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

  void DrawLines(float *f, 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 DrawPointSprites(vtkImageData *sprite, float *points, int n,
                                unsigned char* colors = nullptr, int nc_comps = 0) override;

  void DrawMarkers(int shape, bool highlight, float *points, int n,
                           unsigned char *colors = nullptr, int nc_comps = 0) override;


  vtkSetMacro(MaximumMarkerCacheSize, int)
  vtkGetMacro(MaximumMarkerCacheSize, int)

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

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

  void DrawPolygon(float *, int) 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 DrawString(float *point, const vtkUnicodeString &string) override;

  void ComputeStringBounds(const vtkUnicodeString &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 MultiplyMatrix(vtkMatrix3x3 *m) override;

  void SetMatrix(vtkMatrix3x3 *m) override;

  void GetMatrix(vtkMatrix3x3 *m) override;

  void PushMatrix() override;

  void PopMatrix() override;

  /*
   * Supply an int array of length 4 with x1, y1, width, height specifying
   * clipping region for the device in pixels.
   */
  void SetClipping(int *x) override;

  void EnableClipping(bool enable) override;

  void Begin(vtkViewport* viewport) override;

  void End() override;

  void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId) override;

  void BufferIdModeEnd() override;

  bool SetStringRendererToFreeType();

  bool SetStringRendererToQt();

  bool HasGLSL();


  vtkGetObjectMacro(RenderWindow, vtkOpenGLRenderWindow);

  virtual void ReleaseGraphicsResources(vtkWindow *window);


  vtkMatrix4x4 *GetProjectionMatrix();
  vtkMatrix4x4 *GetModelMatrix();

protected:
  vtkOpenGLContextDevice2D();
  ~vtkOpenGLContextDevice2D() override;

  int GetNumberOfArcIterations(float rX,
                               float rY,
                               float startAngle,
                               float stopAngle);

  vtkRenderer *Renderer;

  bool InRender;


  class Private;
  Private *Storage;

  class CellArrayHelper;
  CellArrayHelper* PolyDataImpl;

  vtkOpenGLRenderWindow* RenderWindow;

  vtkOpenGLHelper *LinesCBO;  // vertex + color
  void ReadyLinesCBOProgram();
  vtkOpenGLHelper *LinesBO;  // vertex
  void ReadyLinesBOProgram();
  vtkOpenGLHelper *VCBO;  // vertex + color
  void ReadyVCBOProgram();
  vtkOpenGLHelper *VBO;  // vertex
  void ReadyVBOProgram();
  vtkOpenGLHelper *VTBO;  // vertex + tcoord
  void ReadyVTBOProgram();
  vtkOpenGLHelper *SCBO;  // sprite + color
  void ReadySCBOProgram();
  vtkOpenGLHelper *SBO;  // sprite
  void ReadySBOProgram();

  void SetMatrices(vtkShaderProgram *prog);
  void BuildVBO(vtkOpenGLHelper *cbo,
    float *v, int nv,
    unsigned char *coolors, int nc,
    float *tcoords);
  void CoreDrawTriangles(std::vector<float> &tverts, unsigned char* colors = nullptr,
    int numComp = 0);
  // used for stipples
  unsigned short LinePattern;


  void DrawMarkersGL2PS(int shape, bool highlight, float *points, int n,
                        unsigned char *colors, int nc_comps);
  void DrawCrossMarkersGL2PS(bool highlight, float *points, int n,
                             unsigned char *colors, int nc_comps);
  void DrawPlusMarkersGL2PS(bool highlight, float *points, int n,
                            unsigned char *colors, int nc_comps);
  void DrawSquareMarkersGL2PS(bool highlight, float *points, int n,
                              unsigned char *colors, int nc_comps);
  void DrawCircleMarkersGL2PS(bool highlight, float *points, int n,
                              unsigned char *colors, int nc_comps);
  void DrawDiamondMarkersGL2PS(bool highlight, float *points, int n,
                               unsigned char *colors, int nc_comps);


  void DrawImageGL2PS(float p[2], vtkImageData *image);
  void DrawImageGL2PS(float p[2], float scale, vtkImageData *image);
  void DrawImageGL2PS(const vtkRectf &rect, vtkImageData *image);


  void DrawCircleGL2PS(float x, float y, float rX, float rY);
  void DrawWedgeGL2PS(float x, float y, float outRx, float outRy,
                      float inRx, float inRy);

  void AddEllipseToPath(vtkPath *path, float x, float y, float rx, float ry,
                        bool reverse);

  void TransformPath(vtkPath *path) const;

  void TransformPoint(float &x, float &y) const;

  void TransformSize(float &dx, float &dy) const;

private:
  vtkOpenGLContextDevice2D(const vtkOpenGLContextDevice2D &) = delete;
  void operator=(const vtkOpenGLContextDevice2D &) = delete;

  vtkImageData *GetMarker(int shape, int size, bool highlight);

  class vtkMarkerCacheObject
  {
  public:
    vtkTypeUInt64 Key;
    vtkImageData *Value;
    bool operator==(vtkTypeUInt64 key)
    {
      return this->Key == key;
    }
  };

  void ComputeStringBoundsInternal(const vtkUnicodeString &string,
                                   float bounds[4]);

  vtkTransform *ProjectionMatrix;
  vtkTransform *ModelMatrix;

  std::list<vtkMarkerCacheObject> MarkerCache;
  int MaximumMarkerCacheSize;

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

};

#endif //vtkOpenGLContextDevice2D_h