VTK  9.0.1
vtkOpenGLPolyDataMapper.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4 
5  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
6  All rights reserved.
7  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
8 
9  This software is distributed WITHOUT ANY WARRANTY; without even
10  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
11  PURPOSE. See the above copyright notice for more information.
12 
13 =========================================================================*/
27 #ifndef vtkOpenGLPolyDataMapper_h
28 #define vtkOpenGLPolyDataMapper_h
29 
30 #include "vtkNew.h" // For vtkNew
31 #include "vtkNew.h" // for ivars
32 #include "vtkOpenGLHelper.h" // used for ivars
33 #include "vtkPolyDataMapper.h"
34 #include "vtkRenderingOpenGL2Module.h" // For export macro
35 #include "vtkShader.h" // for methods
36 #include "vtkStateStorage.h" // used for ivars
37 
38 #include <map> //for methods
39 #include <vector> //for ivars
40 
41 class vtkCellArray;
43 class vtkMatrix4x4;
44 class vtkMatrix3x3;
47 class vtkOpenGLTexture;
51 class vtkPoints;
52 class vtkTexture;
53 class vtkTextureObject;
54 class vtkTransform;
56 
57 class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLPolyDataMapper : public vtkPolyDataMapper
58 {
59 public:
60  static vtkOpenGLPolyDataMapper* New();
62  void PrintSelf(ostream& os, vtkIndent indent) override;
63 
67  void RenderPiece(vtkRenderer* ren, vtkActor* act) override;
68 
70 
73  virtual void RenderPieceStart(vtkRenderer* ren, vtkActor* act);
74  virtual void RenderPieceDraw(vtkRenderer* ren, vtkActor* act);
75  virtual void RenderPieceFinish(vtkRenderer* ren, vtkActor* act);
77 
83  void ReleaseGraphicsResources(vtkWindow*) override;
84 
85  vtkGetMacro(PopulateSelectionSettings, int);
86  void SetPopulateSelectionSettings(int v) { this->PopulateSelectionSettings = v; }
87 
94  bool GetSupportsSelection() override { return true; }
95 
96  // used by RenderPiece and functions it calls to reduce
97  // calls to get the input and allow for rendering of
98  // other polydata (not the input)
100 
102 
108  vtkSetStringMacro(PointIdArrayName);
109  vtkGetStringMacro(PointIdArrayName);
110  vtkSetStringMacro(CellIdArrayName);
111  vtkGetStringMacro(CellIdArrayName);
113 
115 
120  vtkSetStringMacro(ProcessIdArrayName);
121  vtkGetStringMacro(ProcessIdArrayName);
123 
125 
134  vtkSetStringMacro(CompositeIdArrayName);
135  vtkGetStringMacro(CompositeIdArrayName);
137 
138 #ifndef VTK_LEGACY_REMOVE
139 
140 
150  VTK_LEGACY(void AddShaderReplacement(vtkShader::Type shaderType, // vertex, fragment, etc
151  const std::string& originalValue,
152  bool replaceFirst, // do this replacement before the default
153  const std::string& replacementValue, bool replaceAll);)
154  VTK_LEGACY(void ClearShaderReplacement(vtkShader::Type shaderType, // vertex, fragment, etc
155  const std::string& originalValue, bool replaceFirst);)
156  VTK_LEGACY(void ClearAllShaderReplacements(vtkShader::Type shaderType);)
157  VTK_LEGACY(void ClearAllShaderReplacements();)
159 
161 
169  VTK_LEGACY(virtual void SetVertexShaderCode(const char* code);)
170  VTK_LEGACY(virtual char* GetVertexShaderCode();)
171  VTK_LEGACY(virtual void SetFragmentShaderCode(const char* code);)
172  VTK_LEGACY(virtual char* GetFragmentShaderCode();)
173  VTK_LEGACY(virtual void SetGeometryShaderCode(const char* code);)
174  VTK_LEGACY(virtual char* GetGeometryShaderCode();)
176 #endif
177 
181  void ShallowCopy(vtkAbstractMapper* m) override;
182 
184  vtkGetObjectMacro(VBOs, vtkOpenGLVertexBufferObjectGroup);
185 
189  void SetVBOShiftScaleMethod(int m);
190 
192  {
193  PrimitiveStart = 0,
194  PrimitivePoints = 0,
201  PrimitiveEnd
202  };
203 
215  void MapDataArrayToVertexAttribute(const char* vertexAttributeName, const char* dataArrayName,
216  int fieldAssociation, int componentno = -1) override;
217 
218  // This method will Map the specified data array for use as
219  // a texture coordinate for texture tname. The actual
220  // attribute will be named tname_coord so as to not
221  // conflict with the texture sampler definition which will
222  // be tname.
223  void MapDataArrayToMultiTextureAttribute(const char* tname, const char* dataArrayName,
224  int fieldAssociation, int componentno = -1) override;
225 
229  void RemoveVertexAttributeMapping(const char* vertexAttributeName) override;
230 
234  void RemoveAllVertexAttributeMappings() override;
235 
241  vtkHardwareSelector* sel, std::vector<unsigned int>& pixeloffsets, vtkProp* prop) override;
242 
243 protected:
245  ~vtkOpenGLPolyDataMapper() override;
246 
248 
249  void MapDataArray(const char* vertexAttributeName, const char* dataArrayName,
250  const char* texturename, int fieldAssociation, int componentno);
251 
252  // what coordinate should be used for this texture
253  std::string GetTextureCoordinateName(const char* tname);
254 
258  void GetCoincidentParameters(vtkRenderer* ren, vtkActor* actor, float& factor, float& offset);
259 
265  void ComputeBounds() override;
266 
271  virtual void UpdateShaders(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
272 
276  virtual bool GetNeedToRebuildShaders(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
277 
281  virtual void BuildShaders(
282  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
283 
287  virtual void GetShaderTemplate(
288  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
289 
293  virtual void ReplaceShaderValues(
294  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
295 
297 
301  virtual void ReplaceShaderRenderPass(
302  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act, bool prePass);
303  virtual void ReplaceShaderCustomUniforms(
304  std::map<vtkShader::Type, vtkShader*> shaders, vtkActor* act);
305  virtual void ReplaceShaderColor(
306  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
307  virtual void ReplaceShaderLight(
308  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
309  virtual void ReplaceShaderTCoord(
310  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
311  virtual void ReplaceShaderPicking(
312  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
313  virtual void ReplaceShaderPrimID(
314  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
315  virtual void ReplaceShaderNormal(
316  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
317  virtual void ReplaceShaderClip(
318  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
319  virtual void ReplaceShaderPositionVC(
320  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
321  virtual void ReplaceShaderCoincidentOffset(
322  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
323  virtual void ReplaceShaderDepth(
324  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
326 
330  virtual void SetCustomUniforms(vtkOpenGLHelper& cellBO, vtkActor* actor);
331 
335  virtual void SetMapperShaderParameters(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
336 
340  virtual void SetLightingShaderParameters(
341  vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
342 
346  virtual void SetCameraShaderParameters(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
347 
351  virtual void SetPropertyShaderParameters(
352  vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
353 
357  virtual void UpdateBufferObjects(vtkRenderer* ren, vtkActor* act);
358 
362  virtual bool GetNeedToRebuildBufferObjects(vtkRenderer* ren, vtkActor* act);
363 
367  virtual void BuildBufferObjects(vtkRenderer* ren, vtkActor* act);
368 
372  virtual void BuildIBO(vtkRenderer* ren, vtkActor* act, vtkPolyData* poly);
373 
374  // The VBO and its layout.
376 
377  // Structures for the various cell types we render.
378  vtkOpenGLHelper Primitives[PrimitiveEnd];
381 
382  // do we have wide lines that require special handling
383  virtual bool HaveWideLines(vtkRenderer*, vtkActor*);
384 
385  // do we have textures that require special handling
386  virtual bool HaveTextures(vtkActor* actor);
387 
388  // how many textures do we have
389  virtual unsigned int GetNumberOfTextures(vtkActor* actor);
390 
391  // populate a vector with the textures we have
392  // the order is always
393  // ColorInternalTexture
394  // Actors texture
395  // Properties textures
396  virtual std::vector<std::pair<vtkTexture*, std::string> > GetTextures(vtkActor* actor);
397 
398  // do we have textures coordinates that require special handling
399  virtual bool HaveTCoords(vtkPolyData* poly);
400 
401  // values we use to determine if we need to rebuild shaders
402  std::map<const vtkOpenGLHelper*, int> LastLightComplexity;
403  std::map<const vtkOpenGLHelper*, int> LastLightCount;
404  std::map<const vtkOpenGLHelper*, vtkTimeStamp> LightComplexityChanged;
405 
408 
409  // Caches the vtkOpenGLRenderPass::RenderPasses() information.
410  // Note: Do not dereference the pointers held by this object. There is no
411  // guarantee that they are still valid!
413 
414  // Check the renderpasses in actor's property keys to see if they've changed
415  // render stages:
416  vtkMTimeType GetRenderPassStageMTime(vtkActor* actor);
417 
419  vtkTimeStamp VBOBuildTime; // When was the OpenGL VBO updated?
420  vtkStateStorage VBOBuildState; // used for determining when to rebuild the VBO
421  vtkStateStorage IBOBuildState; // used for determining whento rebuild the IBOs
423  vtkStateStorage TempState; // can be used to avoid constant allocs/deallocs
425 
428 
433  int ShiftScaleMethod; // for points
434 
435  // if set to true, tcoords will be passed to the
436  // VBO even if the mapper knows of no texture maps
437  // normally tcoords are only added to the VBO if the
438  // mapper has identified a texture map as well.
440 
441  virtual void BuildCellTextures(
442  vtkRenderer* ren, vtkActor*, vtkCellArray* prims[4], int representation);
443 
444  void AppendCellTextures(vtkRenderer* ren, vtkActor*, vtkCellArray* prims[4], int representation,
445  std::vector<unsigned char>& colors, std::vector<float>& normals, vtkPolyData* pd,
447 
454 
455  // additional picking indirection
460 
462  {
463  public:
468  };
469  std::map<std::string, ExtraAttributeValue> ExtraAttributes;
470 
471  // Store shader properties on this class by legacy shader replacement functions
472  // This should disappear when the functions are deprecated
473 #ifndef VTK_LEGACY_REMOVE
474  vtkOpenGLShaderProperty* GetLegacyShaderProperty();
476 #endif
477 
479 
480  // are we currently drawing spheres/tubes
481  bool DrawingSpheres(vtkOpenGLHelper& cellBO, vtkActor* actor);
482  bool DrawingTubes(vtkOpenGLHelper& cellBO, vtkActor* actor);
483  bool DrawingTubesOrSpheres(vtkOpenGLHelper& cellBO, vtkActor* actor);
484 
485  // get which opengl mode to use to draw the primitive
486  int GetOpenGLMode(int representation, int primType);
487 
488  // get how big to make the points when doing point picking
489  // typically 2 for points, 4 for lines, 6 for surface
490  int GetPointPickingPrimitiveSize(int primType);
491 
492  // used to occasionally invoke timers
493  unsigned int TimerQueryCounter;
494 
495  // stores the mapping from vtk cells to gl_PrimitiveId
497 
498  // compute and set the maximum point and cell ID used in selection
499  virtual void UpdateMaximumPointCellIds(vtkRenderer* ren, vtkActor* actor);
500 
501 private:
503  void operator=(const vtkOpenGLPolyDataMapper&) = delete;
504 };
505 
506 #endif
abstract superclass for all actors, volumes and annotations
Definition: vtkProp.h:53
PolyDataMapper using OpenGL to render.
void ShallowCopy(vtkAbstractMapper *m) override
Make a shallow copy of this mapper.
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:45
vtkOpenGLBufferObject * CellScalarBuffer
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:35
std::map< const vtkOpenGLHelper *, int > LastLightComplexity
virtual void MapDataArrayToMultiTextureAttribute(const char *textureName, const char *dataArrayName, int fieldAssociation, int componentno=-1)
virtual void RemoveAllVertexAttributeMappings()
Remove all vertex attributes.
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:293
Type
Available shader types.
Definition: vtkShader.h:45
record modification and/or execution time
Definition: vtkTimeStamp.h:32
vtkNew< vtkOpenGLCellToVTKCellMap > CellCellMap
vtkTextureObject * CellScalarTexture
vtkOpenGLBufferObject * CellNormalBuffer
vtkTextureObject * CellNormalTexture
OpenGL rendering utility functions.
std::map< const vtkOpenGLHelper *, vtkTimeStamp > LightComplexityChanged
abstract specification for renderers
Definition: vtkRenderer.h:67
virtual void RenderPiece(vtkRenderer *, vtkActor *)
Implemented by sub classes.
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:54
virtual void ProcessSelectorPixelBuffers(vtkHardwareSelector *, std::vector< unsigned int > &, vtkProp *)
allows a mapper to update a selections color buffers Called from a prop which in turn is called from ...
Definition: vtkMapper.h:470
represent GPU shader properties
std::map< std::string, ExtraAttributeValue > ExtraAttributes
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:84
virtual void RemoveVertexAttributeMapping(const char *vertexAttributeName)
Remove a vertex attribute mapping.
bool GetSupportsSelection() override
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT USE THIS METHOD OUTSIDE OF THE RENDERI...
OpenGL texture map.
window superclass for vtkRenderWindow
Definition: vtkWindow.h:37
vtkOpenGLVertexBufferObjectGroup * VBOs
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkNew< vtkMatrix4x4 > VBOShiftScale
handles properties associated with a texture map
Definition: vtkTexture.h:65
vtkOpenGLRenderTimer * TimerQuery
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual void ComputeBounds()
Called in GetBounds().
abstract class specifies interface to map data
abstracts an OpenGL texture object.
virtual void MapDataArrayToVertexAttribute(const char *vertexAttributeName, const char *dataArrayName, int fieldAssociation, int componentno=-1)
Select a data array from the point/cell data and map it to a generic vertex attribute.
std::map< const vtkOpenGLHelper *, int > LastLightCount
map vtkPolyData to graphics primitives
object to represent cell connectivity
Definition: vtkCellArray.h:179
vtkGenericOpenGLResourceFreeCallback * ResourceCallback
vtkNew< vtkTransform > VBOInverseTransform
vtkSmartPointer< vtkOpenGLShaderProperty > LegacyShaderProperty
static vtkPolyDataMapper * New()
OpenGL buffer object.
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:33
manage vertex buffer objects shared within a mapper
vtkOpenGLTexture * InternalColorTexture
vtkNew< vtkInformation > LastRenderPassInfo
Asynchronously measures GPU execution time for a single event.
Class to make storing and comparing state quick and easy.
represent and manipulate 3D points
Definition: vtkPoints.h:33
void ReleaseGraphicsResources(vtkWindow *) override
Release any graphics resources that are being consumed by this mapper.
Definition: vtkMapper.h:108