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 =========================================================================*/
24 #ifndef vtkOpenGLPolyDataMapper_h
25 #define vtkOpenGLPolyDataMapper_h
26 
27 #include "vtkNew.h" // For vtkNew
28 #include "vtkRenderingOpenGL2Module.h" // For export macro
29 #include "vtkNew.h" // for ivars
30 #include "vtkPolyDataMapper.h"
31 #include "vtkShader.h" // for methods
32 #include "vtkOpenGLHelper.h" // used for ivars
33 #include "vtkStateStorage.h" // used for ivars
34 
35 #include <vector> //for ivars
36 #include <map> //for methods
37 
38 class vtkCellArray;
40 class vtkMatrix4x4;
41 class vtkMatrix3x3;
43 class vtkOpenGLTexture;
47 class vtkPoints;
48 class vtkTexture;
49 class vtkTextureObject;
50 class vtkTransform;
51 
52 
53 class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLPolyDataMapper : public vtkPolyDataMapper
54 {
55 public:
58  void PrintSelf(ostream& os, vtkIndent indent) override;
59 
63  void RenderPiece(vtkRenderer *ren, vtkActor *act) override;
64 
66 
69  virtual void RenderPieceStart(vtkRenderer *ren, vtkActor *act);
70  virtual void RenderPieceDraw(vtkRenderer *ren, vtkActor *act);
71  virtual void RenderPieceFinish(vtkRenderer *ren, vtkActor *act);
73 
79  void ReleaseGraphicsResources(vtkWindow *) override;
80 
81  vtkGetMacro(PopulateSelectionSettings,int);
82  void SetPopulateSelectionSettings(int v) { this->PopulateSelectionSettings = v; };
83 
90  bool GetSupportsSelection() override { return true; }
91 
102  bool GetIsOpaque() override;
103 
104  // used by RenderPiece and functions it calls to reduce
105  // calls to get the input and allow for rendering of
106  // other polydata (not the input)
108 
110 
116  vtkSetStringMacro(PointIdArrayName);
117  vtkGetStringMacro(PointIdArrayName);
118  vtkSetStringMacro(CellIdArrayName);
119  vtkGetStringMacro(CellIdArrayName);
121 
123 
128  vtkSetStringMacro(ProcessIdArrayName);
129  vtkGetStringMacro(ProcessIdArrayName);
131 
133 
142  vtkSetStringMacro(CompositeIdArrayName);
143  vtkGetStringMacro(CompositeIdArrayName);
145 
146 
148 
156  vtkShader::Type shaderType, // vertex, fragment, etc
157  const std::string& originalValue,
158  bool replaceFirst, // do this replacement before the default
159  const std::string& replacementValue,
160  bool replaceAll);
162  vtkShader::Type shaderType, // vertex, fragment, etc
163  const std::string& originalValue,
164  bool replaceFirst);
168 
170 
176  vtkSetStringMacro(VertexShaderCode);
177  vtkGetStringMacro(VertexShaderCode);
178  vtkSetStringMacro(FragmentShaderCode);
179  vtkGetStringMacro(FragmentShaderCode);
180  vtkSetStringMacro(GeometryShaderCode);
181  vtkGetStringMacro(GeometryShaderCode);
183 
184  // the following is all extra stuff to work around the
185  // fact that gl_PrimitiveID does not work correctly on
186  // Apple Macs with AMD graphics hardware (before macOS 10.11).
187  // See <rdar://20747550>.
189  vtkPolyData *poly,
190  std::vector<float> &buffData);
191 
195  void ShallowCopy(vtkAbstractMapper *m) override;
196 
198 
202  {
203  this->HaveAppleBugForce = 1;
204  this->Modified();
205  }
207  {
208  this->HaveAppleBugForce = 2;
209  this->Modified();
210  }
212 
216  bool GetHaveAppleBug() { return this->HaveAppleBug; }
217 
219  vtkGetObjectMacro(VBOs, vtkOpenGLVertexBufferObjectGroup);
220 
225 
227  PrimitiveStart = 0,
228  PrimitivePoints = 0,
235  PrimitiveEnd
236  };
237 
239  bool HaveAppleBug,
240  vtkPolyData *poly,
241  vtkCellArray **prims, int representation,
242  vtkPoints *points);
243 
247  static void MakeCellCellMap(
248  std::vector<vtkIdType> &cellCellMap,
249  bool HaveAppleBug,
250  vtkPolyData *poly,
251  vtkCellArray **prims, int representation,
252  vtkPoints *points);
253 
266  const char* vertexAttributeName,
267  const char* dataArrayName,
268  int fieldAssociation,
269  int componentno = -1) override;
270 
271  // This method will Map the specified data array for use as
272  // a texture coordinate for texture tname. The actual
273  // attribute will be named tname_coord so as to not
274  // conflict with the texture sampler definition which will
275  // be tname.
277  const char *tname,
278  const char* dataArrayName, int fieldAssociation, int componentno = -1) override;
279 
283  void RemoveVertexAttributeMapping(const char* vertexAttributeName) override;
284 
289 
295  std::vector<unsigned int> &pixeloffsets,
296  vtkProp *prop) override;
297 
298 protected:
301 
303 
305  const char* vertexAttributeName,
306  const char* dataArrayName,
307  const char *texturename,
308  int fieldAssociation,
309  int componentno);
310 
311  // what coordinate should be used for this texture
313 
314  // the following is all extra stuff to work around the
315  // fact that gl_PrimitiveID does not work correctly on
316  // Apple Macs with AMD graphics hardware (before macOS 10.11).
317  // See <rdar://20747550>.
319  int HaveAppleBugForce; // 0 = default 1 = 0ff 2 = on
320  std::vector<float> AppleBugPrimIDs;
322 
327  vtkRenderer *ren, vtkActor *actor, float &factor, float &offset);
328 
334  void ComputeBounds() override;
335 
340  virtual void UpdateShaders(
341  vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act);
342 
347  vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act);
348 
352  virtual void BuildShaders(
353  std::map<vtkShader::Type, vtkShader *> shaders,
354  vtkRenderer *ren, vtkActor *act);
355 
359  virtual void GetShaderTemplate(
360  std::map<vtkShader::Type, vtkShader *> shaders,
361  vtkRenderer *ren, vtkActor *act);
362 
366  virtual void ReplaceShaderValues(
367  std::map<vtkShader::Type, vtkShader *> shaders,
368  vtkRenderer *ren, vtkActor *act);
369 
371 
376  std::map<vtkShader::Type, vtkShader *> shaders,
377  vtkRenderer *ren, vtkActor *act, bool prePass);
378  virtual void ReplaceShaderColor(
379  std::map<vtkShader::Type, vtkShader *> shaders,
380  vtkRenderer *ren, vtkActor *act);
381  virtual void ReplaceShaderLight(
382  std::map<vtkShader::Type, vtkShader *> shaders,
383  vtkRenderer *ren, vtkActor *act);
384  virtual void ReplaceShaderTCoord(
385  std::map<vtkShader::Type, vtkShader *> shaders,
386  vtkRenderer *ren, vtkActor *act);
387  virtual void ReplaceShaderPicking(
388  std::map<vtkShader::Type, vtkShader *> shaders,
389  vtkRenderer *ren, vtkActor *act);
390  virtual void ReplaceShaderPrimID(
391  std::map<vtkShader::Type, vtkShader *> shaders,
392  vtkRenderer *ren, vtkActor *act);
393  virtual void ReplaceShaderNormal(
394  std::map<vtkShader::Type, vtkShader *> shaders,
395  vtkRenderer *ren, vtkActor *act);
396  virtual void ReplaceShaderClip(
397  std::map<vtkShader::Type, vtkShader *> shaders,
398  vtkRenderer *ren, vtkActor *act);
400  std::map<vtkShader::Type, vtkShader *> shaders,
401  vtkRenderer *ren, vtkActor *act);
403  std::map<vtkShader::Type, vtkShader *> shaders,
404  vtkRenderer *ren, vtkActor *act);
405  virtual void ReplaceShaderDepth(
406  std::map<vtkShader::Type, vtkShader *> shaders,
407  vtkRenderer *ren, vtkActor *act);
409 
414 
419 
424 
429 
433  virtual void UpdateBufferObjects(vtkRenderer *ren, vtkActor *act);
434 
439 
443  virtual void BuildBufferObjects(vtkRenderer *ren, vtkActor *act);
444 
448  virtual void BuildIBO(vtkRenderer *ren, vtkActor *act, vtkPolyData *poly);
449 
450  // The VBO and its layout.
452 
453  // Structures for the various cell types we render.
454  vtkOpenGLHelper Primitives[PrimitiveEnd];
457 
458  // do we have wide lines that require special handling
459  virtual bool HaveWideLines(vtkRenderer *, vtkActor *);
460 
461  // do we have textures that require special handling
462  virtual bool HaveTextures(vtkActor *actor);
463 
464  // how many textures do we have
465  virtual unsigned int GetNumberOfTextures(vtkActor *actor);
466 
467  // populate a vector with the textures we have
468  // the order is always
469  // ColorInternalTexture
470  // Actors texture
471  // Properties textures
472  virtual std::vector<std::pair<vtkTexture *, std::string> > GetTextures(vtkActor *actor);
473 
474  // do we have textures coordinates that require special handling
475  virtual bool HaveTCoords(vtkPolyData *poly);
476 
477  // values we use to determine if we need to rebuild shaders
478  std::map<const vtkOpenGLHelper *, int> LastLightComplexity;
479  std::map<const vtkOpenGLHelper *, int> LastLightCount;
480  std::map<const vtkOpenGLHelper *, vtkTimeStamp> LightComplexityChanged;
481 
484 
485  // Caches the vtkOpenGLRenderPass::RenderPasses() information.
486  // Note: Do not dereference the pointers held by this object. There is no
487  // guarantee that they are still valid!
489 
490  // Check the renderpasses in actor's property keys to see if they've changed
491  // render stages:
493 
495  vtkTimeStamp VBOBuildTime; // When was the OpenGL VBO updated?
496  vtkStateStorage VBOBuildState; // used for determining when to rebuild the VBO
497  vtkStateStorage IBOBuildState; // used for determining whento rebuild the IBOs
499  vtkStateStorage TempState; // can be used to avoid constant allocs/deallocs
501 
504 
509  int ShiftScaleMethod; // for points
510 
511  // if set to true, tcoords will be passed to the
512  // VBO even if the mapper knows of no texture maps
513  // normally tcoords are only added to the VBO if the
514  // mapper has identified a texture map as well.
516 
517  virtual void BuildCellTextures(
518  vtkRenderer *ren,
519  vtkActor *,
520  vtkCellArray *prims[4],
521  int representation);
522 
524  vtkRenderer *ren,
525  vtkActor *,
526  vtkCellArray *prims[4],
527  int representation,
528  std::vector<unsigned char> &colors,
529  std::vector<float> &normals,
530  vtkPolyData *pd);
531 
538 
539  // additional picking indirection
544 
545  std::map<const vtkShader::ReplacementSpec, vtkShader::ReplacementValue>
547 
549  {
550  public:
555  };
556  std::map<std::string,ExtraAttributeValue> ExtraAttributes;
557 
562 
563  // are we currently drawing spheres/tubes
564  bool DrawingSpheres(vtkOpenGLHelper &cellBO, vtkActor *actor);
565  bool DrawingTubes(vtkOpenGLHelper &cellBO, vtkActor *actor);
567 
568  // get which opengl mode to use to draw the primitive
569  int GetOpenGLMode(int representation, int primType);
570 
571  // get how big to make the points when doing point picking
572  // typically 2 for points, 4 for lines, 6 for surface
573  int GetPointPickingPrimitiveSize(int primType);
574 
575  // used to occasionally invoke timers
576  unsigned int TimerQueryCounter;
577 
578  // stores the mapping from vtk cells to gl_PrimitiveId
579  std::vector<vtkIdType> CellCellMap;
580  std::vector<vtkIdType> PointCellMap;
582 
583  // compute and set the maximum point and cell ID used in selection
584  virtual void UpdateMaximumPointCellIds(vtkRenderer* ren, vtkActor *actor);
585 
586 private:
588  void operator=(const vtkOpenGLPolyDataMapper&) = delete;
589 };
590 
591 #endif
vtkPolyDataMapper
map vtkPolyData to graphics primitives
Definition: vtkPolyDataMapper.h:43
vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:40
vtkOpenGLPolyDataMapper::BuildBufferObjects
virtual void BuildBufferObjects(vtkRenderer *ren, vtkActor *act)
Build the VBO/IBO, called by UpdateBufferObjects.
vtkOpenGLPolyDataMapper::GetHaveAppleBug
bool GetHaveAppleBug()
Get the value of HaveAppleBug.
Definition: vtkOpenGLPolyDataMapper.h:216
vtkOpenGLPolyDataMapper::GetTextures
virtual std::vector< std::pair< vtkTexture *, std::string > > GetTextures(vtkActor *actor)
vtkOpenGLPolyDataMapper::CompositeIdArrayName
char * CompositeIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:543
vtkOpenGLPolyDataMapper::ForceTextureCoordinates
bool ForceTextureCoordinates
Definition: vtkOpenGLPolyDataMapper.h:515
vtkOpenGLPolyDataMapper::MakeCellCellMap
static void MakeCellCellMap(std::vector< vtkIdType > &cellCellMap, bool HaveAppleBug, vtkPolyData *poly, vtkCellArray **prims, int representation, vtkPoints *points)
Get access to the map of glprim to vtkcell ids.
vtkOpenGLPolyDataMapper::ExtraAttributeValue::DataArrayName
std::string DataArrayName
Definition: vtkOpenGLPolyDataMapper.h:551
vtkOpenGLPolyDataMapper::TempState
vtkStateStorage TempState
Definition: vtkOpenGLPolyDataMapper.h:499
vtkOpenGLPolyDataMapper::UsingScalarColoring
bool UsingScalarColoring
Definition: vtkOpenGLPolyDataMapper.h:494
vtkOpenGLPolyDataMapper::GetOpenGLMode
int GetOpenGLMode(int representation, int primType)
vtkOpenGLPolyDataMapper::BuildCellTextures
virtual void BuildCellTextures(vtkRenderer *ren, vtkActor *, vtkCellArray *prims[4], int representation)
vtkStateStorage
Class to make storing and comparing state quick and easy.
Definition: vtkStateStorage.h:58
vtkOpenGLBufferObject
OpenGL buffer object.
Definition: vtkOpenGLBufferObject.h:34
vtkShader.h
vtkOpenGLPolyDataMapper::DrawingSpheres
bool DrawingSpheres(vtkOpenGLHelper &cellBO, vtkActor *actor)
vtkOpenGLPolyDataMapper::ReplaceShaderRenderPass
virtual void ReplaceShaderRenderPass(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act, bool prePass)
Perform string replacements on the shader templates, called from ReplaceShaderValues.
vtkOpenGLPolyDataMapper::ReplaceShaderValues
virtual void ReplaceShaderValues(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
Perform string replacements on the shader templates.
vtkOpenGLPolyDataMapper::UpdateShaders
virtual void UpdateShaders(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act)
Make sure appropriate shaders are defined, compiled and bound.
vtkOpenGLPolyDataMapper::ReplaceShaderLight
virtual void ReplaceShaderLight(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkOpenGLPolyDataMapper::CellMapsBuildString
std::string CellMapsBuildString
Definition: vtkOpenGLPolyDataMapper.h:581
vtkOpenGLPolyDataMapper::RemoveAllVertexAttributeMappings
void RemoveAllVertexAttributeMappings() override
Remove all vertex attributes.
vtkOpenGLPolyDataMapper::BuildIBO
virtual void BuildIBO(vtkRenderer *ren, vtkActor *act, vtkPolyData *poly)
Build the IBO, called by BuildBufferObjects.
vtkStateStorage.h
vtkOpenGLPolyDataMapper::UpdateMaximumPointCellIds
virtual void UpdateMaximumPointCellIds(vtkRenderer *ren, vtkActor *actor)
vtkOpenGLPolyDataMapper::VertexShaderCode
char * VertexShaderCode
Definition: vtkOpenGLPolyDataMapper.h:558
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:36
vtkOpenGLPolyDataMapper::SetVBOShiftScaleMethod
void SetVBOShiftScaleMethod(int m)
A convenience method for enabling/disabling the VBO's shift+scale transform.
vtkOpenGLPolyDataMapper::CellCellMap
std::vector< vtkIdType > CellCellMap
Definition: vtkOpenGLPolyDataMapper.h:579
vtkOpenGLPolyDataMapper::LastLightCount
std::map< const vtkOpenGLHelper *, int > LastLightCount
Definition: vtkOpenGLPolyDataMapper.h:479
vtkOpenGLPolyDataMapper::VBOBuildState
vtkStateStorage VBOBuildState
Definition: vtkOpenGLPolyDataMapper.h:496
vtkOpenGLHelper.h
vtkObject::Modified
virtual void Modified()
Update the modification time for this object.
vtkOpenGLPolyDataMapper::AppleBugPrimIDs
std::vector< float > AppleBugPrimIDs
Definition: vtkOpenGLPolyDataMapper.h:320
vtkOpenGLPolyDataMapper::GetNeedToRebuildBufferObjects
virtual bool GetNeedToRebuildBufferObjects(vtkRenderer *ren, vtkActor *act)
Does the VBO/IBO need to be rebuilt.
vtkOpenGLPolyDataMapper::New
static vtkOpenGLPolyDataMapper * New()
vtkOpenGLPolyDataMapper::RemoveVertexAttributeMapping
void RemoveVertexAttributeMapping(const char *vertexAttributeName) override
Remove a vertex attribute mapping.
vtkOpenGLPolyDataMapper::PrimitiveIDOffset
int PrimitiveIDOffset
Definition: vtkOpenGLPolyDataMapper.h:503
vtkOpenGLPolyDataMapper::ShiftScaleMethod
int ShiftScaleMethod
Definition: vtkOpenGLPolyDataMapper.h:509
vtkOpenGLPolyDataMapper::ExtraAttributeValue::ComponentNumber
int ComponentNumber
Definition: vtkOpenGLPolyDataMapper.h:553
vtkOpenGLPolyDataMapper::IBOBuildState
vtkStateStorage IBOBuildState
Definition: vtkOpenGLPolyDataMapper.h:497
vtkOpenGLPolyDataMapper::ExtraAttributes
std::map< std::string, ExtraAttributeValue > ExtraAttributes
Definition: vtkOpenGLPolyDataMapper.h:556
vtkOpenGLPolyDataMapper::ReplaceShaderPositionVC
virtual void ReplaceShaderPositionVC(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkOpenGLPolyDataMapper::PrimitiveTriStripsEdges
@ PrimitiveTriStripsEdges
Definition: vtkOpenGLPolyDataMapper.h:233
vtkTransform
describes linear transformations via a 4x4 matrix
Definition: vtkTransform.h:61
vtkOpenGLPolyDataMapper::GetRenderPassStageMTime
vtkMTimeType GetRenderPassStageMTime(vtkActor *actor)
vtkOpenGLPolyDataMapper::VBOShiftScale
vtkNew< vtkMatrix4x4 > VBOShiftScale
Definition: vtkOpenGLPolyDataMapper.h:508
vtkOpenGLPolyDataMapper::SetLightingShaderParameters
virtual void SetLightingShaderParameters(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act)
Set the shader parameteres related to lighting, called by UpdateShader.
vtkOpenGLPolyDataMapper::DrawingTubes
bool DrawingTubes(vtkOpenGLHelper &cellBO, vtkActor *actor)
vtkMatrix3x3
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:37
vtkOpenGLPolyDataMapper::~vtkOpenGLPolyDataMapper
~vtkOpenGLPolyDataMapper() override
vtkOpenGLPolyDataMapper::PrimitiveLines
@ PrimitiveLines
Definition: vtkOpenGLPolyDataMapper.h:229
vtkOpenGLPolyDataMapper::BuildShaders
virtual void BuildShaders(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
Build the shader source code, called by UpdateShader.
vtkOpenGLPolyDataMapper::GetShaderTemplate
virtual void GetShaderTemplate(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
Create the basic shaders before replacement.
vtkOpenGLPolyDataMapper::MapDataArrayToVertexAttribute
void MapDataArrayToVertexAttribute(const char *vertexAttributeName, const char *dataArrayName, int fieldAssociation, int componentno=-1) override
Select a data array from the point/cell data and map it to a generic vertex attribute.
vtkOpenGLPolyDataMapper::LastSelectionState
int LastSelectionState
Definition: vtkOpenGLPolyDataMapper.h:482
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:38
vtkOpenGLPolyDataMapper::HaveTextures
virtual bool HaveTextures(vtkActor *actor)
vtkOpenGLPolyDataMapper::GetTextureCoordinateName
std::string GetTextureCoordinateName(const char *tname)
vtkOpenGLPolyDataMapper::ReplaceShaderClip
virtual void ReplaceShaderClip(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkOpenGLPolyDataMapper::ClearAllShaderReplacements
void ClearAllShaderReplacements(vtkShader::Type shaderType)
vtkOpenGLPolyDataMapper::CellNormalTexture
vtkTextureObject * CellNormalTexture
Definition: vtkOpenGLPolyDataMapper.h:535
vtkOpenGLRenderTimer
Asynchronously measures GPU execution time for a single event.
Definition: vtkOpenGLRenderTimer.h:38
vtkX3D::points
@ points
Definition: vtkX3D.h:446
vtkOpenGLPolyDataMapper::LastBoundBO
vtkOpenGLHelper * LastBoundBO
Definition: vtkOpenGLPolyDataMapper.h:455
vtkTexture
handles properties associated with a texture map
Definition: vtkTexture.h:72
vtkOpenGLPolyDataMapper::LastLightComplexity
std::map< const vtkOpenGLHelper *, int > LastLightComplexity
Definition: vtkOpenGLPolyDataMapper.h:478
vtkOpenGLPolyDataMapper::SetPropertyShaderParameters
virtual void SetPropertyShaderParameters(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act)
Set the shader parameteres related to the property, called by UpdateShader.
vtkOpenGLPolyDataMapper::FragmentShaderCode
char * FragmentShaderCode
Definition: vtkOpenGLPolyDataMapper.h:559
vtkOpenGLPolyDataMapper::ReplaceShaderPicking
virtual void ReplaceShaderPicking(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkOpenGLPolyDataMapper::UpdateBufferObjects
virtual void UpdateBufferObjects(vtkRenderer *ren, vtkActor *act)
Update the VBO/IBO to be current.
vtkOpenGLPolyDataMapper::VBOBuildTime
vtkTimeStamp VBOBuildTime
Definition: vtkOpenGLPolyDataMapper.h:495
vtkOpenGLVertexBufferObjectGroup
manage vertex buffer objects shared within a mapper
Definition: vtkOpenGLVertexBufferObjectGroup.h:77
vtkX3D::offset
@ offset
Definition: vtkX3D.h:438
vtkOpenGLPolyDataMapper::ClearShaderReplacement
void ClearShaderReplacement(vtkShader::Type shaderType, const std::string &originalValue, bool replaceFirst)
vtkOpenGLPolyDataMapper::CurrentInput
vtkPolyData * CurrentInput
Definition: vtkOpenGLPolyDataMapper.h:107
vtkOpenGLPolyDataMapper::GeometryShaderCode
char * GeometryShaderCode
Definition: vtkOpenGLPolyDataMapper.h:560
vtkOpenGLPolyDataMapper::CellNormalBuffer
vtkOpenGLBufferObject * CellNormalBuffer
Definition: vtkOpenGLPolyDataMapper.h:536
vtkOpenGLPolyDataMapper::HaveAppleBugForce
int HaveAppleBugForce
Definition: vtkOpenGLPolyDataMapper.h:319
vtkHardwareSelector
Definition: vtkHardwareSelector.h:124
vtkGenericOpenGLResourceFreeCallback
Definition: vtkOpenGLResourceFreeCallback.h:26
vtkOpenGLHelper
Definition: vtkOpenGLHelper.h:31
vtkOpenGLPolyDataMapper::GetIsOpaque
bool GetIsOpaque() override
Returns if the mapper does not expect to have translucent geometry.
vtkOpenGLPolyDataMapper::GetPointPickingPrimitiveSize
int GetPointPickingPrimitiveSize(int primType)
vtkActor
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:52
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:40
vtkTextureObject
abstracts an OpenGL texture object.
Definition: vtkTextureObject.h:45
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:42
vtkOpenGLPolyDataMapper::UserShaderReplacements
std::map< const vtkShader::ReplacementSpec, vtkShader::ReplacementValue > UserShaderReplacements
Definition: vtkOpenGLPolyDataMapper.h:546
vtkOpenGLPolyDataMapper::ReplaceShaderDepth
virtual void ReplaceShaderDepth(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkOpenGLPolyDataMapper::ExtraAttributeValue
Definition: vtkOpenGLPolyDataMapper.h:549
vtkOpenGLPolyDataMapper::DrawingEdgesOrVertices
bool DrawingEdgesOrVertices
Definition: vtkOpenGLPolyDataMapper.h:456
vtkOpenGLPolyDataMapper::PointCellMap
std::vector< vtkIdType > PointCellMap
Definition: vtkOpenGLPolyDataMapper.h:580
vtkOpenGLPolyDataMapper::SetCameraShaderParameters
virtual void SetCameraShaderParameters(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act)
Set the shader parameteres related to the Camera, called by UpdateShader.
vtkCellArray
object to represent cell connectivity
Definition: vtkCellArray.h:51
vtkShader::Type
Type
Available shader types.
Definition: vtkShader.h:49
vtkOpenGLPolyDataMapper::GetCoincidentParameters
void GetCoincidentParameters(vtkRenderer *ren, vtkActor *actor, float &factor, float &offset)
helper function to get the appropriate coincident params
vtkOpenGLPolyDataMapper::HaveCellNormals
bool HaveCellNormals
Definition: vtkOpenGLPolyDataMapper.h:537
vtkOpenGLPolyDataMapper::HaveWideLines
virtual bool HaveWideLines(vtkRenderer *, vtkActor *)
vtkOpenGLPolyDataMapper::HaveCellScalars
bool HaveCellScalars
Definition: vtkOpenGLPolyDataMapper.h:534
vtkOpenGLPolyDataMapper::ResourceCallback
vtkGenericOpenGLResourceFreeCallback * ResourceCallback
Definition: vtkOpenGLPolyDataMapper.h:302
vtkOpenGLPolyDataMapper::VBOInverseTransform
vtkNew< vtkTransform > VBOInverseTransform
Definition: vtkOpenGLPolyDataMapper.h:507
vtkOpenGLVertexBufferObject
Definition: vtkOpenGLVertexBufferObject.h:40
vtkNew< vtkInformation >
vtkOpenGLPolyDataMapper::PopulateSelectionSettings
int PopulateSelectionSettings
Definition: vtkOpenGLPolyDataMapper.h:502
vtkOpenGLPolyDataMapper::PrimitiveTrisEdges
@ PrimitiveTrisEdges
Definition: vtkOpenGLPolyDataMapper.h:232
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:90
vtkOpenGLPolyDataMapper::ReplaceShaderTCoord
virtual void ReplaceShaderTCoord(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkOpenGLPolyDataMapper::HandleAppleBug
static vtkPolyData * HandleAppleBug(vtkPolyData *poly, std::vector< float > &buffData)
vtkOpenGLPolyDataMapper::HaveTCoords
virtual bool HaveTCoords(vtkPolyData *poly)
vtkOpenGLPolyDataMapper::ReplaceShaderNormal
virtual void ReplaceShaderNormal(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkOpenGLPolyDataMapper::LightComplexityChanged
std::map< const vtkOpenGLHelper *, vtkTimeStamp > LightComplexityChanged
Definition: vtkOpenGLPolyDataMapper.h:480
vtkOpenGLPolyDataMapper::vtkOpenGLPolyDataMapper
vtkOpenGLPolyDataMapper()
vtkProp
abstract superclass for all actors, volumes and annotations
Definition: vtkProp.h:53
vtkOpenGLPolyDataMapper::ShallowCopy
void ShallowCopy(vtkAbstractMapper *m) override
Make a shallow copy of this mapper.
vtkX3D::string
@ string
Definition: vtkX3D.h:490
vtkOpenGLPolyDataMapper::PrimitiveTris
@ PrimitiveTris
Definition: vtkOpenGLPolyDataMapper.h:230
vtkOpenGLPolyDataMapper::MapDataArrayToMultiTextureAttribute
void MapDataArrayToMultiTextureAttribute(const char *tname, const char *dataArrayName, int fieldAssociation, int componentno=-1) override
vtkOpenGLPolyDataMapper::TempMatrix4
vtkMatrix4x4 * TempMatrix4
Definition: vtkOpenGLPolyDataMapper.h:505
vtkOpenGLPolyDataMapper::ClearAllShaderReplacements
void ClearAllShaderReplacements()
vtkOpenGLPolyDataMapper::VBOs
vtkOpenGLVertexBufferObjectGroup * VBOs
Definition: vtkOpenGLPolyDataMapper.h:451
vtkOpenGLPolyDataMapper::UpdateCellMaps
void UpdateCellMaps(bool HaveAppleBug, vtkPolyData *poly, vtkCellArray **prims, int representation, vtkPoints *points)
vtkNew.h
vtkOpenGLPolyDataMapper::AddShaderReplacement
void AddShaderReplacement(vtkShader::Type shaderType, const std::string &originalValue, bool replaceFirst, const std::string &replacementValue, bool replaceAll)
This function enables you to apply your own substitutions to the shader creation process.
vtkOpenGLPolyDataMapper::ForceHaveAppleBugOn
void ForceHaveAppleBugOn()
Definition: vtkOpenGLPolyDataMapper.h:206
vtkOpenGLPolyDataMapper::TimerQuery
vtkOpenGLRenderTimer * TimerQuery
Definition: vtkOpenGLPolyDataMapper.h:561
vtkOpenGLPolyDataMapper::InternalColorTexture
vtkOpenGLTexture * InternalColorTexture
Definition: vtkOpenGLPolyDataMapper.h:500
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:64
vtkOpenGLPolyDataMapper::ExtraAttributeValue::TextureName
std::string TextureName
Definition: vtkOpenGLPolyDataMapper.h:554
vtkOpenGLPolyDataMapper::ProcessSelectorPixelBuffers
void ProcessSelectorPixelBuffers(vtkHardwareSelector *sel, std::vector< unsigned int > &pixeloffsets, vtkProp *prop) override
allows a mapper to update a selections color buffers Called from a prop which in turn is called from ...
vtkOpenGLPolyDataMapper::SetMapperShaderParameters
virtual void SetMapperShaderParameters(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act)
Set the shader parameters related to the mapper/input data, called by UpdateShader.
vtkOpenGLPolyDataMapper::LastRenderPassInfo
vtkNew< vtkInformation > LastRenderPassInfo
Definition: vtkOpenGLPolyDataMapper.h:488
vtkOpenGLPolyDataMapper::TimerQueryCounter
unsigned int TimerQueryCounter
Definition: vtkOpenGLPolyDataMapper.h:576
vtkOpenGLPolyDataMapper::CellTextureBuildState
vtkStateStorage CellTextureBuildState
Definition: vtkOpenGLPolyDataMapper.h:498
vtkPolyData
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:86
vtkOpenGLPolyDataMapper::PrimitiveTypes
PrimitiveTypes
Definition: vtkOpenGLPolyDataMapper.h:226
vtkOpenGLPolyDataMapper::ComputeBounds
void ComputeBounds() override
Called in GetBounds().
vtkOpenGLPolyDataMapper::ForceHaveAppleBugOff
void ForceHaveAppleBugOff()
Override the normal test for the apple bug.
Definition: vtkOpenGLPolyDataMapper.h:201
vtkPolyDataMapper.h
vtkOpenGLPolyDataMapper::PrimitiveVertices
@ PrimitiveVertices
Definition: vtkOpenGLPolyDataMapper.h:234
vtkOpenGLPolyDataMapper::AppleBugPrimIDBuffer
vtkOpenGLBufferObject * AppleBugPrimIDBuffer
Definition: vtkOpenGLPolyDataMapper.h:321
vtkOpenGLPolyDataMapper::PointIdArrayName
char * PointIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:540
vtkOpenGLPolyDataMapper::GetNeedToRebuildShaders
virtual bool GetNeedToRebuildShaders(vtkOpenGLHelper &cellBO, vtkRenderer *ren, vtkActor *act)
Does the shader source need to be recomputed.
vtkOpenGLPolyDataMapper::PrimitiveTriStrips
@ PrimitiveTriStrips
Definition: vtkOpenGLPolyDataMapper.h:231
vtkOpenGLPolyDataMapper::ReplaceShaderPrimID
virtual void ReplaceShaderPrimID(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkOpenGLPolyDataMapper::ReplaceShaderColor
virtual void ReplaceShaderColor(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkOpenGLTexture
OpenGL texture map.
Definition: vtkOpenGLTexture.h:37
vtkOpenGLPolyDataMapper::CellIdArrayName
char * CellIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:541
vtkOpenGLPolyDataMapper::TempMatrix3
vtkMatrix3x3 * TempMatrix3
Definition: vtkOpenGLPolyDataMapper.h:506
vtkOpenGLPolyDataMapper::MapDataArray
void MapDataArray(const char *vertexAttributeName, const char *dataArrayName, const char *texturename, int fieldAssociation, int componentno)
vtkOpenGLPolyDataMapper::GetNumberOfTextures
virtual unsigned int GetNumberOfTextures(vtkActor *actor)
vtkOpenGLPolyDataMapper
PolyDataMapper using OpenGL to render.
Definition: vtkOpenGLPolyDataMapper.h:54
vtkOpenGLPolyDataMapper::ProcessIdArrayName
char * ProcessIdArrayName
Definition: vtkOpenGLPolyDataMapper.h:542
vtkOpenGLPolyDataMapper::CellScalarBuffer
vtkOpenGLBufferObject * CellScalarBuffer
Definition: vtkOpenGLPolyDataMapper.h:533
vtkOpenGLPolyDataMapper::AppendCellTextures
void AppendCellTextures(vtkRenderer *ren, vtkActor *, vtkCellArray *prims[4], int representation, std::vector< unsigned char > &colors, std::vector< float > &normals, vtkPolyData *pd)
vtkOpenGLPolyDataMapper::DrawingTubesOrSpheres
bool DrawingTubesOrSpheres(vtkOpenGLHelper &cellBO, vtkActor *actor)
vtkOpenGLPolyDataMapper::ExtraAttributeValue::FieldAssociation
int FieldAssociation
Definition: vtkOpenGLPolyDataMapper.h:552
vtkOpenGLPolyDataMapper::SelectionStateChanged
vtkTimeStamp SelectionStateChanged
Definition: vtkOpenGLPolyDataMapper.h:483
vtkOpenGLPolyDataMapper::ReplaceShaderCoincidentOffset
virtual void ReplaceShaderCoincidentOffset(std::map< vtkShader::Type, vtkShader * > shaders, vtkRenderer *ren, vtkActor *act)
vtkAbstractMapper
abstract class specifies interface to map data
Definition: vtkAbstractMapper.h:56
vtkOpenGLPolyDataMapper::CellScalarTexture
vtkTextureObject * CellScalarTexture
Definition: vtkOpenGLPolyDataMapper.h:532
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:302
vtkOpenGLPolyDataMapper::HaveAppleBug
bool HaveAppleBug
Definition: vtkOpenGLPolyDataMapper.h:318