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
vtkPolyDataMapper
map vtkPolyData to graphics primitives
Definition: vtkPolyDataMapper.h:36
vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:33
vtkOpenGLShaderProperty
represent GPU shader properties
Definition: vtkOpenGLShaderProperty.h:40
vtkOpenGLPolyDataMapper::CompositeIdArrayName
char * CompositeIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:459
vtkOpenGLPolyDataMapper::ForceTextureCoordinates
bool ForceTextureCoordinates
Definition: vtkOpenGLPolyDataMapper.h:439
vtkOpenGLPolyDataMapper::ExtraAttributeValue::DataArrayName
std::string DataArrayName
Definition: vtkOpenGLPolyDataMapper.h:464
vtkOpenGLPolyDataMapper::TempState
vtkStateStorage TempState
Definition: vtkOpenGLPolyDataMapper.h:423
vtkOpenGLPolyDataMapper::CellCellMap
vtkNew< vtkOpenGLCellToVTKCellMap > CellCellMap
Definition: vtkOpenGLPolyDataMapper.h:496
vtkOpenGLPolyDataMapper::UsingScalarColoring
bool UsingScalarColoring
Definition: vtkOpenGLPolyDataMapper.h:418
vtkPolyDataMapper::MapDataArrayToMultiTextureAttribute
virtual void MapDataArrayToMultiTextureAttribute(const char *textureName, const char *dataArrayName, int fieldAssociation, int componentno=-1)
vtkStateStorage
Class to make storing and comparing state quick and easy.
Definition: vtkStateStorage.h:131
vtkOpenGLBufferObject
OpenGL buffer object.
Definition: vtkOpenGLBufferObject.h:33
vtkShader.h
vtkOpenGLPolyDataMapper::SetPopulateSelectionSettings
void SetPopulateSelectionSettings(int v)
Definition: vtkOpenGLPolyDataMapper.h:86
vtkStateStorage.h
vtkPolyDataMapper::RemoveVertexAttributeMapping
virtual void RemoveVertexAttributeMapping(const char *vertexAttributeName)
Remove a vertex attribute mapping.
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:32
vtkOpenGLPolyDataMapper::VBOBuildState
vtkStateStorage VBOBuildState
Definition: vtkOpenGLPolyDataMapper.h:420
vtkPolyDataMapper::ShallowCopy
void ShallowCopy(vtkAbstractMapper *m) override
Make a shallow copy of this mapper.
vtkOpenGLHelper.h
vtkSmartPointer< vtkOpenGLShaderProperty >
vtkOpenGLPolyDataMapper::PrimitiveIDOffset
int PrimitiveIDOffset
Definition: vtkOpenGLPolyDataMapper.h:427
vtkOpenGLPolyDataMapper::ShiftScaleMethod
int ShiftScaleMethod
Definition: vtkOpenGLPolyDataMapper.h:433
vtkOpenGLPolyDataMapper::ExtraAttributeValue::ComponentNumber
int ComponentNumber
Definition: vtkOpenGLPolyDataMapper.h:466
vtkOpenGLPolyDataMapper::IBOBuildState
vtkStateStorage IBOBuildState
Definition: vtkOpenGLPolyDataMapper.h:421
vtkOpenGLPolyDataMapper::PrimitiveTriStripsEdges
@ PrimitiveTriStripsEdges
Definition: vtkOpenGLPolyDataMapper.h:199
vtkTransform
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:54
vtkOpenGLPolyDataMapper::VBOShiftScale
vtkNew< vtkMatrix4x4 > VBOShiftScale
Definition: vtkOpenGLPolyDataMapper.h:432
vtkMatrix3x3
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:33
vtkOpenGLCellToVTKCellMap
OpenGL rendering utility functions.
Definition: vtkOpenGLCellToVTKCellMap.h:35
vtkPolyDataMapper::RenderPiece
virtual void RenderPiece(vtkRenderer *, vtkActor *)
Implemented by sub classes.
Definition: vtkPolyDataMapper.h:46
vtkOpenGLPolyDataMapper::PrimitiveLines
@ PrimitiveLines
Definition: vtkOpenGLPolyDataMapper.h:195
vtkOpenGLPolyDataMapper::LastSelectionState
int LastSelectionState
Definition: vtkOpenGLPolyDataMapper.h:406
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:37
vtkOpenGLPolyDataMapper::LastLightComplexity
std::map< const vtkOpenGLHelper *, int > LastLightComplexity
Definition: vtkOpenGLPolyDataMapper.h:402
vtkOpenGLPolyDataMapper::CellNormalTexture
vtkTextureObject * CellNormalTexture
Definition: vtkOpenGLPolyDataMapper.h:451
vtkOpenGLRenderTimer
Asynchronously measures GPU execution time for a single event.
Definition: vtkOpenGLRenderTimer.h:37
vtkOpenGLPolyDataMapper::LightComplexityChanged
std::map< const vtkOpenGLHelper *, vtkTimeStamp > LightComplexityChanged
Definition: vtkOpenGLPolyDataMapper.h:404
vtkOpenGLPolyDataMapper::LastBoundBO
vtkOpenGLHelper * LastBoundBO
Definition: vtkOpenGLPolyDataMapper.h:379
vtkTexture
handles properties associated with a texture map
Definition: vtkTexture.h:65
vtkOpenGLPolyDataMapper::ExtraAttributes
std::map< std::string, ExtraAttributeValue > ExtraAttributes
Definition: vtkOpenGLPolyDataMapper.h:469
vtkOpenGLPolyDataMapper::VBOBuildTime
vtkTimeStamp VBOBuildTime
Definition: vtkOpenGLPolyDataMapper.h:419
vtkOpenGLVertexBufferObjectGroup
manage vertex buffer objects shared within a mapper
Definition: vtkOpenGLVertexBufferObjectGroup.h:77
vtkX3D::offset
@ offset
Definition: vtkX3D.h:444
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:470
vtkOpenGLPolyDataMapper::CurrentInput
vtkPolyData * CurrentInput
Definition: vtkOpenGLPolyDataMapper.h:99
vtkOpenGLPolyDataMapper::CellNormalBuffer
vtkOpenGLBufferObject * CellNormalBuffer
Definition: vtkOpenGLPolyDataMapper.h:452
vtkHardwareSelector
Definition: vtkHardwareSelector.h:123
vtkGenericOpenGLResourceFreeCallback
Definition: vtkOpenGLResourceFreeCallback.h:25
vtkOpenGLHelper
Definition: vtkOpenGLHelper.h:30
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:40
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:35
vtkOpenGLPolyDataMapper::ExtraAttributeValue
Definition: vtkOpenGLPolyDataMapper.h:461
vtkOpenGLPolyDataMapper::DrawingEdgesOrVertices
bool DrawingEdgesOrVertices
Definition: vtkOpenGLPolyDataMapper.h:380
vtkCellArray
object to represent cell connectivity
Definition: vtkCellArray.h:179
vtkShader::Type
Type
Available shader types.
Definition: vtkShader.h:45
vtkOpenGLPolyDataMapper::HaveCellNormals
bool HaveCellNormals
Definition: vtkOpenGLPolyDataMapper.h:453
vtkOpenGLPolyDataMapper::HaveCellScalars
bool HaveCellScalars
Definition: vtkOpenGLPolyDataMapper.h:450
vtkOpenGLPolyDataMapper::ResourceCallback
vtkGenericOpenGLResourceFreeCallback * ResourceCallback
Definition: vtkOpenGLPolyDataMapper.h:247
vtkOpenGLPolyDataMapper::VBOInverseTransform
vtkNew< vtkTransform > VBOInverseTransform
Definition: vtkOpenGLPolyDataMapper.h:431
vtkOpenGLVertexBufferObject
Definition: vtkOpenGLVertexBufferObject.h:36
vtkNew< vtkInformation >
vtkOpenGLPolyDataMapper::PopulateSelectionSettings
int PopulateSelectionSettings
Definition: vtkOpenGLPolyDataMapper.h:426
vtkOpenGLPolyDataMapper::PrimitiveTrisEdges
@ PrimitiveTrisEdges
Definition: vtkOpenGLPolyDataMapper.h:198
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:94
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:53
vtkX3D::string
@ string
Definition: vtkX3D.h:496
vtkOpenGLPolyDataMapper::PrimitiveTris
@ PrimitiveTris
Definition: vtkOpenGLPolyDataMapper.h:196
vtkOpenGLPolyDataMapper::TempMatrix4
vtkMatrix4x4 * TempMatrix4
Definition: vtkOpenGLPolyDataMapper.h:429
vtkOpenGLPolyDataMapper::VBOs
vtkOpenGLVertexBufferObjectGroup * VBOs
Definition: vtkOpenGLPolyDataMapper.h:375
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.
vtkOpenGLPolyDataMapper::TimerQuery
vtkOpenGLRenderTimer * TimerQuery
Definition: vtkOpenGLPolyDataMapper.h:478
vtkOpenGLPolyDataMapper::InternalColorTexture
vtkOpenGLTexture * InternalColorTexture
Definition: vtkOpenGLPolyDataMapper.h:424
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:67
vtkOpenGLPolyDataMapper::ExtraAttributeValue::TextureName
std::string TextureName
Definition: vtkOpenGLPolyDataMapper.h:467
vtkOpenGLPolyDataMapper::LastRenderPassInfo
vtkNew< vtkInformation > LastRenderPassInfo
Definition: vtkOpenGLPolyDataMapper.h:412
vtkOpenGLPolyDataMapper::TimerQueryCounter
unsigned int TimerQueryCounter
Definition: vtkOpenGLPolyDataMapper.h:493
vtkOpenGLPolyDataMapper::CellTextureBuildState
vtkStateStorage CellTextureBuildState
Definition: vtkOpenGLPolyDataMapper.h:422
vtkPolyData
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:84
vtkOpenGLPolyDataMapper::PrimitiveTypes
PrimitiveTypes
Definition: vtkOpenGLPolyDataMapper.h:191
vtkPolyDataMapper::ComputeBounds
virtual void ComputeBounds()
Called in GetBounds().
vtkPolyDataMapper.h
vtkOpenGLPolyDataMapper::PrimitiveVertices
@ PrimitiveVertices
Definition: vtkOpenGLPolyDataMapper.h:200
vtkOpenGLPolyDataMapper::PointIdArrayName
char * PointIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:456
vtkOpenGLPolyDataMapper::PrimitiveTriStrips
@ PrimitiveTriStrips
Definition: vtkOpenGLPolyDataMapper.h:197
vtkOpenGLTexture
OpenGL texture map.
Definition: vtkOpenGLTexture.h:33
vtkOpenGLPolyDataMapper::CellIdArrayName
char * CellIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:457
vtkOpenGLPolyDataMapper::TempMatrix3
vtkMatrix3x3 * TempMatrix3
Definition: vtkOpenGLPolyDataMapper.h:430
vtkOpenGLPolyDataMapper
PolyDataMapper using OpenGL to render.
Definition: vtkOpenGLPolyDataMapper.h:57
vtkOpenGLPolyDataMapper::ProcessIdArrayName
char * ProcessIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:458
vtkOpenGLPolyDataMapper::CellScalarBuffer
vtkOpenGLBufferObject * CellScalarBuffer
Definition: vtkOpenGLPolyDataMapper.h:449
vtkOpenGLPolyDataMapper::LegacyShaderProperty
vtkSmartPointer< vtkOpenGLShaderProperty > LegacyShaderProperty
Definition: vtkOpenGLPolyDataMapper.h:475
vtkOpenGLPolyDataMapper::ExtraAttributeValue::FieldAssociation
int FieldAssociation
Definition: vtkOpenGLPolyDataMapper.h:465
vtkOpenGLPolyDataMapper::SelectionStateChanged
vtkTimeStamp SelectionStateChanged
Definition: vtkOpenGLPolyDataMapper.h:407
vtkOpenGLPolyDataMapper::LastLightCount
std::map< const vtkOpenGLHelper *, int > LastLightCount
Definition: vtkOpenGLPolyDataMapper.h:403
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:448
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:293