VTK  9.0.1
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
OpenGL rendering window.
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:34
virtual void SetMatrix(vtkMatrix3x3 *m)=0
Set the model view matrix for the display.
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:35
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:32
abstract specification for Viewports
Definition: vtkViewport.h:44
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:67
static vtkContextDevice2D * New()
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:54
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:84
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:33
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:41
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:33
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.