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 "vtkNew.h" // for ivars
26 #include "vtkOpenGLHelper.h" // used for ivars
27 #include "vtkPolyDataMapper.h"
28 #include "vtkRenderingOpenGL2Module.h" // For export macro
29 #include "vtkShader.h" // for methods
30 #include "vtkStateStorage.h" // used for ivars
31 
32 #include <map> //for methods
33 #include <vector> //for ivars
34 
35 class vtkCellArray;
37 class vtkMatrix4x4;
38 class vtkMatrix3x3;
41 class vtkOpenGLTexture;
45 class vtkPoints;
46 class vtkTexture;
47 class vtkTextureObject;
48 class vtkTransform;
50 
51 class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLPolyDataMapper : public vtkPolyDataMapper
52 {
53 public:
54  static vtkOpenGLPolyDataMapper* New();
56  void PrintSelf(ostream& os, vtkIndent indent) override;
57 
61  void RenderPiece(vtkRenderer* ren, vtkActor* act) override;
62 
64 
67  virtual void RenderPieceStart(vtkRenderer* ren, vtkActor* act);
68  virtual void RenderPieceDraw(vtkRenderer* ren, vtkActor* act);
69  virtual void RenderPieceFinish(vtkRenderer* ren, vtkActor* act);
71 
77  void ReleaseGraphicsResources(vtkWindow*) override;
78 
79  vtkGetMacro(PopulateSelectionSettings, int);
80  void SetPopulateSelectionSettings(int v) { this->PopulateSelectionSettings = v; }
81 
88  bool GetSupportsSelection() override { return true; }
89 
90  // used by RenderPiece and functions it calls to reduce
91  // calls to get the input and allow for rendering of
92  // other polydata (not the input)
94 
96 
102  vtkSetStringMacro(PointIdArrayName);
103  vtkGetStringMacro(PointIdArrayName);
104  vtkSetStringMacro(CellIdArrayName);
105  vtkGetStringMacro(CellIdArrayName);
107 
109 
114  vtkSetStringMacro(ProcessIdArrayName);
115  vtkGetStringMacro(ProcessIdArrayName);
117 
119 
128  vtkSetStringMacro(CompositeIdArrayName);
129  vtkGetStringMacro(CompositeIdArrayName);
131 
132 #ifndef VTK_LEGACY_REMOVE
133 
134 
144  VTK_LEGACY(void AddShaderReplacement(vtkShader::Type shaderType, // vertex, fragment, etc
145  const std::string& originalValue,
146  bool replaceFirst, // do this replacement before the default
147  const std::string& replacementValue, bool replaceAll);)
148  VTK_LEGACY(void ClearShaderReplacement(vtkShader::Type shaderType, // vertex, fragment, etc
149  const std::string& originalValue, bool replaceFirst);)
150  VTK_LEGACY(void ClearAllShaderReplacements(vtkShader::Type shaderType);)
151  VTK_LEGACY(void ClearAllShaderReplacements();)
153 
155 
163  VTK_LEGACY(virtual void SetVertexShaderCode(const char* code);)
164  VTK_LEGACY(virtual char* GetVertexShaderCode();)
165  VTK_LEGACY(virtual void SetFragmentShaderCode(const char* code);)
166  VTK_LEGACY(virtual char* GetFragmentShaderCode();)
167  VTK_LEGACY(virtual void SetGeometryShaderCode(const char* code);)
168  VTK_LEGACY(virtual char* GetGeometryShaderCode();)
170 #endif
171 
175  void ShallowCopy(vtkAbstractMapper* m) override;
176 
178  vtkGetObjectMacro(VBOs, vtkOpenGLVertexBufferObjectGroup);
179 
183  void SetVBOShiftScaleMethod(int m);
184 
186  {
187  PrimitiveStart = 0,
188  PrimitivePoints = 0,
195  PrimitiveEnd
196  };
197 
209  void MapDataArrayToVertexAttribute(const char* vertexAttributeName, const char* dataArrayName,
210  int fieldAssociation, int componentno = -1) override;
211 
212  // This method will Map the specified data array for use as
213  // a texture coordinate for texture tname. The actual
214  // attribute will be named tname_coord so as to not
215  // conflict with the texture sampler definition which will
216  // be tname.
217  void MapDataArrayToMultiTextureAttribute(const char* tname, const char* dataArrayName,
218  int fieldAssociation, int componentno = -1) override;
219 
223  void RemoveVertexAttributeMapping(const char* vertexAttributeName) override;
224 
228  void RemoveAllVertexAttributeMappings() override;
229 
235  vtkHardwareSelector* sel, std::vector<unsigned int>& pixeloffsets, vtkProp* prop) override;
236 
237 protected:
239  ~vtkOpenGLPolyDataMapper() override;
240 
242 
243  void MapDataArray(const char* vertexAttributeName, const char* dataArrayName,
244  const char* texturename, int fieldAssociation, int componentno);
245 
246  // what coordinate should be used for this texture
247  std::string GetTextureCoordinateName(const char* tname);
248 
252  void GetCoincidentParameters(vtkRenderer* ren, vtkActor* actor, float& factor, float& offset);
253 
259  void ComputeBounds() override;
260 
265  virtual void UpdateShaders(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
266 
270  virtual bool GetNeedToRebuildShaders(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
271 
275  virtual void BuildShaders(
276  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
277 
281  virtual void GetShaderTemplate(
282  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
283 
287  virtual void ReplaceShaderValues(
288  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
289 
291 
295  virtual void ReplaceShaderRenderPass(
296  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act, bool prePass);
297  virtual void ReplaceShaderCustomUniforms(
298  std::map<vtkShader::Type, vtkShader*> shaders, vtkActor* act);
299  virtual void ReplaceShaderColor(
300  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
301  virtual void ReplaceShaderLight(
302  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
303  virtual void ReplaceShaderTCoord(
304  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
305  virtual void ReplaceShaderPicking(
306  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
307  virtual void ReplaceShaderPrimID(
308  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
309  virtual void ReplaceShaderNormal(
310  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
311  virtual void ReplaceShaderClip(
312  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
313  virtual void ReplaceShaderPositionVC(
314  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
315  virtual void ReplaceShaderCoincidentOffset(
316  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
317  virtual void ReplaceShaderDepth(
318  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
320 
324  virtual void SetCustomUniforms(vtkOpenGLHelper& cellBO, vtkActor* actor);
325 
329  virtual void SetMapperShaderParameters(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
330 
334  virtual void SetLightingShaderParameters(
335  vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
336 
340  virtual void SetCameraShaderParameters(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
341 
345  virtual void SetPropertyShaderParameters(
346  vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
347 
351  virtual void UpdateBufferObjects(vtkRenderer* ren, vtkActor* act);
352 
356  virtual bool GetNeedToRebuildBufferObjects(vtkRenderer* ren, vtkActor* act);
357 
361  virtual void BuildBufferObjects(vtkRenderer* ren, vtkActor* act);
362 
366  virtual void BuildIBO(vtkRenderer* ren, vtkActor* act, vtkPolyData* poly);
367 
368  // The VBO and its layout.
370 
371  // Structures for the various cell types we render.
372  vtkOpenGLHelper Primitives[PrimitiveEnd];
375 
376  // do we have wide lines that require special handling
377  virtual bool HaveWideLines(vtkRenderer*, vtkActor*);
378 
379  // do we have textures that require special handling
380  virtual bool HaveTextures(vtkActor* actor);
381 
382  // how many textures do we have
383  virtual unsigned int GetNumberOfTextures(vtkActor* actor);
384 
385  // populate a vector with the textures we have
386  // the order is always
387  // ColorInternalTexture
388  // Actors texture
389  // Properties textures
390  virtual std::vector<std::pair<vtkTexture*, std::string> > GetTextures(vtkActor* actor);
391 
392  // do we have textures coordinates that require special handling
393  virtual bool HaveTCoords(vtkPolyData* poly);
394 
395  // values we use to determine if we need to rebuild shaders
396  std::map<const vtkOpenGLHelper*, int> LastLightComplexity;
397  std::map<const vtkOpenGLHelper*, int> LastLightCount;
398  std::map<const vtkOpenGLHelper*, vtkTimeStamp> LightComplexityChanged;
399 
402 
403  // Caches the vtkOpenGLRenderPass::RenderPasses() information.
404  // Note: Do not dereference the pointers held by this object. There is no
405  // guarantee that they are still valid!
407 
408  // Check the renderpasses in actor's property keys to see if they've changed
409  // render stages:
410  vtkMTimeType GetRenderPassStageMTime(vtkActor* actor);
411 
413  vtkTimeStamp VBOBuildTime; // When was the OpenGL VBO updated?
414  vtkStateStorage VBOBuildState; // used for determining when to rebuild the VBO
415  vtkStateStorage IBOBuildState; // used for determining whento rebuild the IBOs
417  vtkStateStorage TempState; // can be used to avoid constant allocs/deallocs
419 
422 
427  int ShiftScaleMethod; // for points
428 
429  // if set to true, tcoords will be passed to the
430  // VBO even if the mapper knows of no texture maps
431  // normally tcoords are only added to the VBO if the
432  // mapper has identified a texture map as well.
434 
435  virtual void BuildCellTextures(
436  vtkRenderer* ren, vtkActor*, vtkCellArray* prims[4], int representation);
437 
438  void AppendCellTextures(vtkRenderer* ren, vtkActor*, vtkCellArray* prims[4], int representation,
439  std::vector<unsigned char>& colors, std::vector<float>& normals, vtkPolyData* pd,
441 
448 
449  // additional picking indirection
454 
456  {
457  public:
462  };
463  std::map<std::string, ExtraAttributeValue> ExtraAttributes;
464 
465  // Store shader properties on this class by legacy shader replacement functions
466  // This should disappear when the functions are deprecated
467 #ifndef VTK_LEGACY_REMOVE
468  vtkOpenGLShaderProperty* GetLegacyShaderProperty();
470 #endif
471 
473 
474  // are we currently drawing spheres/tubes
475  bool DrawingSpheres(vtkOpenGLHelper& cellBO, vtkActor* actor);
476  bool DrawingTubes(vtkOpenGLHelper& cellBO, vtkActor* actor);
477  bool DrawingTubesOrSpheres(vtkOpenGLHelper& cellBO, vtkActor* actor);
478 
479  // get which opengl mode to use to draw the primitive
480  int GetOpenGLMode(int representation, int primType);
481 
482  // get how big to make the points when doing point picking
483  // typically 2 for points, 4 for lines, 6 for surface
484  int GetPointPickingPrimitiveSize(int primType);
485 
486  // used to occasionally invoke timers
487  unsigned int TimerQueryCounter;
488 
489  // stores the mapping from vtk cells to gl_PrimitiveId
491 
492  // compute and set the maximum point and cell ID used in selection
493  virtual void UpdateMaximumPointCellIds(vtkRenderer* ren, vtkActor* actor);
494 
495 private:
497  void operator=(const vtkOpenGLPolyDataMapper&) = delete;
498 };
499 
500 #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:453
vtkOpenGLPolyDataMapper::ForceTextureCoordinates
bool ForceTextureCoordinates
Definition: vtkOpenGLPolyDataMapper.h:433
vtkOpenGLPolyDataMapper::ExtraAttributeValue::DataArrayName
std::string DataArrayName
Definition: vtkOpenGLPolyDataMapper.h:458
vtkOpenGLPolyDataMapper::TempState
vtkStateStorage TempState
Definition: vtkOpenGLPolyDataMapper.h:417
vtkOpenGLPolyDataMapper::CellCellMap
vtkNew< vtkOpenGLCellToVTKCellMap > CellCellMap
Definition: vtkOpenGLPolyDataMapper.h:490
vtkOpenGLPolyDataMapper::UsingScalarColoring
bool UsingScalarColoring
Definition: vtkOpenGLPolyDataMapper.h:412
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:80
vtkPolyDataMapper::RenderPiece
virtual void RenderPiece(vtkRenderer *ren, vtkActor *act)=0
Implemented by sub classes.
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:414
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:421
vtkOpenGLPolyDataMapper::ShiftScaleMethod
int ShiftScaleMethod
Definition: vtkOpenGLPolyDataMapper.h:427
vtkOpenGLPolyDataMapper::ExtraAttributeValue::ComponentNumber
int ComponentNumber
Definition: vtkOpenGLPolyDataMapper.h:460
vtkOpenGLPolyDataMapper::IBOBuildState
vtkStateStorage IBOBuildState
Definition: vtkOpenGLPolyDataMapper.h:415
vtkOpenGLPolyDataMapper::PrimitiveTriStripsEdges
Definition: vtkOpenGLPolyDataMapper.h:193
vtkTransform
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:54
vtkOpenGLPolyDataMapper::VBOShiftScale
vtkNew< vtkMatrix4x4 > VBOShiftScale
Definition: vtkOpenGLPolyDataMapper.h:426
vtkMatrix3x3
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:33
vtkOpenGLCellToVTKCellMap
OpenGL rendering utility functions.
Definition: vtkOpenGLCellToVTKCellMap.h:35
vtkOpenGLPolyDataMapper::PrimitiveLines
Definition: vtkOpenGLPolyDataMapper.h:189
vtkOpenGLPolyDataMapper::LastSelectionState
int LastSelectionState
Definition: vtkOpenGLPolyDataMapper.h:400
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:34
vtkOpenGLPolyDataMapper::LastLightComplexity
std::map< const vtkOpenGLHelper *, int > LastLightComplexity
Definition: vtkOpenGLPolyDataMapper.h:396
vtkOpenGLPolyDataMapper::CellNormalTexture
vtkTextureObject * CellNormalTexture
Definition: vtkOpenGLPolyDataMapper.h:445
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:398
vtkOpenGLPolyDataMapper::LastBoundBO
vtkOpenGLHelper * LastBoundBO
Definition: vtkOpenGLPolyDataMapper.h:373
vtkTexture
handles properties associated with a texture map
Definition: vtkTexture.h:65
vtkOpenGLPolyDataMapper::ExtraAttributes
std::map< std::string, ExtraAttributeValue > ExtraAttributes
Definition: vtkOpenGLPolyDataMapper.h:463
vtkOpenGLPolyDataMapper::VBOBuildTime
vtkTimeStamp VBOBuildTime
Definition: vtkOpenGLPolyDataMapper.h:413
vtkOpenGLVertexBufferObjectGroup
manage vertex buffer objects shared within a mapper
Definition: vtkOpenGLVertexBufferObjectGroup.h:77
vtkX3D::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:93
vtkOpenGLPolyDataMapper::CellNormalBuffer
vtkOpenGLBufferObject * CellNormalBuffer
Definition: vtkOpenGLPolyDataMapper.h:446
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:455
vtkOpenGLPolyDataMapper::DrawingEdgesOrVertices
bool DrawingEdgesOrVertices
Definition: vtkOpenGLPolyDataMapper.h:374
vtkCellArray
object to represent cell connectivity
Definition: vtkCellArray.h:163
vtkShader::Type
Type
Available shader types.
Definition: vtkShader.h:45
vtkOpenGLPolyDataMapper::HaveCellNormals
bool HaveCellNormals
Definition: vtkOpenGLPolyDataMapper.h:447
vtkOpenGLPolyDataMapper::HaveCellScalars
bool HaveCellScalars
Definition: vtkOpenGLPolyDataMapper.h:444
vtkOpenGLPolyDataMapper::ResourceCallback
vtkGenericOpenGLResourceFreeCallback * ResourceCallback
Definition: vtkOpenGLPolyDataMapper.h:241
vtkOpenGLPolyDataMapper::VBOInverseTransform
vtkNew< vtkTransform > VBOInverseTransform
Definition: vtkOpenGLPolyDataMapper.h:425
vtkOpenGLVertexBufferObject
Definition: vtkOpenGLVertexBufferObject.h:36
vtkNew< vtkInformation >
vtkOpenGLPolyDataMapper::PopulateSelectionSettings
int PopulateSelectionSettings
Definition: vtkOpenGLPolyDataMapper.h:420
vtkOpenGLPolyDataMapper::PrimitiveTrisEdges
Definition: vtkOpenGLPolyDataMapper.h:192
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:88
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:47
vtkX3D::string
Definition: vtkX3D.h:496
vtkOpenGLPolyDataMapper::PrimitiveTris
Definition: vtkOpenGLPolyDataMapper.h:190
vtkOpenGLPolyDataMapper::TempMatrix4
vtkMatrix4x4 * TempMatrix4
Definition: vtkOpenGLPolyDataMapper.h:423
vtkOpenGLPolyDataMapper::VBOs
vtkOpenGLVertexBufferObjectGroup * VBOs
Definition: vtkOpenGLPolyDataMapper.h:369
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:472
vtkOpenGLPolyDataMapper::InternalColorTexture
vtkOpenGLTexture * InternalColorTexture
Definition: vtkOpenGLPolyDataMapper.h:418
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:58
vtkOpenGLPolyDataMapper::ExtraAttributeValue::TextureName
std::string TextureName
Definition: vtkOpenGLPolyDataMapper.h:461
vtkOpenGLPolyDataMapper::LastRenderPassInfo
vtkNew< vtkInformation > LastRenderPassInfo
Definition: vtkOpenGLPolyDataMapper.h:406
vtkOpenGLPolyDataMapper::TimerQueryCounter
unsigned int TimerQueryCounter
Definition: vtkOpenGLPolyDataMapper.h:487
vtkOpenGLPolyDataMapper::CellTextureBuildState
vtkStateStorage CellTextureBuildState
Definition: vtkOpenGLPolyDataMapper.h:416
vtkPolyData
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:84
vtkOpenGLPolyDataMapper::PrimitiveTypes
PrimitiveTypes
Definition: vtkOpenGLPolyDataMapper.h:185
vtkPolyDataMapper::ComputeBounds
virtual void ComputeBounds()
Called in GetBounds().
vtkPolyDataMapper.h
vtkOpenGLPolyDataMapper::PrimitiveVertices
Definition: vtkOpenGLPolyDataMapper.h:194
vtkOpenGLPolyDataMapper::PointIdArrayName
char * PointIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:450
vtkOpenGLPolyDataMapper::PrimitiveTriStrips
Definition: vtkOpenGLPolyDataMapper.h:191
vtkOpenGLTexture
OpenGL texture map.
Definition: vtkOpenGLTexture.h:33
vtkOpenGLPolyDataMapper::CellIdArrayName
char * CellIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:451
vtkOpenGLPolyDataMapper::TempMatrix3
vtkMatrix3x3 * TempMatrix3
Definition: vtkOpenGLPolyDataMapper.h:424
vtkOpenGLPolyDataMapper
PolyDataMapper using OpenGL to render.
Definition: vtkOpenGLPolyDataMapper.h:51
vtkOpenGLPolyDataMapper::ProcessIdArrayName
char * ProcessIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:452
vtkOpenGLPolyDataMapper::CellScalarBuffer
vtkOpenGLBufferObject * CellScalarBuffer
Definition: vtkOpenGLPolyDataMapper.h:443
vtkOpenGLPolyDataMapper::LegacyShaderProperty
vtkSmartPointer< vtkOpenGLShaderProperty > LegacyShaderProperty
Definition: vtkOpenGLPolyDataMapper.h:469
vtkOpenGLPolyDataMapper::ExtraAttributeValue::FieldAssociation
int FieldAssociation
Definition: vtkOpenGLPolyDataMapper.h:459
vtkOpenGLPolyDataMapper::SelectionStateChanged
vtkTimeStamp SelectionStateChanged
Definition: vtkOpenGLPolyDataMapper.h:401
vtkOpenGLPolyDataMapper::LastLightCount
std::map< const vtkOpenGLHelper *, int > LastLightCount
Definition: vtkOpenGLPolyDataMapper.h:397
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:442
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:298