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 
33 #ifndef vtkOpenGLContextDevice2D_h
34 #define vtkOpenGLContextDevice2D_h
35 
36 #include "vtkRenderingContextOpenGL2Module.h" // For export macro
37 #include "vtkContextDevice2D.h"
38 
39 #include <vector> // STL Header
40 #include <list> // for std::list
41 
42 class vtkMatrix4x4;
43 class vtkOpenGLExtensionManager;
44 class vtkOpenGLHelper;
46 class vtkPath;
47 class vtkRenderer;
48 class vtkShaderProgram;
49 class vtkStringToImage;
50 class vtkTransform;
51 class vtkViewport;
52 class vtkWindow;
53 
54 class VTKRENDERINGCONTEXTOPENGL2_EXPORT vtkOpenGLContextDevice2D : public vtkContextDevice2D
55 {
56 public:
58  void PrintSelf(ostream &os, vtkIndent indent) override;
59 
63  static vtkOpenGLContextDevice2D *New();
64 
70  void DrawPoly(float *f, int n, unsigned char *colors = nullptr,
71  int nc_comps = 0) override;
72 
79  void DrawLines(float *f, int n, unsigned char *colors = nullptr,
80  int nc_comps = 0) override;
81 
87  void DrawPoints(float *points, int n, unsigned char* colors = nullptr,
88  int nc_comps = 0) override;
89 
96  void DrawPointSprites(vtkImageData *sprite, float *points, int n,
97  unsigned char* colors = nullptr, int nc_comps = 0) override;
98 
110  void DrawMarkers(int shape, bool highlight, float *points, int n,
111  unsigned char *colors = nullptr, int nc_comps = 0) override;
112 
114 
119  vtkSetMacro(MaximumMarkerCacheSize, int)
120  vtkGetMacro(MaximumMarkerCacheSize, int)
122 
126  void DrawQuad(float *points, int n) override;
127 
131  void DrawQuadStrip(float *points, int n) override;
132 
136  void DrawPolygon(float *, int) override;
137  void DrawColoredPolygon(float *points, int numPoints,
138  unsigned char *colors = nullptr,
139  int nc_comps = 0) override;
140 
152  void DrawEllipseWedge(float x, float y, float outRx, float outRy,
153  float inRx, float inRy, float startAngle,
154  float stopAngle) override;
155 
162  void DrawEllipticArc(float x, float y, float rX, float rY,
163  float startAngle, float stopAngle) override;
164 
165 
169  void DrawString(float *point, const vtkStdString &string) override;
170 
179  void ComputeStringBounds(const vtkStdString &string,
180  float bounds[4]) override;
181 
185  void DrawString(float *point, const vtkUnicodeString &string) override;
186 
195  void ComputeStringBounds(const vtkUnicodeString &string,
196  float bounds[4]) override;
197 
203  void ComputeJustifiedStringBounds(const char* string, float bounds[4]) override;
204 
209  void DrawMathTextString(float point[2], const vtkStdString &string) override;
210 
215  void DrawImage(float p[2], float scale, vtkImageData *image) override;
216 
222  void DrawImage(const vtkRectf& pos, vtkImageData *image) override;
223 
228  void DrawPolyData(float p[2], float scale, vtkPolyData* polyData,
229  vtkUnsignedCharArray* colors, int scalarMode) override;
230 
234  void SetColor4(unsigned char color[4]) override;
235 
239  virtual void SetColor(unsigned char color[3]);
240 
244  void SetTexture(vtkImageData* image, int properties = 0) override;
245 
249  void SetPointSize(float size) override;
250 
254  void SetLineWidth(float width) override;
255 
259  void SetLineType(int type) override;
260 
264  void MultiplyMatrix(vtkMatrix3x3 *m) override;
265 
269  void SetMatrix(vtkMatrix3x3 *m) override;
270 
274  void GetMatrix(vtkMatrix3x3 *m) override;
275 
279  void PushMatrix() override;
280 
284  void PopMatrix() override;
285 
286  /*
287  * Supply an int array of length 4 with x1, y1, width, height specifying
288  * clipping region for the device in pixels.
289  */
290  void SetClipping(int *x) override;
291 
295  void EnableClipping(bool enable) override;
296 
300  void Begin(vtkViewport* viewport) override;
301 
305  void End() override;
306 
314  void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId) override;
315 
323  void BufferIdModeEnd() override;
324 
330  bool SetStringRendererToFreeType();
331 
336  bool SetStringRendererToQt();
337 
341  bool HasGLSL();
342 
344 
347  vtkGetObjectMacro(RenderWindow, vtkOpenGLRenderWindow);
349 
355  virtual void ReleaseGraphicsResources(vtkWindow *window);
356 
358 
361  vtkMatrix4x4 *GetProjectionMatrix();
362  vtkMatrix4x4 *GetModelMatrix();
364 
365 protected:
367  ~vtkOpenGLContextDevice2D() override;
368 
376  int GetNumberOfArcIterations(float rX,
377  float rY,
378  float startAngle,
379  float stopAngle);
380 
385 
389  bool InRender;
390 
392 
395  class Private;
396  Private *Storage;
397 
401 
406 
407  vtkOpenGLHelper *LinesCBO; // vertex + color
408  void ReadyLinesCBOProgram();
410  void ReadyLinesBOProgram();
411  vtkOpenGLHelper *VCBO; // vertex + color
412  void ReadyVCBOProgram();
413  vtkOpenGLHelper *VBO; // vertex
414  void ReadyVBOProgram();
415  vtkOpenGLHelper *VTBO; // vertex + tcoord
416  void ReadyVTBOProgram();
417  vtkOpenGLHelper *SCBO; // sprite + color
418  void ReadySCBOProgram();
419  vtkOpenGLHelper *SBO; // sprite
420  void ReadySBOProgram();
421 
422  void SetMatrices(vtkShaderProgram *prog);
423  void BuildVBO(vtkOpenGLHelper *cbo,
424  float *v, int nv,
425  unsigned char *coolors, int nc,
426  float *tcoords);
427  void CoreDrawTriangles(std::vector<float> &tverts, unsigned char* colors = nullptr,
428  int numComp = 0);
429  // used for stipples
430  unsigned short LinePattern;
431 
433 
437  void DrawMarkersGL2PS(int shape, bool highlight, float *points, int n,
438  unsigned char *colors, int nc_comps);
439  void DrawCrossMarkersGL2PS(bool highlight, float *points, int n,
440  unsigned char *colors, int nc_comps);
441  void DrawPlusMarkersGL2PS(bool highlight, float *points, int n,
442  unsigned char *colors, int nc_comps);
443  void DrawSquareMarkersGL2PS(bool highlight, float *points, int n,
444  unsigned char *colors, int nc_comps);
445  void DrawCircleMarkersGL2PS(bool highlight, float *points, int n,
446  unsigned char *colors, int nc_comps);
447  void DrawDiamondMarkersGL2PS(bool highlight, float *points, int n,
448  unsigned char *colors, int nc_comps);
450 
452 
455  void DrawImageGL2PS(float p[2], vtkImageData *image);
456  void DrawImageGL2PS(float p[2], float scale, vtkImageData *image);
457  void DrawImageGL2PS(const vtkRectf &rect, vtkImageData *image);
459 
461 
464  void DrawCircleGL2PS(float x, float y, float rX, float rY);
465  void DrawWedgeGL2PS(float x, float y, float outRx, float outRy,
466  float inRx, float inRy);
468 
472  void AddEllipseToPath(vtkPath *path, float x, float y, float rx, float ry,
473  bool reverse);
474 
478  void TransformPath(vtkPath *path) const;
479 
483  void TransformPoint(float &x, float &y) const;
484 
488  void TransformSize(float &dx, float &dy) const;
489 
490 private:
492  void operator=(const vtkOpenGLContextDevice2D &) = delete;
493 
500  vtkImageData *GetMarker(int shape, int size, bool highlight);
501 
502  class vtkMarkerCacheObject
503  {
504  public:
505  vtkTypeUInt64 Key;
506  vtkImageData *Value;
507  bool operator==(vtkTypeUInt64 key)
508  {
509  return this->Key == key;
510  }
511  };
512 
513  void ComputeStringBoundsInternal(const vtkUnicodeString &string,
514  float bounds[4]);
515 
516  vtkTransform *ProjectionMatrix;
517  vtkTransform *ModelMatrix;
518 
519  std::list<vtkMarkerCacheObject> MarkerCache;
520  int MaximumMarkerCacheSize;
521 
526  vtkImageData * GenerateMarker(int shape, int size, bool highlight);
527 
528 };
529 
530 #endif //vtkOpenGLContextDevice2D_h
OpenGL rendering window.
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:40
virtual void SetMatrix(vtkMatrix3x3 *m)=0
Set the model view matrix for the display.
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:41
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.
virtual void SetClipping(int *x)=0
Supply an int array of length 4 with x1, y1, width, height specifying clipping region for the device ...
virtual void BufferIdModeEnd()
Finalize BufferId creation Mode.
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...
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...
concrete dataset representing a path defined by Bezier curves.
Definition: vtkPath.h:35
abstract specification for Viewports
Definition: vtkViewport.h:47
virtual void DrawPolygon(float *p, int n)
Draw a polygon using the specified number of points.
Class for drawing 2D primitives using OpenGL 1.1+.
virtual void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId)
Start BufferId creation Mode.
abstract specification for renderers
Definition: vtkRenderer.h:63
static vtkContextDevice2D * New()
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:60
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:85
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...
virtual void Begin(vtkViewport *)
Begin drawing, pass in the viewport to set up the view.
base class for classes that render supplied text to an image.
virtual void SetColor4(unsigned char color[4])=0
Set the color for the device using unsigned char of length 4, RGBA.
bool InRender
Is the device currently rendering? Prevent multiple End() calls.
window superclass for vtkRenderWindow
Definition: vtkWindow.h:37
virtual void EnableClipping(bool enable)=0
Enable or disable the clipping of the scene.
virtual void SetLineWidth(float width)=0
Set the line width.
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.
vtkOpenGLRenderWindow * RenderWindow
The OpenGL render window being used by the device.
a simple class to control print indentation
Definition: vtkIndent.h:39
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.
topologically and geometrically regular array of data
Definition: vtkImageData.h:45
virtual void DrawQuadStrip(float *, int)
Draw a quad using the specified number of points.
Abstract class for drawing 2D primitives.
virtual void PopMatrix()=0
Pop the current matrix off of the stack.
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... ...
virtual void SetTexture(vtkImageData *image, int properties)=0
Set the texture for the device, it is used to fill the polygons.
virtual void DrawMathTextString(float *point, const vtkStdString &string)=0
Draw text using MathText markup for mathematical equations.
virtual void SetPointSize(float size)=0
Set the point size for glyphs/sprites.
dynamic, self-adjusting array of unsigned char
virtual void DrawQuad(float *, int)
Draw a quad using the specified number of points.
2D array of ids, used for picking.
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 ...
virtual void MultiplyMatrix(vtkMatrix3x3 *m)=0
Multiply the current model view matrix by the supplied one.
virtual void DrawString(float *point, const vtkStdString &string)=0
Draw some text to the screen.
virtual void End()
End drawing, clean up the view.
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...
virtual void DrawColoredPolygon(float *points, int numPoints, unsigned char *colors=nullptr, int nc_comps=0)
Draw a polygon using the specified number of points.
vtkRenderer * Renderer
We need to store a pointer to the renderer for the text rendering.
virtual void GetMatrix(vtkMatrix3x3 *m)=0
Set the model view matrix for the display.
virtual void ComputeStringBounds(const vtkStdString &string, float bounds[4])=0
Compute the bounds of the supplied string.
VTKCOMMONCORE_EXPORT bool operator==(const vtkUnicodeString &lhs, const vtkUnicodeString &rhs)
virtual void PushMatrix()=0
Push the current matrix onto the stack.
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...
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:36
virtual void SetLineType(int type)=0
Set the line type type (using anonymous enum in vtkPen).
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
String class that stores Unicode text.
The ShaderProgram uses one or more Shader objects.