VTK  9.0.20200806
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 "vtkDeprecation.h" // For VTK_DEPRECATED_IN_9_0_0
31 #include "vtkNew.h" // For vtkNew
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 map
39 #include <tuple> // for tuple
40 #include <vector> // for vector
41 
42 class vtkCellArray;
44 class vtkMatrix4x4;
45 class vtkMatrix3x3;
48 class vtkOpenGLTexture;
52 class vtkPoints;
53 class vtkTexture;
54 class vtkTextureObject;
55 class vtkTransform;
57 
58 class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLPolyDataMapper : public vtkPolyDataMapper
59 {
60 public:
61  static vtkOpenGLPolyDataMapper* New();
63  void PrintSelf(ostream& os, vtkIndent indent) override;
64 
68  void RenderPiece(vtkRenderer* ren, vtkActor* act) override;
69 
71 
74  virtual void RenderPieceStart(vtkRenderer* ren, vtkActor* act);
75  virtual void RenderPieceDraw(vtkRenderer* ren, vtkActor* act);
76  virtual void RenderPieceFinish(vtkRenderer* ren, vtkActor* act);
78 
84  void ReleaseGraphicsResources(vtkWindow*) override;
85 
86  vtkGetMacro(PopulateSelectionSettings, int);
87  void SetPopulateSelectionSettings(int v) { this->PopulateSelectionSettings = v; }
88 
95  bool GetSupportsSelection() override { return true; }
96 
97  // used by RenderPiece and functions it calls to reduce
98  // calls to get the input and allow for rendering of
99  // other polydata (not the input)
101 
103 
109  vtkSetStringMacro(PointIdArrayName);
110  vtkGetStringMacro(PointIdArrayName);
111  vtkSetStringMacro(CellIdArrayName);
112  vtkGetStringMacro(CellIdArrayName);
114 
116 
121  vtkSetStringMacro(ProcessIdArrayName);
122  vtkGetStringMacro(ProcessIdArrayName);
124 
126 
135  vtkSetStringMacro(CompositeIdArrayName);
136  vtkGetStringMacro(CompositeIdArrayName);
138 
140 
150  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::AddShaderReplacement")
151  void AddShaderReplacement(vtkShader::Type shaderType, // vertex, fragment, etc
152  const std::string& originalValue,
153  bool replaceFirst, // do this replacement before the default
154  const std::string& replacementValue, bool replaceAll);
155  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::ClearShaderReplacement")
156  void ClearShaderReplacement(vtkShader::Type shaderType, // vertex, fragment, etc
157  const std::string& originalValue, bool replaceFirst);
158  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::ClearAllShaderReplacements")
159  void ClearAllShaderReplacements(vtkShader::Type shaderType);
160  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::ClearAllShaderReplacements")
161  void ClearAllShaderReplacements();
163 
165 
173  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::SetVertexShaderCode")
174  virtual void SetVertexShaderCode(const char* code);
175  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::GetVertexShaderCode")
176  virtual char* GetVertexShaderCode();
177  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::SetFragmentShaderCode")
178  virtual void SetFragmentShaderCode(const char* code);
179  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::GetFragmentShaderCode")
180  virtual char* GetFragmentShaderCode();
181  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::SetGeometryShaderCode")
182  virtual void SetGeometryShaderCode(const char* code);
183  VTK_DEPRECATED_IN_9_0_0("Use vtkOpenGLShaderProperty::GetGeometryShaderCode")
184  virtual char* GetGeometryShaderCode();
186 
190  void ShallowCopy(vtkAbstractMapper* m) override;
191 
193  vtkGetObjectMacro(VBOs, vtkOpenGLVertexBufferObjectGroup);
194 
198  virtual void SetVBOShiftScaleMethod(int m);
199  virtual int GetVBOShiftScaleMethod() { return this->ShiftScaleMethod; }
200 
202  {
203  PrimitiveStart = 0,
204  PrimitivePoints = 0,
209  PrimitiveEnd
210  };
211 
223  void MapDataArrayToVertexAttribute(const char* vertexAttributeName, const char* dataArrayName,
224  int fieldAssociation, int componentno = -1) override;
225 
226  // This method will Map the specified data array for use as
227  // a texture coordinate for texture tname. The actual
228  // attribute will be named tname_coord so as to not
229  // conflict with the texture sampler definition which will
230  // be tname.
231  void MapDataArrayToMultiTextureAttribute(const char* tname, const char* dataArrayName,
232  int fieldAssociation, int componentno = -1) override;
233 
237  void RemoveVertexAttributeMapping(const char* vertexAttributeName) override;
238 
242  void RemoveAllVertexAttributeMappings() override;
243 
249  vtkHardwareSelector* sel, std::vector<unsigned int>& pixeloffsets, vtkProp* prop) override;
250 
251 protected:
253  ~vtkOpenGLPolyDataMapper() override;
254 
256 
257  void MapDataArray(const char* vertexAttributeName, const char* dataArrayName,
258  const char* texturename, int fieldAssociation, int componentno);
259 
260  // what coordinate should be used for this texture
261  std::string GetTextureCoordinateName(const char* tname);
262 
263  // handle updating shift scale based on pose changes
264  virtual void UpdateCameraShiftScale(vtkRenderer* ren, vtkActor* actor);
265 
269  void GetCoincidentParameters(vtkRenderer* ren, vtkActor* actor, float& factor, float& offset);
270 
276  void ComputeBounds() override;
277 
282  virtual void UpdateShaders(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
283 
287  virtual bool GetNeedToRebuildShaders(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
288 
292  virtual void BuildShaders(
293  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
294 
298  virtual void GetShaderTemplate(
299  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
300 
304  virtual void ReplaceShaderValues(
305  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
306 
308 
312  virtual void ReplaceShaderRenderPass(
313  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act, bool prePass);
314  virtual void ReplaceShaderCustomUniforms(
315  std::map<vtkShader::Type, vtkShader*> shaders, vtkActor* act);
316  virtual void ReplaceShaderColor(
317  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
318  virtual void ReplaceShaderEdges(
319  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
320  virtual void ReplaceShaderLight(
321  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
322  virtual void ReplaceShaderTCoord(
323  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
324  virtual void ReplaceShaderPicking(
325  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
326  virtual void ReplaceShaderPrimID(
327  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
328  virtual void ReplaceShaderNormal(
329  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
330  virtual void ReplaceShaderClip(
331  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
332  virtual void ReplaceShaderPositionVC(
333  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
334  virtual void ReplaceShaderCoincidentOffset(
335  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
336  virtual void ReplaceShaderDepth(
337  std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* ren, vtkActor* act);
339 
343  virtual void SetCustomUniforms(vtkOpenGLHelper& cellBO, vtkActor* actor);
344 
348  virtual void SetMapperShaderParameters(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
349 
353  virtual void SetLightingShaderParameters(
354  vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
355 
359  virtual void SetCameraShaderParameters(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
360 
364  virtual void SetPropertyShaderParameters(
365  vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act);
366 
370  virtual void UpdateBufferObjects(vtkRenderer* ren, vtkActor* act);
371 
375  virtual bool GetNeedToRebuildBufferObjects(vtkRenderer* ren, vtkActor* act);
376 
380  virtual void BuildBufferObjects(vtkRenderer* ren, vtkActor* act);
381 
385  virtual void BuildIBO(vtkRenderer* ren, vtkActor* act, vtkPolyData* poly);
386 
390  virtual void BuildSelectionIBO(
391  vtkPolyData* poly, std::vector<unsigned int> (&indices)[4], vtkIdType offset);
392 
396  virtual void BuildSelectionCache(const char* arrayName, bool selectingPoints, vtkPolyData* poly);
397 
398  // The VBO and its layout.
400 
401  // Structures for the various cell types we render.
402  vtkOpenGLHelper Primitives[PrimitiveEnd];
403  vtkOpenGLHelper SelectionPrimitives[PrimitiveEnd];
406  bool DrawingSelection = false;
408  vtkMTimeType SelectionTime = 0;
409 
410  std::map<std::tuple<unsigned int, unsigned int, vtkIdType>, std::vector<vtkIdType>>
413  bool SelectionCacheForPoints = false;
414  vtkMTimeType SelectionCacheTime = 0;
415  vtkPolyData* SelectionPolyData = nullptr;
416 
417  // do we have wide lines that require special handling
418  virtual bool HaveWideLines(vtkRenderer*, vtkActor*);
419 
420  // do we have textures that require special handling
421  virtual bool HaveTextures(vtkActor* actor);
422 
423  // how many textures do we have
424  virtual unsigned int GetNumberOfTextures(vtkActor* actor);
425 
426  // populate a vector with the textures we have
427  // the order is always
428  // ColorInternalTexture
429  // Actors texture
430  // Properties textures
431  virtual std::vector<std::pair<vtkTexture*, std::string>> GetTextures(vtkActor* actor);
432 
433  // do we have textures coordinates that require special handling
434  virtual bool HaveTCoords(vtkPolyData* poly);
435 
436  // values we use to determine if we need to rebuild shaders
437  std::map<const vtkOpenGLHelper*, int> LastLightComplexity;
438  std::map<const vtkOpenGLHelper*, int> LastLightCount;
439  std::map<const vtkOpenGLHelper*, vtkTimeStamp> LightComplexityChanged;
440 
443 
444  // Caches the vtkOpenGLRenderPass::RenderPasses() information.
445  // Note: Do not dereference the pointers held by this object. There is no
446  // guarantee that they are still valid!
448 
449  // Check the renderpasses in actor's property keys to see if they've changed
450  // render stages:
451  vtkMTimeType GetRenderPassStageMTime(vtkActor* actor);
452 
454  vtkTimeStamp VBOBuildTime; // When was the OpenGL VBO updated?
455  vtkStateStorage VBOBuildState; // used for determining when to rebuild the VBO
456  vtkStateStorage IBOBuildState; // used for determining whento rebuild the IBOs
458  vtkStateStorage TempState; // can be used to avoid constant allocs/deallocs
460 
463 
468  int ShiftScaleMethod; // for points
469 
470  // if set to true, tcoords will be passed to the
471  // VBO even if the mapper knows of no texture maps
472  // normally tcoords are only added to the VBO if the
473  // mapper has identified a texture map as well.
475 
476  virtual void BuildCellTextures(
477  vtkRenderer* ren, vtkActor*, vtkCellArray* prims[4], int representation);
478 
479  void AppendCellTextures(vtkRenderer* ren, vtkActor*, vtkCellArray* prims[4], int representation,
480  std::vector<unsigned char>& colors, std::vector<float>& normals, vtkPolyData* pd,
482 
489 
492  std::vector<unsigned char> EdgeValues;
493  virtual bool DrawingEdges(vtkRenderer*, vtkActor*);
494 
495  // additional picking indirection
500 
502  {
503  public:
508  };
509  std::map<std::string, ExtraAttributeValue> ExtraAttributes;
510 
511  // Store shader properties on this class by legacy shader replacement functions
512  // This should disappear when the functions are deprecated
513  // VTK_DEPRECATED_IN_9_0_0("legacy support functions")
514  vtkOpenGLShaderProperty* GetLegacyShaderProperty();
515  // VTK_DEPRECATED_IN_9_0_0("legacy support functions")
517 
519 
520  // are we currently drawing spheres/tubes
521  bool DrawingSpheres(vtkOpenGLHelper& cellBO, vtkActor* actor);
522  bool DrawingTubes(vtkOpenGLHelper& cellBO, vtkActor* actor);
523  bool DrawingTubesOrSpheres(vtkOpenGLHelper& cellBO, vtkActor* actor);
524 
525  // get which opengl mode to use to draw the primitive
526  int GetOpenGLMode(int representation, int primType);
527 
528  // get how big to make the points when doing point picking
529  // typically 2 for points, 4 for lines, 6 for surface
530  int GetPointPickingPrimitiveSize(int primType);
531 
532  // used to occasionally invoke timers
533  unsigned int TimerQueryCounter;
534 
535  // stores the mapping from vtk cells to gl_PrimitiveId
537 
538  // compute and set the maximum point and cell ID used in selection
539  virtual void UpdateMaximumPointCellIds(vtkRenderer* ren, vtkActor* actor);
540 
541  void AddPointIdsToSelectionPrimitives(vtkPolyData* poly, const char* arrayName,
542  unsigned int processId, unsigned int compositeIndex, vtkIdType selectedId);
543  void AddCellIdsToSelectionPrimitives(vtkPolyData* poly, const char* arrayName,
544  unsigned int processId, unsigned int compositeIndex, vtkIdType selectedId);
545 
546  vtkNew<vtkCellArray> SelectionArrays[4];
547 
548 private:
550  void operator=(const vtkOpenGLPolyDataMapper&) = delete;
551 };
552 
553 #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:499
vtkOpenGLPolyDataMapper::ForceTextureCoordinates
bool ForceTextureCoordinates
Definition: vtkOpenGLPolyDataMapper.h:474
vtkOpenGLPolyDataMapper::ExtraAttributeValue::DataArrayName
std::string DataArrayName
Definition: vtkOpenGLPolyDataMapper.h:504
vtkOpenGLPolyDataMapper::TempState
vtkStateStorage TempState
Definition: vtkOpenGLPolyDataMapper.h:458
vtkOpenGLPolyDataMapper::CellCellMap
vtkNew< vtkOpenGLCellToVTKCellMap > CellCellMap
Definition: vtkOpenGLPolyDataMapper.h:536
vtkOpenGLPolyDataMapper::UsingScalarColoring
bool UsingScalarColoring
Definition: vtkOpenGLPolyDataMapper.h:453
vtkPolyDataMapper::MapDataArrayToMultiTextureAttribute
virtual void MapDataArrayToMultiTextureAttribute(const char *textureName, const char *dataArrayName, int fieldAssociation, int componentno=-1)
vtkOpenGLPolyDataMapper::EdgeBuffer
vtkOpenGLBufferObject * EdgeBuffer
Definition: vtkOpenGLPolyDataMapper.h:491
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::SelectionCacheName
std::string SelectionCacheName
Definition: vtkOpenGLPolyDataMapper.h:412
vtkOpenGLPolyDataMapper::SetPopulateSelectionSettings
void SetPopulateSelectionSettings(int v)
Definition: vtkOpenGLPolyDataMapper.h:87
vtkIdType
int vtkIdType
Definition: vtkType.h:330
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::SelectionCache
std::map< std::tuple< unsigned int, unsigned int, vtkIdType >, std::vector< vtkIdType > > SelectionCache
Definition: vtkOpenGLPolyDataMapper.h:411
vtkOpenGLPolyDataMapper::VBOBuildState
vtkStateStorage VBOBuildState
Definition: vtkOpenGLPolyDataMapper.h:455
vtkOpenGLHelper.h
vtkSmartPointer< vtkOpenGLShaderProperty >
vtkOpenGLPolyDataMapper::PrimitiveIDOffset
int PrimitiveIDOffset
Definition: vtkOpenGLPolyDataMapper.h:462
vtkOpenGLPolyDataMapper::ShiftScaleMethod
int ShiftScaleMethod
Definition: vtkOpenGLPolyDataMapper.h:468
vtkOpenGLPolyDataMapper::ExtraAttributeValue::ComponentNumber
int ComponentNumber
Definition: vtkOpenGLPolyDataMapper.h:506
vtkOpenGLPolyDataMapper::IBOBuildState
vtkStateStorage IBOBuildState
Definition: vtkOpenGLPolyDataMapper.h:456
detail::Type
Type
Definition: TestQtCommon.h:18
vtkTransform
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:54
vtkOpenGLPolyDataMapper::VBOShiftScale
vtkNew< vtkMatrix4x4 > VBOShiftScale
Definition: vtkOpenGLPolyDataMapper.h:467
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
Definition: vtkOpenGLPolyDataMapper.h:205
vtkOpenGLPolyDataMapper::LastSelectionState
int LastSelectionState
Definition: vtkOpenGLPolyDataMapper.h:441
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:38
vtkOpenGLPolyDataMapper::LastLightComplexity
std::map< const vtkOpenGLHelper *, int > LastLightComplexity
Definition: vtkOpenGLPolyDataMapper.h:437
vtkOpenGLPolyDataMapper::CellNormalTexture
vtkTextureObject * CellNormalTexture
Definition: vtkOpenGLPolyDataMapper.h:486
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:439
vtkOpenGLPolyDataMapper::LastBoundBO
vtkOpenGLHelper * LastBoundBO
Definition: vtkOpenGLPolyDataMapper.h:404
vtkTexture
handles properties associated with a texture map
Definition: vtkTexture.h:65
vtkOpenGLPolyDataMapper::ExtraAttributes
std::map< std::string, ExtraAttributeValue > ExtraAttributes
Definition: vtkOpenGLPolyDataMapper.h:509
vtkOpenGLPolyDataMapper::VBOBuildTime
vtkTimeStamp VBOBuildTime
Definition: vtkOpenGLPolyDataMapper.h:454
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:471
vtkOpenGLPolyDataMapper::CurrentInput
vtkPolyData * CurrentInput
Definition: vtkOpenGLPolyDataMapper.h:100
vtkOpenGLPolyDataMapper::CellNormalBuffer
vtkOpenGLBufferObject * CellNormalBuffer
Definition: vtkOpenGLPolyDataMapper.h:487
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:501
vtkCellArray
object to represent cell connectivity
Definition: vtkCellArray.h:180
VTK_DEPRECATED_IN_9_0_0
#define VTK_DEPRECATED_IN_9_0_0(reason)
Definition: vtkDeprecation.h:83
vtkOpenGLPolyDataMapper::SelectionType
int SelectionType
Definition: vtkOpenGLPolyDataMapper.h:407
vtkOpenGLPolyDataMapper::HaveCellNormals
bool HaveCellNormals
Definition: vtkOpenGLPolyDataMapper.h:488
vtkShader
Vertex or Fragment shader, combined into a ShaderProgram.
Definition: vtkShader.h:37
vtkOpenGLPolyDataMapper::HaveCellScalars
bool HaveCellScalars
Definition: vtkOpenGLPolyDataMapper.h:485
vtkOpenGLPolyDataMapper::ResourceCallback
vtkGenericOpenGLResourceFreeCallback * ResourceCallback
Definition: vtkOpenGLPolyDataMapper.h:255
vtkOpenGLPolyDataMapper::VBOInverseTransform
vtkNew< vtkTransform > VBOInverseTransform
Definition: vtkOpenGLPolyDataMapper.h:466
vtkOpenGLVertexBufferObject
Definition: vtkOpenGLVertexBufferObject.h:40
vtkNew< vtkInformation >
vtkOpenGLPolyDataMapper::PopulateSelectionSettings
int PopulateSelectionSettings
Definition: vtkOpenGLPolyDataMapper.h:461
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:95
vtkMapper::ReleaseGraphicsResources
void ReleaseGraphicsResources(vtkWindow *) override
Release any graphics resources that are being consumed by this mapper.
Definition: vtkMapper.h:109
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:56
vtkX3D::string
Definition: vtkX3D.h:496
vtkOpenGLPolyDataMapper::PrimitiveTris
Definition: vtkOpenGLPolyDataMapper.h:206
vtkOpenGLPolyDataMapper::TempMatrix4
vtkMatrix4x4 * TempMatrix4
Definition: vtkOpenGLPolyDataMapper.h:464
vtkOpenGLPolyDataMapper::VBOs
vtkOpenGLVertexBufferObjectGroup * VBOs
Definition: vtkOpenGLPolyDataMapper.h:399
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.
vtkDeprecation.h
vtkOpenGLPolyDataMapper::TimerQuery
vtkOpenGLRenderTimer * TimerQuery
Definition: vtkOpenGLPolyDataMapper.h:518
vtkOpenGLPolyDataMapper::InternalColorTexture
vtkOpenGLTexture * InternalColorTexture
Definition: vtkOpenGLPolyDataMapper.h:459
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:67
vtkOpenGLPolyDataMapper::ExtraAttributeValue::TextureName
std::string TextureName
Definition: vtkOpenGLPolyDataMapper.h:507
vtkOpenGLPolyDataMapper::LastRenderPassInfo
vtkNew< vtkInformation > LastRenderPassInfo
Definition: vtkOpenGLPolyDataMapper.h:447
vtkOpenGLPolyDataMapper::TimerQueryCounter
unsigned int TimerQueryCounter
Definition: vtkOpenGLPolyDataMapper.h:533
vtkOpenGLPolyDataMapper::CellTextureBuildState
vtkStateStorage CellTextureBuildState
Definition: vtkOpenGLPolyDataMapper.h:457
vtkPolyData
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:85
vtkOpenGLPolyDataMapper::PrimitiveTypes
PrimitiveTypes
Definition: vtkOpenGLPolyDataMapper.h:201
vtkPolyDataMapper::ComputeBounds
virtual void ComputeBounds()
Called in GetBounds().
vtkPolyDataMapper.h
vtkOpenGLPolyDataMapper::PrimitiveVertices
Definition: vtkOpenGLPolyDataMapper.h:208
vtkOpenGLPolyDataMapper::PointIdArrayName
char * PointIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:496
vtkOpenGLPolyDataMapper::PrimitiveTriStrips
Definition: vtkOpenGLPolyDataMapper.h:207
vtkOpenGLTexture
OpenGL texture map.
Definition: vtkOpenGLTexture.h:33
vtkOpenGLPolyDataMapper::CellIdArrayName
char * CellIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:497
vtkOpenGLPolyDataMapper::TempMatrix3
vtkMatrix3x3 * TempMatrix3
Definition: vtkOpenGLPolyDataMapper.h:465
vtkOpenGLPolyDataMapper::DrawingVertices
bool DrawingVertices
Definition: vtkOpenGLPolyDataMapper.h:405
vtkOpenGLPolyDataMapper::EdgeValues
std::vector< unsigned char > EdgeValues
Definition: vtkOpenGLPolyDataMapper.h:492
vtkOpenGLPolyDataMapper
PolyDataMapper using OpenGL to render.
Definition: vtkOpenGLPolyDataMapper.h:58
vtkOpenGLPolyDataMapper::ProcessIdArrayName
char * ProcessIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:498
vtkOpenGLPolyDataMapper::CellScalarBuffer
vtkOpenGLBufferObject * CellScalarBuffer
Definition: vtkOpenGLPolyDataMapper.h:484
vtkOpenGLPolyDataMapper::LegacyShaderProperty
vtkSmartPointer< vtkOpenGLShaderProperty > LegacyShaderProperty
Definition: vtkOpenGLPolyDataMapper.h:516
vtkOpenGLPolyDataMapper::ExtraAttributeValue::FieldAssociation
int FieldAssociation
Definition: vtkOpenGLPolyDataMapper.h:505
vtkOpenGLPolyDataMapper::SelectionStateChanged
vtkTimeStamp SelectionStateChanged
Definition: vtkOpenGLPolyDataMapper.h:442
vtkOpenGLPolyDataMapper::LastLightCount
std::map< const vtkOpenGLHelper *, int > LastLightCount
Definition: vtkOpenGLPolyDataMapper.h:438
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:483
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:285
vtkOpenGLPolyDataMapper::EdgeTexture
vtkTextureObject * EdgeTexture
Definition: vtkOpenGLPolyDataMapper.h:490