VTK  9.0.20201029
vtkRenderer.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkRenderer.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
41 #ifndef vtkRenderer_h
42 #define vtkRenderer_h
43 
44 #include "vtkRenderingCoreModule.h" // For export macro
45 #include "vtkViewport.h"
46 
47 #include "vtkActorCollection.h" // Needed for access in inline members
48 #include "vtkVolumeCollection.h" // Needed for access in inline members
49 
50 class vtkFXAAOptions;
51 class vtkRenderWindow;
52 class vtkVolume;
53 class vtkCuller;
54 class vtkActor;
55 class vtkActor2D;
56 class vtkCamera;
58 class vtkInformation;
59 class vtkLightCollection;
61 class vtkLight;
64 class vtkRenderPass;
65 class vtkTexture;
66 
67 class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
68 {
69 public:
70  vtkTypeMacro(vtkRenderer, vtkViewport);
71  void PrintSelf(ostream& os, vtkIndent indent) override;
72 
78  static vtkRenderer* New();
79 
81 
86  void AddActor(vtkProp* p);
87  void AddVolume(vtkProp* p);
88  void RemoveActor(vtkProp* p);
89  void RemoveVolume(vtkProp* p);
91 
95  void AddLight(vtkLight*);
96 
100  void RemoveLight(vtkLight*);
101 
105  void RemoveAllLights();
106 
110  vtkLightCollection* GetLights();
111 
118  void SetLightCollection(vtkLightCollection* lights);
119 
123  void CreateLight(void);
124 
130  virtual vtkLight* MakeLight();
131 
133 
139  vtkGetMacro(TwoSidedLighting, vtkTypeBool);
140  vtkSetMacro(TwoSidedLighting, vtkTypeBool);
141  vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);
143 
145 
158  vtkSetMacro(LightFollowCamera, vtkTypeBool);
159  vtkGetMacro(LightFollowCamera, vtkTypeBool);
160  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
162 
164 
172  vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
173  vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
174  vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);
176 
182  virtual vtkTypeBool UpdateLightsGeometryToFollowCamera(void);
183 
187  vtkVolumeCollection* GetVolumes();
188 
192  vtkActorCollection* GetActors();
193 
197  void SetActiveCamera(vtkCamera*);
198 
204  vtkCamera* GetActiveCamera();
205 
211  virtual vtkCamera* MakeCamera();
212 
214 
220  vtkSetMacro(Erase, vtkTypeBool);
221  vtkGetMacro(Erase, vtkTypeBool);
222  vtkBooleanMacro(Erase, vtkTypeBool);
224 
226 
231  vtkSetMacro(Draw, vtkTypeBool);
232  vtkGetMacro(Draw, vtkTypeBool);
233  vtkBooleanMacro(Draw, vtkTypeBool);
235 
240  int CaptureGL2PSSpecialProp(vtkProp*);
241 
247  void SetGL2PSSpecialPropCollection(vtkPropCollection*);
248 
252  void AddCuller(vtkCuller*);
253 
257  void RemoveCuller(vtkCuller*);
258 
262  vtkCullerCollection* GetCullers();
263 
265 
268  vtkSetVector3Macro(Ambient, double);
269  vtkGetVectorMacro(Ambient, double, 3);
271 
273 
277  vtkSetMacro(AllocatedRenderTime, double);
278  virtual double GetAllocatedRenderTime();
280 
287  virtual double GetTimeFactor();
288 
295  virtual void Render();
296 
300  virtual void DeviceRender(){};
301 
308  virtual void DeviceRenderOpaqueGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
309 
319  virtual void DeviceRenderTranslucentPolygonalGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
320 
325  virtual void ClearLights(void) {}
326 
330  virtual void Clear() {}
331 
335  int VisibleActorCount();
336 
340  int VisibleVolumeCount();
341 
346  void ComputeVisiblePropBounds(double bounds[6]);
347 
351  double* ComputeVisiblePropBounds() VTK_SIZEHINT(6);
352 
357  virtual void ResetCameraClippingRange();
358 
360 
363  virtual void ResetCameraClippingRange(const double bounds[6]);
364  virtual void ResetCameraClippingRange(
365  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
367 
369 
374  vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
375  vtkGetMacro(NearClippingPlaneTolerance, double);
377 
379 
384  vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
385  vtkGetMacro(ClippingRangeExpansion, double);
387 
394  virtual void ResetCamera();
395 
405  virtual void ResetCamera(const double bounds[6]);
406 
410  virtual void ResetCamera(
411  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
412 
414 
419  void SetRenderWindow(vtkRenderWindow*);
420  vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
421  vtkWindow* GetVTKWindow() override;
423 
425 
431  vtkSetMacro(BackingStore, vtkTypeBool);
432  vtkGetMacro(BackingStore, vtkTypeBool);
433  vtkBooleanMacro(BackingStore, vtkTypeBool);
435 
437 
442  vtkSetMacro(Interactive, vtkTypeBool);
443  vtkGetMacro(Interactive, vtkTypeBool);
444  vtkBooleanMacro(Interactive, vtkTypeBool);
446 
448 
459  virtual void SetLayer(int layer);
460  vtkGetMacro(Layer, int);
462 
464 
474  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
475  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
476  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
478 
480 
484  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
485  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
486  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
488 
493  int Transparent();
494 
498  void WorldToView() override;
499 
501 
504  void ViewToWorld() override;
505  void ViewToWorld(double& wx, double& wy, double& wz) override;
507 
511  void WorldToView(double& wx, double& wy, double& wz) override;
512 
514 
517  void WorldToPose(double& wx, double& wy, double& wz) override;
518  void PoseToWorld(double& wx, double& wy, double& wz) override;
519  void ViewToPose(double& wx, double& wy, double& wz) override;
520  void PoseToView(double& wx, double& wy, double& wz) override;
522 
527  double GetZ(int x, int y);
528 
532  vtkMTimeType GetMTime() override;
533 
535 
538  vtkGetMacro(LastRenderTimeInSeconds, double);
540 
542 
548  vtkGetMacro(NumberOfPropsRendered, int);
550 
552 
559  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
560  {
561  return this->PickProp(selectionX, selectionY, selectionX, selectionY);
562  }
564  double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
566 
572  virtual void StereoMidpoint() { return; }
573 
580  double GetTiledAspectRatio();
581 
587  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
588 
590 
600  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
601  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
602  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
604 
610  vtkSetMacro(UseDepthPeelingForVolumes, bool);
611  vtkGetMacro(UseDepthPeelingForVolumes, bool);
612  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
613 
615 
624  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
625  vtkGetMacro(OcclusionRatio, double);
627 
629 
634  vtkSetMacro(MaximumNumberOfPeels, int);
635  vtkGetMacro(MaximumNumberOfPeels, int);
637 
639 
644  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
646 
648 
652  vtkSetMacro(UseSSAO, bool);
653  vtkGetMacro(UseSSAO, bool);
654  vtkBooleanMacro(UseSSAO, bool);
656 
658 
662  vtkSetMacro(SSAORadius, double);
663  vtkGetMacro(SSAORadius, double);
665 
667 
671  vtkSetMacro(SSAOBias, double);
672  vtkGetMacro(SSAOBias, double);
674 
676 
680  vtkSetMacro(SSAOKernelSize, unsigned int);
681  vtkGetMacro(SSAOKernelSize, unsigned int);
683 
685 
690  vtkSetMacro(SSAOBlur, bool);
691  vtkGetMacro(SSAOBlur, bool);
692  vtkBooleanMacro(SSAOBlur, bool);
694 
696 
702  void SetDelegate(vtkRendererDelegate* d);
703  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
705 
707 
712  vtkGetObjectMacro(Selector, vtkHardwareSelector);
714 
716 
721  virtual void SetLeftBackgroundTexture(vtkTexture*);
722  vtkTexture* GetLeftBackgroundTexture();
723  virtual void SetBackgroundTexture(vtkTexture*);
724  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
726 
728 
732  virtual void SetRightBackgroundTexture(vtkTexture*);
733  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
735 
737 
741  vtkSetMacro(TexturedBackground, bool);
742  vtkGetMacro(TexturedBackground, bool);
743  vtkBooleanMacro(TexturedBackground, bool);
745 
746  // method to release graphics resources in any derived renderers.
747  virtual void ReleaseGraphicsResources(vtkWindow*);
748 
750 
753  vtkSetMacro(UseFXAA, bool);
754  vtkGetMacro(UseFXAA, bool);
755  vtkBooleanMacro(UseFXAA, bool);
757 
759 
762  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
763  virtual void SetFXAAOptions(vtkFXAAOptions*);
765 
767 
771  vtkSetMacro(UseShadows, vtkTypeBool);
772  vtkGetMacro(UseShadows, vtkTypeBool);
773  vtkBooleanMacro(UseShadows, vtkTypeBool);
775 
777 
781  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
782  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
783  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
785 
786  // Set/Get a custom render pass.
787  // Initial value is NULL.
788  void SetPass(vtkRenderPass* p);
789  vtkGetObjectMacro(Pass, vtkRenderPass);
790 
792 
795  vtkGetObjectMacro(Information, vtkInformation);
796  virtual void SetInformation(vtkInformation*);
798 
800 
806  vtkSetMacro(UseImageBasedLighting, bool);
807  vtkGetMacro(UseImageBasedLighting, bool);
808  vtkBooleanMacro(UseImageBasedLighting, bool);
810 
812 
823  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
824  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
826 
828 
831  vtkGetVector3Macro(EnvironmentUp, double);
832  vtkSetVector3Macro(EnvironmentUp, double);
834 
836 
839  vtkGetVector3Macro(EnvironmentRight, double);
840  vtkSetVector3Macro(EnvironmentRight, double);
842 
843 protected:
844  vtkRenderer();
845  ~vtkRenderer() override;
846 
847  // internal method to expand bounding box to consider model transform
848  // matrix or model view transform matrix based on whether or not deering
849  // frustum is used. 'bounds' buffer is mutated to the expanded box.
850  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
851 
854 
857 
860 
861  double Ambient[3];
864  double TimeFactor;
868  unsigned char* BackingImage;
869  int BackingStoreSize[2];
871 
873 
875 
876  // Allocate the time for each prop
877  void AllocateTime();
878 
879  // Internal variables indicating the number of props
880  // that have been or will be rendered in each category.
882 
883  // A temporary list of props used for culling, and traversal
884  // of all props when rendering
887 
888  // Indicates if the renderer should receive events from an interactor.
889  // Typically only used in conjunction with transparent renderers.
891 
892  // Shows what layer this renderer belongs to. Only of interested when
893  // there are layered renderers.
894  int Layer;
897 
898  // Holds the result of ComputeVisiblePropBounds so that it is visible from
899  // wrapped languages
900  double ComputedVisiblePropBounds[6];
901 
910 
916 
924 
931 
936 
942  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
943 
951  virtual int UpdateTranslucentPolygonalGeometry();
952 
958  virtual int UpdateOpaquePolygonalGeometry();
959 
964  virtual int UpdateCamera(void);
965 
971  virtual vtkTypeBool UpdateLightGeometry(void);
972 
977  virtual int UpdateLights(void) { return 0; }
978 
984  vtkCamera* GetActiveCameraAndResetIfCreated();
985 
990  bool UseFXAA;
991 
996 
1002 
1008 
1016 
1022 
1033 
1040 
1041  bool UseSSAO = false;
1042  double SSAORadius = 0.5;
1043  double SSAOBias = 0.01;
1044  unsigned int SSAOKernelSize = 32;
1045  bool SSAOBlur = false;
1046 
1053 
1054  // HARDWARE SELECTION ----------------------------------------
1055  friend class vtkHardwareSelector;
1056 
1061  {
1062  this->Selector = selector;
1063  this->Modified();
1064  }
1065 
1066  // End Ivars for visible cell selecting.
1068 
1069  //---------------------------------------------------------------
1070  friend class vtkRendererDelegate;
1072 
1076 
1077  friend class vtkRenderPass;
1079 
1080  // Arbitrary extra information associated with this renderer
1082 
1085 
1086  double EnvironmentUp[3];
1087  double EnvironmentRight[3];
1088 
1089 private:
1090  vtkRenderer(const vtkRenderer&) = delete;
1091  void operator=(const vtkRenderer&) = delete;
1092 };
1093 
1095 {
1096  return this->Lights;
1097 }
1098 
1103 {
1104  return this->Cullers;
1105 }
1106 
1107 #endif
vtkViewport::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkVolumeCollection
an ordered list of volumes
Definition: vtkVolumeCollection.h:35
vtkRenderer::PickProp
vtkAssemblyPath * PickProp(double selectionX, double selectionY) override
Return the prop (via a vtkAssemblyPath) that has the highest z value at the given x,...
Definition: vtkRenderer.h:559
vtkLight
a virtual light for 3D rendering
Definition: vtkLight.h:56
vtkRenderer::ClippingRangeExpansion
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:915
vtkRenderer::UseShadows
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:1001
vtkRenderer::PreserveDepthBuffer
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:896
vtkVolume
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:44
vtkRenderer::Pass
vtkRenderPass * Pass
Definition: vtkRenderer.h:1078
vtkRenderer::IsActiveCameraCreated
vtkTypeBool IsActiveCameraCreated()
This method returns 1 if the ActiveCamera has already been set or automatically created by the render...
Definition: vtkRenderer.h:587
vtkRenderer::Clear
virtual void Clear()
Clear the image to the background color.
Definition: vtkRenderer.h:330
vtkRenderer::UpdateLights
virtual int UpdateLights(void)
Ask all lights to load themselves into rendering pipeline.
Definition: vtkRenderer.h:977
vtkObject::New
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on.
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:32
vtkRenderer::BackingStore
vtkTypeBool BackingStore
Definition: vtkRenderer.h:867
vtkLightCollection
an ordered list of lights
Definition: vtkLightCollection.h:35
vtkRenderer::AllocatedRenderTime
double AllocatedRenderTime
Definition: vtkRenderer.h:863
vtkRenderer::ClearLights
virtual void ClearLights(void)
Internal method temporarily removes lights before reloading them into graphics pipeline.
Definition: vtkRenderer.h:325
vtkViewport::WorldToPose
virtual void WorldToPose(double &, double &, double &)
Definition: vtkViewport.h:261
vtkObject::Modified
virtual void Modified()
Update the modification time for this object.
vtkRenderer::LightFollowCamera
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:874
vtkRenderer::RenderTime
vtkTimeStamp RenderTime
Definition: vtkRenderer.h:870
vtkFXAAOptions
Configuration for FXAA implementations.
Definition: vtkFXAAOptions.h:30
vtkRenderer::OcclusionRatio
double OcclusionRatio
In case of use of depth peeling technique for rendering translucent material, define the threshold un...
Definition: vtkRenderer.h:1032
vtkRenderer::EnvironmentTexture
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1084
vtkRenderer::UseDepthPeelingForVolumes
bool UseDepthPeelingForVolumes
This flag is on and the GPU supports it, depth-peel volumes along with the translucent geometry.
Definition: vtkRenderer.h:1021
vtkRenderer::Draw
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:930
vtkViewport::PickProp
virtual vtkAssemblyPath * PickProp(double selectionX, double selectionY)=0
Return the Prop that has the highest z value at the given x, y position in the viewport.
vtkViewport.h
vtkAssemblyPath
a list of nodes that form an assembly path
Definition: vtkAssemblyPath.h:41
vtkRenderer::BackingImage
unsigned char * BackingImage
Definition: vtkRenderer.h:868
vtkFrameBufferObjectBase
abstract interface to OpenGL FBOs
Definition: vtkFrameBufferObjectBase.h:32
vtkRenderer::StereoMidpoint
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
Definition: vtkRenderer.h:572
vtkRenderer::RenderWindow
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:862
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:38
vtkRenderer::Layer
int Layer
Definition: vtkRenderer.h:894
vtkRenderer::AutomaticLightCreation
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:866
vtkRenderer::UseFXAA
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene.
Definition: vtkRenderer.h:990
vtkRenderer::UseDepthPeeling
vtkTypeBool UseDepthPeeling
If this flag is on and the GPU supports it, depth peeling is used for rendering translucent materials...
Definition: vtkRenderer.h:1015
vtkRenderer::SetSelector
void SetSelector(vtkHardwareSelector *selector)
Called by vtkHardwareSelector when it begins rendering for selection.
Definition: vtkRenderer.h:1060
vtkRendererDelegate
Render the props of a vtkRenderer.
Definition: vtkRendererDelegate.h:37
vtkTexture
handles properties associated with a texture map
Definition: vtkTexture.h:65
vtkRenderer::PreserveColorBuffer
vtkTypeBool PreserveColorBuffer
Definition: vtkRenderer.h:895
VTK_SIZEHINT
#define VTK_SIZEHINT(...)
Definition: vtkWrappingHints.h:45
vtkRenderer::Interactive
vtkTypeBool Interactive
Definition: vtkRenderer.h:890
vtkActorCollection.h
vtkRenderer::LastRenderTimeInSeconds
double LastRenderTimeInSeconds
Definition: vtkRenderer.h:872
vtkRenderer::ActiveCamera
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:852
vtkViewport::ViewToPose
virtual void ViewToPose(double &, double &, double &)
Definition: vtkViewport.h:253
vtkVolumeCollection.h
vtkRenderer::Volumes
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:859
vtkObject::GetMTime
virtual vtkMTimeType GetMTime()
Return this object's modified time.
vtkRenderer::Cullers
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:856
vtkHardwareSelector
Definition: vtkHardwareSelector.h:123
vtkRenderer::GetLights
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:1094
vtkRenderer::Delegate
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1071
vtkRenderer::PropArrayCount
int PropArrayCount
Definition: vtkRenderer.h:886
vtkRenderer::TimeFactor
double TimeFactor
Definition: vtkRenderer.h:864
vtkActor
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:45
vtkCuller
a superclass for prop cullers
Definition: vtkCuller.h:37
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:35
vtkRenderer::TwoSidedLighting
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:865
vtkCamera
a virtual camera for 3D rendering
Definition: vtkCamera.h:45
vtkRenderer::UseHiddenLineRemoval
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:1007
vtkRenderer::PropArray
vtkProp ** PropArray
Definition: vtkRenderer.h:885
vtkCullerCollection
an ordered list of Cullers
Definition: vtkCullerCollection.h:34
vtkViewport::PoseToWorld
virtual void PoseToWorld(double &, double &, double &)
Definition: vtkViewport.h:254
vtkRenderer::FXAAOptions
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:995
vtkViewport
abstract specification for Viewports
Definition: vtkViewport.h:44
vtkRenderer::Actors
vtkActorCollection * Actors
Definition: vtkRenderer.h:858
vtkViewport::ViewToWorld
virtual void ViewToWorld()
Convert view point coordinates to world coordinates.
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:73
vtkProp
abstract superclass for all actors, volumes and annotations
Definition: vtkProp.h:56
vtkViewport::GetVTKWindow
virtual vtkWindow * GetVTKWindow()=0
Return the vtkWindow that owns this vtkViewport.
vtkRenderer::GL2PSSpecialPropCollection
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:935
vtkActor2D
a actor that draws 2D data
Definition: vtkActor2D.h:39
vtkRenderer::UseImageBasedLighting
bool UseImageBasedLighting
Definition: vtkRenderer.h:1083
vtkRenderer::Selector
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1067
vtkRenderer::Lights
vtkLightCollection * Lights
Definition: vtkRenderer.h:855
vtkRenderer::NearClippingPlaneTolerance
double NearClippingPlaneTolerance
Specifies the minimum distance of the near clipping plane as a percentage of the far clipping plane d...
Definition: vtkRenderer.h:909
vtkRenderer::BackgroundTexture
vtkTexture * BackgroundTexture
Definition: vtkRenderer.h:1074
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:67
vtkRenderer::TexturedBackground
bool TexturedBackground
Definition: vtkRenderer.h:1073
vtkActorCollection
an ordered list of actors
Definition: vtkActorCollection.h:36
vtkRenderer::RightBackgroundTexture
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1075
vtkRenderer::MaximumNumberOfPeels
int MaximumNumberOfPeels
In case of depth peeling, define the maximum number of peeling layers.
Definition: vtkRenderer.h:1039
vtkRenderWindow
create a window for renderers to draw into
Definition: vtkRenderWindow.h:95
vtkViewport::PoseToView
virtual void PoseToView(double &, double &, double &)
Definition: vtkViewport.h:260
vtkRenderer::CreatedLight
vtkLight * CreatedLight
Definition: vtkRenderer.h:853
vtkPropCollection
an ordered list of Props
Definition: vtkPropCollection.h:35
vtkViewport::WorldToView
virtual void WorldToView()
Convert world point coordinates to view coordinates.
vtkRenderer::LastRenderingUsedDepthPeeling
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
Definition: vtkRenderer.h:1052
vtkRenderer::DeviceRender
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:300
vtkRenderer::GetCullers
vtkCullerCollection * GetCullers()
Return the collection of cullers.
Definition: vtkRenderer.h:1102
vtkRenderer::Erase
vtkTypeBool Erase
When this flag is off, the renderer will not erase the background or the Zbuffer.
Definition: vtkRenderer.h:923
vtkRenderer::NumberOfPropsRendered
int NumberOfPropsRendered
Definition: vtkRenderer.h:881
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkRenderer::Information
vtkInformation * Information
Definition: vtkRenderer.h:1081
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:285
vtkRenderPass
Perform part of the rendering of a vtkRenderer.
Definition: vtkRenderPass.h:56