VTK
vtkOpenGLContextDevice2D.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkOpenGLContextDevice2D.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 
30 #ifndef vtkOpenGLContextDevice2D_h
31 #define vtkOpenGLContextDevice2D_h
32 
33 #include "vtkContextDevice2D.h"
34 #include "vtkRenderingContextOpenGL2Module.h" // For export macro
35 
36 #include <list> // for std::list
37 #include <vector> // STL Header
38 
39 class vtkMatrix4x4;
40 class vtkOpenGLExtensionManager;
41 class vtkOpenGLHelper;
43 class vtkPath;
44 class vtkRenderer;
45 class vtkShaderProgram;
46 class vtkStringToImage;
47 class vtkTransform;
48 class vtkViewport;
49 class vtkWindow;
50 
51 class VTKRENDERINGCONTEXTOPENGL2_EXPORT vtkOpenGLContextDevice2D : public vtkContextDevice2D
52 {
53 public:
55  void PrintSelf(ostream& os, vtkIndent indent) override;
56 
60  static vtkOpenGLContextDevice2D* New();
61 
67  void DrawPoly(float* f, int n, unsigned char* colors = nullptr, int nc_comps = 0) override;
68 
75  void DrawLines(float* f, int n, unsigned char* colors = nullptr, int nc_comps = 0) override;
76 
82  void DrawPoints(float* points, int n, unsigned char* colors = nullptr, int nc_comps = 0) override;
83 
90  void DrawPointSprites(vtkImageData* sprite, float* points, int n, unsigned char* colors = nullptr,
91  int nc_comps = 0) override;
92 
104  void DrawMarkers(int shape, bool highlight, float* points, int n, unsigned char* colors = nullptr,
105  int nc_comps = 0) override;
106 
108 
113  vtkSetMacro(MaximumMarkerCacheSize, int);
114  vtkGetMacro(MaximumMarkerCacheSize, int);
116 
120  void DrawQuad(float* points, int n) override;
121 
125  void DrawQuadStrip(float* points, int n) override;
126 
130  void DrawPolygon(float*, int) override;
131  void DrawColoredPolygon(
132  float* points, int numPoints, unsigned char* colors = nullptr, int nc_comps = 0) override;
133 
145  void DrawEllipseWedge(float x, float y, float outRx, float outRy, float inRx, float inRy,
146  float startAngle, float stopAngle) override;
147 
154  void DrawEllipticArc(
155  float x, float y, float rX, float rY, float startAngle, float stopAngle) override;
156 
160  void DrawString(float* point, const vtkStdString& string) override;
161 
170  void ComputeStringBounds(const vtkStdString& string, float bounds[4]) override;
171 
175  void DrawString(float* point, const vtkUnicodeString& string) override;
176 
185  void ComputeStringBounds(const vtkUnicodeString& string, float bounds[4]) override;
186 
192  void ComputeJustifiedStringBounds(const char* string, float bounds[4]) override;
193 
198  void DrawMathTextString(float point[2], const vtkStdString& string) override;
199 
204  void DrawImage(float p[2], float scale, vtkImageData* image) override;
205 
211  void DrawImage(const vtkRectf& pos, vtkImageData* image) override;
212 
217  void DrawPolyData(float p[2], float scale, vtkPolyData* polyData, vtkUnsignedCharArray* colors,
218  int scalarMode) override;
219 
223  void SetColor4(unsigned char color[4]) override;
224 
228  virtual void SetColor(unsigned char color[3]);
229 
233  void SetTexture(vtkImageData* image, int properties = 0) override;
234 
238  void SetPointSize(float size) override;
239 
243  void SetLineWidth(float width) override;
244 
248  void SetLineType(int type) override;
249 
253  void MultiplyMatrix(vtkMatrix3x3* m) override;
254 
258  void SetMatrix(vtkMatrix3x3* m) override;
259 
263  void GetMatrix(vtkMatrix3x3* m) override;
264 
268  void PushMatrix() override;
269 
273  void PopMatrix() override;
274 
275  /*
276  * Supply an int array of length 4 with x1, y1, width, height specifying
277  * clipping region for the device in pixels.
278  */
279  void SetClipping(int* x) override;
280 
284  void EnableClipping(bool enable) override;
285 
289  void Begin(vtkViewport* viewport) override;
290 
294  void End() override;
295 
303  void BufferIdModeBegin(vtkAbstractContextBufferId* bufferId) override;
304 
312  void BufferIdModeEnd() override;
313 
319  bool SetStringRendererToFreeType();
320 
325  bool SetStringRendererToQt();
326 
330  bool HasGLSL();
331 
333 
336  vtkGetObjectMacro(RenderWindow, vtkOpenGLRenderWindow);
338 
344  virtual void ReleaseGraphicsResources(vtkWindow* window);
345 
347 
350  vtkMatrix4x4* GetProjectionMatrix();
351  vtkMatrix4x4* GetModelMatrix();
353 
354 protected:
356  ~vtkOpenGLContextDevice2D() override;
357 
365  int GetNumberOfArcIterations(float rX, float rY, float startAngle, float stopAngle);
366 
371 
375  bool InRender;
376 
378 
381  class Private;
382  Private* Storage;
383 
387 
392 
393  vtkOpenGLHelper* LinesCBO; // vertex + color
394  void ReadyLinesCBOProgram();
396  void ReadyLinesBOProgram();
397  vtkOpenGLHelper* VCBO; // vertex + color
398  void ReadyVCBOProgram();
399  vtkOpenGLHelper* VBO; // vertex
400  void ReadyVBOProgram();
401  vtkOpenGLHelper* VTBO; // vertex + tcoord
402  void ReadyVTBOProgram();
403  vtkOpenGLHelper* SCBO; // sprite + color
404  void ReadySCBOProgram();
405  vtkOpenGLHelper* SBO; // sprite
406  void ReadySBOProgram();
407 
408  void SetMatrices(vtkShaderProgram* prog);
409  void BuildVBO(
410  vtkOpenGLHelper* cbo, float* v, int nv, unsigned char* coolors, int nc, float* tcoords);
411  void CoreDrawTriangles(
412  std::vector<float>& tverts, unsigned char* colors = nullptr, int numComp = 0);
413  // used for stipples
414  unsigned short LinePattern;
415 
417 
421  void DrawMarkersGL2PS(
422  int shape, bool highlight, float* points, int n, unsigned char* colors, int nc_comps);
423  void DrawCrossMarkersGL2PS(
424  bool highlight, float* points, int n, unsigned char* colors, int nc_comps);
425  void DrawPlusMarkersGL2PS(
426  bool highlight, float* points, int n, unsigned char* colors, int nc_comps);
427  void DrawSquareMarkersGL2PS(
428  bool highlight, float* points, int n, unsigned char* colors, int nc_comps);
429  void DrawCircleMarkersGL2PS(
430  bool highlight, float* points, int n, unsigned char* colors, int nc_comps);
431  void DrawDiamondMarkersGL2PS(
432  bool highlight, float* points, int n, unsigned char* colors, int nc_comps);
434 
436 
439  void DrawImageGL2PS(float p[2], vtkImageData* image);
440  void DrawImageGL2PS(float p[2], float scale, vtkImageData* image);
441  void DrawImageGL2PS(const vtkRectf& rect, vtkImageData* image);
443 
445 
448  void DrawCircleGL2PS(float x, float y, float rX, float rY);
449  void DrawWedgeGL2PS(float x, float y, float outRx, float outRy, float inRx, float inRy);
451 
455  void AddEllipseToPath(vtkPath* path, float x, float y, float rx, float ry, bool reverse);
456 
460  void TransformPath(vtkPath* path) const;
461 
465  void TransformPoint(float& x, float& y) const;
466 
470  void TransformSize(float& dx, float& dy) const;
471 
472 private:
474  void operator=(const vtkOpenGLContextDevice2D&) = delete;
475 
482  vtkImageData* GetMarker(int shape, int size, bool highlight);
483 
484  class vtkMarkerCacheObject
485  {
486  public:
487  vtkTypeUInt64 Key;
488  vtkImageData* Value;
489  bool operator==(vtkTypeUInt64 key) { return this->Key == key; }
490  };
491 
492  void ComputeStringBoundsInternal(const vtkUnicodeString& string, float bounds[4]);
493 
494  vtkTransform* ProjectionMatrix;
495  vtkTransform* ModelMatrix;
496 
497  std::list<vtkMarkerCacheObject> MarkerCache;
498  int MaximumMarkerCacheSize;
499 
504  vtkImageData* GenerateMarker(int shape, int size, bool highlight);
505 };
506 
507 #endif // vtkOpenGLContextDevice2D_h
vtkOpenGLContextDevice2D::Private
Definition: vtkOpenGLContextDevice2DPrivate.h:269
vtkContextDevice2D::DrawMarkers
virtual void DrawMarkers(int shape, bool highlight, float *points, int n, unsigned char *colors=nullptr, int nc_comps=0)
Draw a series of markers centered at the points supplied.
vtkContextDevice2D::ComputeStringBounds
virtual void ComputeStringBounds(const vtkStdString &string, float bounds[4])=0
Compute the bounds of the supplied string.
vtkContextDevice2D::DrawQuadStrip
virtual void DrawQuadStrip(float *, int)
Draw a quad using the specified number of points.
Definition: vtkContextDevice2D.h:115
vtkOpenGLContextDevice2D::SBO
vtkOpenGLHelper * SBO
Definition: vtkOpenGLContextDevice2D.h:405
vtkContextDevice2D::New
static vtkContextDevice2D * New()
vtkContextDevice2D::PopMatrix
virtual void PopMatrix()=0
Pop the current matrix off of the stack.
vtkContextDevice2D::BufferIdModeBegin
virtual void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId)
Start BufferId creation Mode.
vtkX3D::scale
Definition: vtkX3D.h:235
vtkContextDevice2D::DrawPolyData
virtual void DrawPolyData(float p[2], float scale, vtkPolyData *polyData, vtkUnsignedCharArray *colors, int scalarMode)
Draw the supplied PolyData at the given x, y (p[0], p[1]) (bottom corner), scaled by scale (1....
vtkOpenGLContextDevice2D::VTBO
vtkOpenGLHelper * VTBO
Definition: vtkOpenGLContextDevice2D.h:401
vtkOpenGLContextDevice2D::PolyDataImpl
CellArrayHelper * PolyDataImpl
Definition: vtkOpenGLContextDevice2D.h:384
vtkOpenGLContextDevice2D::LinePattern
unsigned short LinePattern
Definition: vtkOpenGLContextDevice2D.h:414
vtkContextDevice2D::End
virtual void End()
End drawing, clean up the view.
Definition: vtkContextDevice2D.h:367
vtkX3D::type
Definition: vtkX3D.h:522
vtkContextDevice2D::DrawQuad
virtual void DrawQuad(float *, int)
Draw a quad using the specified number of points.
Definition: vtkContextDevice2D.h:110
vtkContextDevice2D::MultiplyMatrix
virtual void MultiplyMatrix(vtkMatrix3x3 *m)=0
Multiply the current model view matrix by the supplied one.
vtkOpenGLContextDevice2D::LinesCBO
vtkOpenGLHelper * LinesCBO
Definition: vtkOpenGLContextDevice2D.h:393
vtkX3D::key
Definition: vtkX3D.h:263
vtkX3D::image
Definition: vtkX3D.h:380
vtkContextDevice2D::SetMatrix
virtual void SetMatrix(vtkMatrix3x3 *m)=0
Set the model view matrix for the display.
vtkPath
concrete dataset representing a path defined by Bezier curves.
Definition: vtkPath.h:32
vtkContextDevice2D::DrawString
virtual void DrawString(float *point, const vtkStdString &string)=0
Draw some text to the screen.
vtkUnsignedCharArray
dynamic, self-adjusting array of unsigned char
Definition: vtkUnsignedCharArray.h:35
vtkContextDevice2D::SetColor4
virtual void SetColor4(unsigned char color[4])=0
Set the color for the device using unsigned char of length 4, RGBA.
vtkStringToImage
base class for classes that render supplied text to an image.
Definition: vtkStringToImage.h:37
vtkTransform
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:54
vtkContextDevice2D::SetClipping
virtual void SetClipping(int *x)=0
Supply an int array of length 4 with x1, y1, width, height specifying clipping region for the device ...
vtkContextDevice2D::DrawColoredPolygon
virtual void DrawColoredPolygon(float *points, int numPoints, unsigned char *colors=nullptr, int nc_comps=0)
Draw a polygon using the specified number of points.
vtkContextDevice2D::PushMatrix
virtual void PushMatrix()=0
Push the current matrix onto the stack.
vtkMatrix3x3
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:33
vtkContextDevice2D::ComputeJustifiedStringBounds
virtual void ComputeJustifiedStringBounds(const char *string, float bounds[4])=0
Compute the bounds of the supplied string while taking into account the justification of the currentl...
vtkOpenGLContextDevice2D::VCBO
vtkOpenGLHelper * VCBO
Definition: vtkOpenGLContextDevice2D.h:397
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:34
vtkContextDevice2D::DrawPolygon
virtual void DrawPolygon(float *p, int n)
Draw a polygon using the specified number of points.
Definition: vtkContextDevice2D.h:121
vtkContextDevice2D::DrawImage
virtual void DrawImage(float p[2], float scale, vtkImageData *image)=0
Draw the supplied image at the given x, y (p[0], p[1]) (bottom corner), scaled by scale (1....
vtkAbstractContextBufferId
2D array of ids, used for picking.
Definition: vtkAbstractContextBufferId.h:46
vtkX3D::color
Definition: vtkX3D.h:227
vtkX3D::points
Definition: vtkX3D.h:452
vtkX3D::point
Definition: vtkX3D.h:242
vtkContextDevice2D::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkContextDevice2D::DrawEllipticArc
virtual void DrawEllipticArc(float x, float y, float rX, float rY, float startAngle, float stopAngle)=0
Draw an elliptic arc with center at x,y with radii rX and rY between angles startAngle and stopAngle ...
vtkContextDevice2D::SetLineType
virtual void SetLineType(int type)=0
Set the line type type (using anonymous enum in vtkPen).
vtkContextDevice2D::SetPointSize
virtual void SetPointSize(float size)=0
Set the point size for glyphs/sprites.
vtkOpenGLContextDevice2D
Class for drawing 2D primitives using OpenGL 1.1+.
Definition: vtkOpenGLContextDevice2D.h:51
vtkOpenGLContextDevice2D::SCBO
vtkOpenGLHelper * SCBO
Definition: vtkOpenGLContextDevice2D.h:403
vtkOpenGLContextDevice2D::CellArrayHelper
Definition: vtkOpenGLContextDevice2DPrivate.h:526
vtkShaderProgram
The ShaderProgram uses one or more Shader objects.
Definition: vtkShaderProgram.h:44
vtkOpenGLHelper
Definition: vtkOpenGLHelper.h:30
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:41
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:35
vtkUnicodeString
String class that stores Unicode text.
Definition: vtkUnicodeString.h:69
vtkX3D::size
Definition: vtkX3D.h:259
vtkContextDevice2D::DrawPointSprites
virtual void DrawPointSprites(vtkImageData *sprite, float *points, int n, unsigned char *colors=nullptr, int nc_comps=0)=0
Draw a series of point sprites, images centred at the points supplied.
vtkX3D::startAngle
Definition: vtkX3D.h:492
operator==
VTKCOMMONCORE_EXPORT bool operator==(const vtkUnicodeString &lhs, const vtkUnicodeString &rhs)
vtkContextDevice2D::BufferIdModeEnd
virtual void BufferIdModeEnd()
Finalize BufferId creation Mode.
vtkContextDevice2D::DrawPoly
virtual void DrawPoly(float *points, int n, unsigned char *colors=nullptr, int nc_comps=0)=0
Draw a poly line using the points - fastest code path due to memory layout of the coordinates.
vtkContextDevice2D::GetMatrix
virtual void GetMatrix(vtkMatrix3x3 *m)=0
Set the model view matrix for the display.
vtkViewport
abstract specification for Viewports
Definition: vtkViewport.h:44
vtkContextDevice2D
Abstract class for drawing 2D primitives.
Definition: vtkContextDevice2D.h:50
vtkOpenGLContextDevice2D::Renderer
vtkRenderer * Renderer
We need to store a pointer to the renderer for the text rendering.
Definition: vtkOpenGLContextDevice2D.h:370
vtkContextDevice2D::DrawLines
virtual void DrawLines(float *f, int n, unsigned char *colors=nullptr, int nc_comps=0)=0
Draw lines using the points - memory layout is as follows: l1p1,l1p2,l2p1,l2p2...
vtkOpenGLContextDevice2D::Storage
Private * Storage
Definition: vtkOpenGLContextDevice2D.h:381
vtkOpenGLContextDevice2D::LinesBO
vtkOpenGLHelper * LinesBO
Definition: vtkOpenGLContextDevice2D.h:395
vtkContextDevice2D::SetTexture
virtual void SetTexture(vtkImageData *image, int properties)=0
Set the texture for the device, it is used to fill the polygons.
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:58
vtkContextDevice2D::DrawMathTextString
virtual void DrawMathTextString(float *point, const vtkStdString &string)=0
Draw text using MathText markup for mathematical equations.
vtkOpenGLContextDevice2D::VBO
vtkOpenGLHelper * VBO
Definition: vtkOpenGLContextDevice2D.h:399
vtkPolyData
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:84
vtkContextDevice2D::Begin
virtual void Begin(vtkViewport *)
Begin drawing, pass in the viewport to set up the view.
Definition: vtkContextDevice2D.h:362
vtkOpenGLRenderWindow
OpenGL rendering window.
Definition: vtkOpenGLRenderWindow.h:51
vtkOpenGLContextDevice2D::InRender
bool InRender
Is the device currently rendering? Prevent multiple End() calls.
Definition: vtkOpenGLContextDevice2D.h:375
vtkStdString
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:34
vtkContextDevice2D::DrawEllipseWedge
virtual void DrawEllipseWedge(float x, float y, float outRx, float outRy, float inRx, float inRy, float startAngle, float stopAngle)=0
Draw an elliptic wedge with center at x, y, outer radii outRx, outRy, inner radii inRx,...
vtkOpenGLContextDevice2D::RenderWindow
vtkOpenGLRenderWindow * RenderWindow
The OpenGL render window being used by the device.
Definition: vtkOpenGLContextDevice2D.h:391
vtkContextDevice2D::SetLineWidth
virtual void SetLineWidth(float width)=0
Set the line width.
vtkRectf
Definition: vtkRect.h:326
vtkContextDevice2D::EnableClipping
virtual void EnableClipping(bool enable)=0
Enable or disable the clipping of the scene.
vtkContextDevice2D::DrawPoints
virtual void DrawPoints(float *points, int n, unsigned char *colors=nullptr, int nc_comps=0)=0
Draw a series of points - fastest code path due to memory layout of the coordinates.
vtkContextDevice2D.h