VTK
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 =========================================================================*/
21 #ifndef vtkOpenGLPolyDataMapper_h
22 #define vtkOpenGLPolyDataMapper_h
23 
24 #include "vtkNew.h" // For vtkNew
25 #include "vtkRenderingOpenGL2Module.h" // For export macro
26 #include "vtkNew.h" // for ivars
27 #include "vtkPolyDataMapper.h"
28 #include "vtkShader.h" // for methods
29 #include "vtkOpenGLHelper.h" // used for ivars
30 
31 #include <vector> //for ivars
32 #include <map> //for methods
33 
34 class vtkCellArray;
36 class vtkMatrix4x4;
37 class vtkMatrix3x3;
39 class vtkOpenGLTexture;
43 class vtkPoints;
44 class vtkTexture;
45 class vtkTextureObject;
46 class vtkTransform;
47 
48 
49 class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLPolyDataMapper : public vtkPolyDataMapper
50 {
51 public:
52  static vtkOpenGLPolyDataMapper* New();
54  void PrintSelf(ostream& os, vtkIndent indent) override;
55 
59  void RenderPiece(vtkRenderer *ren, vtkActor *act) override;
60 
62 
65  virtual void RenderPieceStart(vtkRenderer *ren, vtkActor *act);
66  virtual void RenderPieceDraw(vtkRenderer *ren, vtkActor *act);
67  virtual void RenderPieceFinish(vtkRenderer *ren, vtkActor *act);
69 
75  void ReleaseGraphicsResources(vtkWindow *) override;
76 
77  vtkGetMacro(PopulateSelectionSettings,int);
78  void SetPopulateSelectionSettings(int v) { this->PopulateSelectionSettings = v; };
79 
86  bool GetSupportsSelection() override { return true; }
87 
98  bool GetIsOpaque() override;
99 
100  // used by RenderPiece and functions it calls to reduce
101  // calls to get the input and allow for rendering of
102  // other polydata (not the input)
104 
106 
112  vtkSetStringMacro(PointIdArrayName);
113  vtkGetStringMacro(PointIdArrayName);
114  vtkSetStringMacro(CellIdArrayName);
115  vtkGetStringMacro(CellIdArrayName);
117 
119 
124  vtkSetStringMacro(ProcessIdArrayName);
125  vtkGetStringMacro(ProcessIdArrayName);
127 
129 
138  vtkSetStringMacro(CompositeIdArrayName);
139  vtkGetStringMacro(CompositeIdArrayName);
141 
142 
144 
151  void AddShaderReplacement(
152  vtkShader::Type shaderType, // vertex, fragment, etc
153  const std::string& originalValue,
154  bool replaceFirst, // do this replacement before the default
155  const std::string& replacementValue,
156  bool replaceAll);
157  void ClearShaderReplacement(
158  vtkShader::Type shaderType, // vertex, fragment, etc
159  const std::string& originalValue,
160  bool replaceFirst);
161  void ClearAllShaderReplacements(vtkShader::Type shaderType);
162  void ClearAllShaderReplacements();
164 
166 
172  vtkSetStringMacro(VertexShaderCode);
173  vtkGetStringMacro(VertexShaderCode);
174  vtkSetStringMacro(FragmentShaderCode);
175  vtkGetStringMacro(FragmentShaderCode);
176  vtkSetStringMacro(GeometryShaderCode);
177  vtkGetStringMacro(GeometryShaderCode);
179 
180  // the following is all extra stuff to work around the
181  // fact that gl_PrimitiveID does not work correctly on
182  // Apple Macs with AMD graphics hardware (before macOS 10.11).
183  // See <rdar://20747550>.
184  static vtkPolyData *HandleAppleBug(
185  vtkPolyData *poly,
186  std::vector<float> &buffData);
187 
192 
194 
198  {
199  this->HaveAppleBugForce = 1;
200  this->Modified();
201  }
203  {
204  this->HaveAppleBugForce = 2;
205  this->Modified();
206  }
208 
212  bool GetHaveAppleBug() { return this->HaveAppleBug; }
213 
215  vtkGetObjectMacro(VBOs, vtkOpenGLVertexBufferObjectGroup);
216 
220  void SetVBOShiftScaleMethod(int m);
221 
223  PrimitiveStart = 0,
224  PrimitivePoints = 0,
231  PrimitiveEnd
232  };
233 
234  void UpdateCellMaps(
235  bool HaveAppleBug,
236  vtkPolyData *poly,
237  vtkCellArray **prims, int representation,
238  vtkPoints *points);
239 
243  static void MakeCellCellMap(
244  std::vector<vtkIdType> &cellCellMap,
245  bool HaveAppleBug,
246  vtkPolyData *poly,
247  vtkCellArray **prims, int representation,
248  vtkPoints *points);
249 
262  const char* vertexAttributeName,
263  const char* dataArrayName,
264  int fieldAssociation,
265  int componentno = -1) override;
266 
267  // This method will Map the specified data array for use as
268  // a texture coordinate for texture tname. The actual
269  // attribute will be named tname_coord so as to not
270  // conflict with the texture sampler definition which will
271  // be tname.
273  const char *tname,
274  const char* dataArrayName, int fieldAssociation, int componentno = -1) override;
275 
279  void RemoveVertexAttributeMapping(const char* vertexAttributeName) override;
280 
284  void RemoveAllVertexAttributeMappings() override;
285 
291  std::vector<unsigned int> &pixeloffsets,
292  vtkProp *prop) override;
293 
294 protected:
296  ~vtkOpenGLPolyDataMapper() override;
297 
299 
300  void MapDataArray(
301  const char* vertexAttributeName,
302  const char* dataArrayName,
303  const char *texturename,
304  int fieldAssociation,
305  int componentno);
306 
307  // what coordinate should be used for this texture
308  std::string GetTextureCoordinateName(const char *tname);
309 
310  // the following is all extra stuff to work around the
311  // fact that gl_PrimitiveID does not work correctly on
312  // Apple Macs with AMD graphics hardware (before macOS 10.11).
313  // See <rdar://20747550>.
315  int HaveAppleBugForce; // 0 = default 1 = 0ff 2 = on
316  std::vector<float> AppleBugPrimIDs;
318 
322  void GetCoincidentParameters(
323  vtkRenderer *ren, vtkActor *actor, float &factor, float &offset);
324 
330  void ComputeBounds() override;
331 
336  virtual void UpdateShaders(
337  vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act);
338 
342  virtual bool GetNeedToRebuildShaders(
343  vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act);
344 
348  virtual void BuildShaders(
349  std::map<vtkShader::Type, vtkShader *> shaders,
350  vtkRenderer *ren, vtkActor *act);
351 
355  virtual void GetShaderTemplate(
356  std::map<vtkShader::Type, vtkShader *> shaders,
357  vtkRenderer *ren, vtkActor *act);
358 
362  virtual void ReplaceShaderValues(
363  std::map<vtkShader::Type, vtkShader *> shaders,
364  vtkRenderer *ren, vtkActor *act);
365 
367 
371  virtual void ReplaceShaderRenderPass(
372  std::map<vtkShader::Type, vtkShader *> shaders,
373  vtkRenderer *ren, vtkActor *act, bool prePass);
374  virtual void ReplaceShaderColor(
375  std::map<vtkShader::Type, vtkShader *> shaders,
376  vtkRenderer *ren, vtkActor *act);
377  virtual void ReplaceShaderLight(
378  std::map<vtkShader::Type, vtkShader *> shaders,
379  vtkRenderer *ren, vtkActor *act);
380  virtual void ReplaceShaderTCoord(
381  std::map<vtkShader::Type, vtkShader *> shaders,
382  vtkRenderer *ren, vtkActor *act);
383  virtual void ReplaceShaderPicking(
384  std::map<vtkShader::Type, vtkShader *> shaders,
385  vtkRenderer *ren, vtkActor *act);
386  virtual void ReplaceShaderPrimID(
387  std::map<vtkShader::Type, vtkShader *> shaders,
388  vtkRenderer *ren, vtkActor *act);
389  virtual void ReplaceShaderNormal(
390  std::map<vtkShader::Type, vtkShader *> shaders,
391  vtkRenderer *ren, vtkActor *act);
392  virtual void ReplaceShaderClip(
393  std::map<vtkShader::Type, vtkShader *> shaders,
394  vtkRenderer *ren, vtkActor *act);
395  virtual void ReplaceShaderPositionVC(
396  std::map<vtkShader::Type, vtkShader *> shaders,
397  vtkRenderer *ren, vtkActor *act);
398  virtual void ReplaceShaderCoincidentOffset(
399  std::map<vtkShader::Type, vtkShader *> shaders,
400  vtkRenderer *ren, vtkActor *act);
401  virtual void ReplaceShaderDepth(
402  std::map<vtkShader::Type, vtkShader *> shaders,
403  vtkRenderer *ren, vtkActor *act);
405 
409  virtual void SetMapperShaderParameters(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act);
410 
414  virtual void SetLightingShaderParameters(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act);
415 
419  virtual void SetCameraShaderParameters(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act);
420 
424  virtual void SetPropertyShaderParameters(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act);
425 
429  virtual void UpdateBufferObjects(vtkRenderer *ren, vtkActor *act);
430 
434  virtual bool GetNeedToRebuildBufferObjects(vtkRenderer *ren, vtkActor *act);
435 
439  virtual void BuildBufferObjects(vtkRenderer *ren, vtkActor *act);
440 
444  virtual void BuildIBO(vtkRenderer *ren, vtkActor *act, vtkPolyData *poly);
445 
446  // The VBO and its layout.
448 
449  // Structures for the various cell types we render.
450  vtkOpenGLHelper Primitives[PrimitiveEnd];
453 
454  // do we have wide lines that require special handling
455  virtual bool HaveWideLines(vtkRenderer *, vtkActor *);
456 
457  // do we have textures that require special handling
458  virtual bool HaveTextures(vtkActor *actor);
459 
460  // how many textures do we have
461  virtual unsigned int GetNumberOfTextures(vtkActor *actor);
462 
463  // populate a vector with the textures we have
464  // the order is always
465  // ColorInternalTexture
466  // Actors texture
467  // Properties textures
468  virtual std::vector<std::pair<vtkTexture *, std::string> > GetTextures(vtkActor *actor);
469 
470  // do we have textures coordinates that require special handling
471  virtual bool HaveTCoords(vtkPolyData *poly);
472 
473  // values we use to determine if we need to rebuild shaders
474  std::map<const vtkOpenGLHelper *, int> LastLightComplexity;
475  std::map<const vtkOpenGLHelper *, int> LastLightCount;
476  std::map<const vtkOpenGLHelper *, vtkTimeStamp> LightComplexityChanged;
477 
480 
481  // Caches the vtkOpenGLRenderPass::RenderPasses() information.
482  // Note: Do not dereference the pointers held by this object. There is no
483  // guarantee that they are still valid!
485 
486  // Check the renderpasses in actor's property keys to see if they've changed
487  // render stages:
488  vtkMTimeType GetRenderPassStageMTime(vtkActor *actor);
489 
491  vtkTimeStamp VBOBuildTime; // When was the OpenGL VBO updated?
492  std::string VBOBuildString; // used for determining whento rebuild the VBO
493  std::string IBOBuildString; // used for determining whento rebuild the IBOs
496 
499 
504  int ShiftScaleMethod; // for points
505 
506  // if set to true, tcoords will be passed to the
507  // VBO even if the mapper knows of no texture maps
508  // normally tcoords are only added to the VBO if the
509  // mapper has identified a texture map as well.
511 
512  virtual void BuildCellTextures(
513  vtkRenderer *ren,
514  vtkActor *,
515  vtkCellArray *prims[4],
516  int representation);
517 
518  void AppendCellTextures(
519  vtkRenderer *ren,
520  vtkActor *,
521  vtkCellArray *prims[4],
522  int representation,
523  std::vector<unsigned char> &colors,
524  std::vector<float> &normals,
525  vtkPolyData *pd);
526 
533 
534  // additional picking indirection
539 
540  std::map<const vtkShader::ReplacementSpec, vtkShader::ReplacementValue>
542 
544  {
545  public:
550  };
551  std::map<std::string,ExtraAttributeValue> ExtraAttributes;
552 
557 
558  // are we currently drawing spheres/tubes
559  bool DrawingSpheres(vtkOpenGLHelper &cellBO, vtkActor *actor);
560  bool DrawingTubes(vtkOpenGLHelper &cellBO, vtkActor *actor);
561  bool DrawingTubesOrSpheres(vtkOpenGLHelper &cellBO, vtkActor *actor);
562 
563  // get which opengl mode to use to draw the primitive
564  int GetOpenGLMode(int representation, int primType);
565 
566  // get how big to make the points when doing point picking
567  // typically 2 for points, 4 for lines, 6 for surface
568  int GetPointPickingPrimitiveSize(int primType);
569 
570  // used to occasionally invoke timers
571  unsigned int TimerQueryCounter;
572 
573  // stores the mapping from vtk cells to gl_PrimitiveId
574  std::vector<vtkIdType> CellCellMap;
575  std::vector<vtkIdType> PointCellMap;
577 
578  // compute and set the maximum point and cell ID used in selection
579  virtual void UpdateMaximumPointCellIds(vtkRenderer* ren, vtkActor *actor);
580 
581 private:
583  void operator=(const vtkOpenGLPolyDataMapper&) = delete;
584 };
585 
586 #endif
vtkPolyDataMapper
map vtkPolyData to graphics primitives
Definition: vtkPolyDataMapper.h:36
vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:33
vtkOpenGLPolyDataMapper::GetHaveAppleBug
bool GetHaveAppleBug()
Get the value of HaveAppleBug.
Definition: vtkOpenGLPolyDataMapper.h:212
vtkOpenGLPolyDataMapper::CompositeIdArrayName
char * CompositeIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:538
vtkOpenGLPolyDataMapper::ForceTextureCoordinates
bool ForceTextureCoordinates
Definition: vtkOpenGLPolyDataMapper.h:510
vtkOpenGLPolyDataMapper::ExtraAttributeValue::DataArrayName
std::string DataArrayName
Definition: vtkOpenGLPolyDataMapper.h:546
vtkOpenGLPolyDataMapper::UsingScalarColoring
bool UsingScalarColoring
Definition: vtkOpenGLPolyDataMapper.h:490
vtkPolyDataMapper::MapDataArrayToMultiTextureAttribute
virtual void MapDataArrayToMultiTextureAttribute(const char *textureName, const char *dataArrayName, int fieldAssociation, int componentno=-1)
vtkOpenGLBufferObject
OpenGL buffer object.
Definition: vtkOpenGLBufferObject.h:33
vtkShader.h
vtkOpenGLPolyDataMapper::CellTextureBuildString
std::string CellTextureBuildString
Definition: vtkOpenGLPolyDataMapper.h:494
vtkOpenGLPolyDataMapper::SetPopulateSelectionSettings
void SetPopulateSelectionSettings(int v)
Definition: vtkOpenGLPolyDataMapper.h:78
vtkOpenGLPolyDataMapper::CellMapsBuildString
std::string CellMapsBuildString
Definition: vtkOpenGLPolyDataMapper.h:576
vtkPolyDataMapper::RenderPiece
virtual void RenderPiece(vtkRenderer *ren, vtkActor *act)=0
Implemented by sub classes.
vtkPolyDataMapper::RemoveVertexAttributeMapping
virtual void RemoveVertexAttributeMapping(const char *vertexAttributeName)
Remove a vertex attribute mapping.
vtkOpenGLPolyDataMapper::VertexShaderCode
char * VertexShaderCode
Definition: vtkOpenGLPolyDataMapper.h:553
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:32
vtkOpenGLPolyDataMapper::CellCellMap
std::vector< vtkIdType > CellCellMap
Definition: vtkOpenGLPolyDataMapper.h:574
vtkOpenGLPolyDataMapper::LastLightCount
std::map< const vtkOpenGLHelper *, int > LastLightCount
Definition: vtkOpenGLPolyDataMapper.h:475
vtkOpenGLHelper.h
vtkObject::Modified
virtual void Modified()
Update the modification time for this object.
vtkOpenGLPolyDataMapper::AppleBugPrimIDs
std::vector< float > AppleBugPrimIDs
Definition: vtkOpenGLPolyDataMapper.h:316
vtkOpenGLPolyDataMapper::PrimitiveIDOffset
int PrimitiveIDOffset
Definition: vtkOpenGLPolyDataMapper.h:498
vtkOpenGLPolyDataMapper::ShiftScaleMethod
int ShiftScaleMethod
Definition: vtkOpenGLPolyDataMapper.h:504
vtkOpenGLPolyDataMapper::ExtraAttributeValue::ComponentNumber
int ComponentNumber
Definition: vtkOpenGLPolyDataMapper.h:548
vtkOpenGLPolyDataMapper::ExtraAttributes
std::map< std::string, ExtraAttributeValue > ExtraAttributes
Definition: vtkOpenGLPolyDataMapper.h:551
vtkOpenGLPolyDataMapper::PrimitiveTriStripsEdges
Definition: vtkOpenGLPolyDataMapper.h:229
vtkTransform
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:54
vtkOpenGLPolyDataMapper::VBOShiftScale
vtkNew< vtkMatrix4x4 > VBOShiftScale
Definition: vtkOpenGLPolyDataMapper.h:503
vtkMatrix3x3
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:33
vtkOpenGLPolyDataMapper::VBOBuildString
std::string VBOBuildString
Definition: vtkOpenGLPolyDataMapper.h:492
vtkOpenGLPolyDataMapper::PrimitiveLines
Definition: vtkOpenGLPolyDataMapper.h:225
vtkOpenGLPolyDataMapper::LastSelectionState
int LastSelectionState
Definition: vtkOpenGLPolyDataMapper.h:478
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:34
vtkOpenGLPolyDataMapper::CellNormalTexture
vtkTextureObject * CellNormalTexture
Definition: vtkOpenGLPolyDataMapper.h:530
vtkOpenGLRenderTimer
Asynchronously measures GPU execution time for a single event.
Definition: vtkOpenGLRenderTimer.h:37
vtkX3D::points
Definition: vtkX3D.h:446
vtkOpenGLPolyDataMapper::LastBoundBO
vtkOpenGLHelper * LastBoundBO
Definition: vtkOpenGLPolyDataMapper.h:451
vtkTexture
handles properties associated with a texture map
Definition: vtkTexture.h:65
vtkOpenGLPolyDataMapper::LastLightComplexity
std::map< const vtkOpenGLHelper *, int > LastLightComplexity
Definition: vtkOpenGLPolyDataMapper.h:474
vtkOpenGLPolyDataMapper::FragmentShaderCode
char * FragmentShaderCode
Definition: vtkOpenGLPolyDataMapper.h:554
vtkOpenGLPolyDataMapper::VBOBuildTime
vtkTimeStamp VBOBuildTime
Definition: vtkOpenGLPolyDataMapper.h:491
vtkOpenGLVertexBufferObjectGroup
manage vertex buffer objects shared within a mapper
Definition: vtkOpenGLVertexBufferObjectGroup.h:76
vtkX3D::offset
Definition: vtkX3D.h:438
vtkMapper::ProcessSelectorPixelBuffers
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:490
vtkOpenGLPolyDataMapper::CurrentInput
vtkPolyData * CurrentInput
Definition: vtkOpenGLPolyDataMapper.h:103
vtkOpenGLPolyDataMapper::GeometryShaderCode
char * GeometryShaderCode
Definition: vtkOpenGLPolyDataMapper.h:555
vtkOpenGLPolyDataMapper::CellNormalBuffer
vtkOpenGLBufferObject * CellNormalBuffer
Definition: vtkOpenGLPolyDataMapper.h:531
vtkOpenGLPolyDataMapper::HaveAppleBugForce
int HaveAppleBugForce
Definition: vtkOpenGLPolyDataMapper.h:315
vtkHardwareSelector
Definition: vtkHardwareSelector.h:123
vtkGenericOpenGLResourceFreeCallback
Definition: vtkOpenGLResourceFreeCallback.h:25
vtkOpenGLHelper
Definition: vtkOpenGLHelper.h:30
vtkPolyDataMapper::ShallowCopy
void ShallowCopy(vtkAbstractMapper *m)
Make a shallow copy of this mapper.
vtkActor
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:45
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkTextureObject
abstracts an OpenGL texture object.
Definition: vtkTextureObject.h:41
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:35
vtkOpenGLPolyDataMapper::UserShaderReplacements
std::map< const vtkShader::ReplacementSpec, vtkShader::ReplacementValue > UserShaderReplacements
Definition: vtkOpenGLPolyDataMapper.h:541
vtkOpenGLPolyDataMapper::ExtraAttributeValue
Definition: vtkOpenGLPolyDataMapper.h:543
vtkOpenGLPolyDataMapper::DrawingEdgesOrVertices
bool DrawingEdgesOrVertices
Definition: vtkOpenGLPolyDataMapper.h:452
vtkOpenGLPolyDataMapper::PointCellMap
std::vector< vtkIdType > PointCellMap
Definition: vtkOpenGLPolyDataMapper.h:575
vtkCellArray
object to represent cell connectivity
Definition: vtkCellArray.h:44
vtkShader::Type
Type
Available shader types.
Definition: vtkShader.h:45
vtkOpenGLPolyDataMapper::HaveCellNormals
bool HaveCellNormals
Definition: vtkOpenGLPolyDataMapper.h:532
vtkOpenGLPolyDataMapper::HaveCellScalars
bool HaveCellScalars
Definition: vtkOpenGLPolyDataMapper.h:529
vtkOpenGLPolyDataMapper::ResourceCallback
vtkGenericOpenGLResourceFreeCallback * ResourceCallback
Definition: vtkOpenGLPolyDataMapper.h:298
vtkOpenGLPolyDataMapper::VBOInverseTransform
vtkNew< vtkTransform > VBOInverseTransform
Definition: vtkOpenGLPolyDataMapper.h:502
vtkOpenGLVertexBufferObject
Definition: vtkOpenGLVertexBufferObject.h:38
vtkNew< vtkInformation >
vtkOpenGLPolyDataMapper::PopulateSelectionSettings
int PopulateSelectionSettings
Definition: vtkOpenGLPolyDataMapper.h:497
vtkOpenGLPolyDataMapper::PrimitiveTrisEdges
Definition: vtkOpenGLPolyDataMapper.h:228
vtkOpenGLPolyDataMapper::GetSupportsSelection
bool GetSupportsSelection() override
WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT USE THIS METHOD OUTSIDE OF THE RENDERI...
Definition: vtkOpenGLPolyDataMapper.h:86
vtkOpenGLPolyDataMapper::LightComplexityChanged
std::map< const vtkOpenGLHelper *, vtkTimeStamp > LightComplexityChanged
Definition: vtkOpenGLPolyDataMapper.h:476
vtkMapper::ReleaseGraphicsResources
void ReleaseGraphicsResources(vtkWindow *) override
Release any graphics resources that are being consumed by this mapper.
Definition: vtkMapper.h:108
vtkPolyDataMapper::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkProp
abstract superclass for all actors, volumes and annotations
Definition: vtkProp.h:46
vtkX3D::string
Definition: vtkX3D.h:490
vtkOpenGLPolyDataMapper::PrimitiveTris
Definition: vtkOpenGLPolyDataMapper.h:226
vtkOpenGLPolyDataMapper::TempMatrix4
vtkMatrix4x4 * TempMatrix4
Definition: vtkOpenGLPolyDataMapper.h:500
vtkOpenGLPolyDataMapper::VBOs
vtkOpenGLVertexBufferObjectGroup * VBOs
Definition: vtkOpenGLPolyDataMapper.h:447
vtkNew.h
vtkPolyDataMapper::New
static vtkPolyDataMapper * New()
vtkPolyDataMapper::MapDataArrayToVertexAttribute
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.
vtkMapper::GetIsOpaque
virtual bool GetIsOpaque()
Returns if the mapper does not expect to have translucent geometry.
vtkOpenGLPolyDataMapper::IBOBuildString
std::string IBOBuildString
Definition: vtkOpenGLPolyDataMapper.h:493
vtkOpenGLPolyDataMapper::ForceHaveAppleBugOn
void ForceHaveAppleBugOn()
Definition: vtkOpenGLPolyDataMapper.h:202
vtkOpenGLPolyDataMapper::TimerQuery
vtkOpenGLRenderTimer * TimerQuery
Definition: vtkOpenGLPolyDataMapper.h:556
vtkOpenGLPolyDataMapper::InternalColorTexture
vtkOpenGLTexture * InternalColorTexture
Definition: vtkOpenGLPolyDataMapper.h:495
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:57
vtkOpenGLPolyDataMapper::ExtraAttributeValue::TextureName
std::string TextureName
Definition: vtkOpenGLPolyDataMapper.h:549
vtkOpenGLPolyDataMapper::LastRenderPassInfo
vtkNew< vtkInformation > LastRenderPassInfo
Definition: vtkOpenGLPolyDataMapper.h:484
vtkOpenGLPolyDataMapper::TimerQueryCounter
unsigned int TimerQueryCounter
Definition: vtkOpenGLPolyDataMapper.h:571
vtkPolyData
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:79
vtkOpenGLPolyDataMapper::PrimitiveTypes
PrimitiveTypes
Definition: vtkOpenGLPolyDataMapper.h:222
vtkOpenGLPolyDataMapper::ForceHaveAppleBugOff
void ForceHaveAppleBugOff()
Override the normal test for the apple bug.
Definition: vtkOpenGLPolyDataMapper.h:197
vtkPolyDataMapper::ComputeBounds
virtual void ComputeBounds()
Called in GetBounds().
vtkPolyDataMapper.h
vtkOpenGLPolyDataMapper::PrimitiveVertices
Definition: vtkOpenGLPolyDataMapper.h:230
vtkOpenGLPolyDataMapper::AppleBugPrimIDBuffer
vtkOpenGLBufferObject * AppleBugPrimIDBuffer
Definition: vtkOpenGLPolyDataMapper.h:317
vtkOpenGLPolyDataMapper::PointIdArrayName
char * PointIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:535
vtkOpenGLPolyDataMapper::PrimitiveTriStrips
Definition: vtkOpenGLPolyDataMapper.h:227
vtkOpenGLTexture
OpenGL texture map.
Definition: vtkOpenGLTexture.h:33
vtkOpenGLPolyDataMapper::CellIdArrayName
char * CellIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:536
vtkOpenGLPolyDataMapper::TempMatrix3
vtkMatrix3x3 * TempMatrix3
Definition: vtkOpenGLPolyDataMapper.h:501
vtkOpenGLPolyDataMapper
PolyDataMapper using OpenGL to render.
Definition: vtkOpenGLPolyDataMapper.h:49
vtkOpenGLPolyDataMapper::ProcessIdArrayName
char * ProcessIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:537
vtkOpenGLPolyDataMapper::CellScalarBuffer
vtkOpenGLBufferObject * CellScalarBuffer
Definition: vtkOpenGLPolyDataMapper.h:528
vtkOpenGLPolyDataMapper::ExtraAttributeValue::FieldAssociation
int FieldAssociation
Definition: vtkOpenGLPolyDataMapper.h:547
vtkOpenGLPolyDataMapper::SelectionStateChanged
vtkTimeStamp SelectionStateChanged
Definition: vtkOpenGLPolyDataMapper.h:479
vtkPolyDataMapper::RemoveAllVertexAttributeMappings
virtual void RemoveAllVertexAttributeMappings()
Remove all vertex attributes.
vtkAbstractMapper
abstract class specifies interface to map data
Definition: vtkAbstractMapper.h:52
vtkOpenGLPolyDataMapper::CellScalarTexture
vtkTextureObject * CellScalarTexture
Definition: vtkOpenGLPolyDataMapper.h:527
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:302
vtkOpenGLPolyDataMapper::HaveAppleBug
bool HaveAppleBug
Definition: vtkOpenGLPolyDataMapper.h:314