VTK  9.0.20210120
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 
417  virtual void ResetCameraScreenSpace();
418 
424  virtual void ResetCameraScreenSpace(const double bounds[6]);
425 
429  virtual void ResetCameraScreenSpace(
430  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
431 
433 
438  void SetRenderWindow(vtkRenderWindow*);
439  vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
440  vtkWindow* GetVTKWindow() override;
442 
444 
450  vtkSetMacro(BackingStore, vtkTypeBool);
451  vtkGetMacro(BackingStore, vtkTypeBool);
452  vtkBooleanMacro(BackingStore, vtkTypeBool);
454 
456 
461  vtkSetMacro(Interactive, vtkTypeBool);
462  vtkGetMacro(Interactive, vtkTypeBool);
463  vtkBooleanMacro(Interactive, vtkTypeBool);
465 
467 
478  virtual void SetLayer(int layer);
479  vtkGetMacro(Layer, int);
481 
483 
493  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
494  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
495  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
497 
499 
503  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
504  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
505  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
507 
512  int Transparent();
513 
517  void WorldToView() override;
518 
520 
523  void ViewToWorld() override;
524  void ViewToWorld(double& wx, double& wy, double& wz) override;
526 
530  void WorldToView(double& wx, double& wy, double& wz) override;
531 
533 
536  void WorldToPose(double& wx, double& wy, double& wz) override;
537  void PoseToWorld(double& wx, double& wy, double& wz) override;
538  void ViewToPose(double& wx, double& wy, double& wz) override;
539  void PoseToView(double& wx, double& wy, double& wz) override;
541 
546  double GetZ(int x, int y);
547 
551  vtkMTimeType GetMTime() override;
552 
554 
557  vtkGetMacro(LastRenderTimeInSeconds, double);
559 
561 
567  vtkGetMacro(NumberOfPropsRendered, int);
569 
571 
578  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
579  {
580  return this->PickProp(selectionX, selectionY, selectionX, selectionY);
581  }
583  double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
585 
591  virtual void StereoMidpoint() { return; }
592 
599  double GetTiledAspectRatio();
600 
606  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
607 
609 
619  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
620  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
621  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
623 
629  vtkSetMacro(UseDepthPeelingForVolumes, bool);
630  vtkGetMacro(UseDepthPeelingForVolumes, bool);
631  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
632 
634 
643  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
644  vtkGetMacro(OcclusionRatio, double);
646 
648 
653  vtkSetMacro(MaximumNumberOfPeels, int);
654  vtkGetMacro(MaximumNumberOfPeels, int);
656 
658 
663  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
665 
667 
671  vtkSetMacro(UseSSAO, bool);
672  vtkGetMacro(UseSSAO, bool);
673  vtkBooleanMacro(UseSSAO, bool);
675 
677 
681  vtkSetMacro(SSAORadius, double);
682  vtkGetMacro(SSAORadius, double);
684 
686 
690  vtkSetMacro(SSAOBias, double);
691  vtkGetMacro(SSAOBias, double);
693 
695 
699  vtkSetMacro(SSAOKernelSize, unsigned int);
700  vtkGetMacro(SSAOKernelSize, unsigned int);
702 
704 
709  vtkSetMacro(SSAOBlur, bool);
710  vtkGetMacro(SSAOBlur, bool);
711  vtkBooleanMacro(SSAOBlur, bool);
713 
715 
721  void SetDelegate(vtkRendererDelegate* d);
722  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
724 
726 
731  vtkGetObjectMacro(Selector, vtkHardwareSelector);
733 
735 
740  virtual void SetLeftBackgroundTexture(vtkTexture*);
741  vtkTexture* GetLeftBackgroundTexture();
742  virtual void SetBackgroundTexture(vtkTexture*);
743  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
745 
747 
751  virtual void SetRightBackgroundTexture(vtkTexture*);
752  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
754 
756 
760  vtkSetMacro(TexturedBackground, bool);
761  vtkGetMacro(TexturedBackground, bool);
762  vtkBooleanMacro(TexturedBackground, bool);
764 
765  // method to release graphics resources in any derived renderers.
766  virtual void ReleaseGraphicsResources(vtkWindow*);
767 
769 
772  vtkSetMacro(UseFXAA, bool);
773  vtkGetMacro(UseFXAA, bool);
774  vtkBooleanMacro(UseFXAA, bool);
776 
778 
781  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
782  virtual void SetFXAAOptions(vtkFXAAOptions*);
784 
786 
790  vtkSetMacro(UseShadows, vtkTypeBool);
791  vtkGetMacro(UseShadows, vtkTypeBool);
792  vtkBooleanMacro(UseShadows, vtkTypeBool);
794 
796 
800  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
801  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
802  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
804 
805  // Set/Get a custom render pass.
806  // Initial value is NULL.
807  void SetPass(vtkRenderPass* p);
808  vtkGetObjectMacro(Pass, vtkRenderPass);
809 
811 
814  vtkGetObjectMacro(Information, vtkInformation);
815  virtual void SetInformation(vtkInformation*);
817 
819 
825  vtkSetMacro(UseImageBasedLighting, bool);
826  vtkGetMacro(UseImageBasedLighting, bool);
827  vtkBooleanMacro(UseImageBasedLighting, bool);
829 
831 
842  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
843  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
845 
847 
850  vtkGetVector3Macro(EnvironmentUp, double);
851  vtkSetVector3Macro(EnvironmentUp, double);
853 
855 
858  vtkGetVector3Macro(EnvironmentRight, double);
859  vtkSetVector3Macro(EnvironmentRight, double);
861 
862 protected:
863  vtkRenderer();
864  ~vtkRenderer() override;
865 
866  // internal method to expand bounding box to consider model transform
867  // matrix or model view transform matrix based on whether or not deering
868  // frustum is used. 'bounds' buffer is mutated to the expanded box.
869  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
870 
873 
876 
879 
880  double Ambient[3];
883  double TimeFactor;
887  unsigned char* BackingImage;
888  int BackingStoreSize[2];
890 
892 
894 
895  // Allocate the time for each prop
896  void AllocateTime();
897 
898  // Internal variables indicating the number of props
899  // that have been or will be rendered in each category.
901 
902  // A temporary list of props used for culling, and traversal
903  // of all props when rendering
906 
907  // Indicates if the renderer should receive events from an interactor.
908  // Typically only used in conjunction with transparent renderers.
910 
911  // Shows what layer this renderer belongs to. Only of interested when
912  // there are layered renderers.
913  int Layer;
916 
917  // Holds the result of ComputeVisiblePropBounds so that it is visible from
918  // wrapped languages
919  double ComputedVisiblePropBounds[6];
920 
929 
935 
943 
950 
955 
961  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
962 
970  virtual int UpdateTranslucentPolygonalGeometry();
971 
977  virtual int UpdateOpaquePolygonalGeometry();
978 
983  virtual int UpdateCamera(void);
984 
990  virtual vtkTypeBool UpdateLightGeometry(void);
991 
996  virtual int UpdateLights(void) { return 0; }
997 
1003  vtkCamera* GetActiveCameraAndResetIfCreated();
1004 
1009  bool UseFXAA;
1010 
1015 
1021 
1027 
1035 
1041 
1052 
1059 
1060  bool UseSSAO = false;
1061  double SSAORadius = 0.5;
1062  double SSAOBias = 0.01;
1063  unsigned int SSAOKernelSize = 32;
1064  bool SSAOBlur = false;
1065 
1072 
1073  // HARDWARE SELECTION ----------------------------------------
1074  friend class vtkHardwareSelector;
1075 
1080  {
1081  this->Selector = selector;
1082  this->Modified();
1083  }
1084 
1085  // End Ivars for visible cell selecting.
1087 
1088  //---------------------------------------------------------------
1089  friend class vtkRendererDelegate;
1091 
1095 
1096  friend class vtkRenderPass;
1098 
1099  // Arbitrary extra information associated with this renderer
1101 
1104 
1105  double EnvironmentUp[3];
1106  double EnvironmentRight[3];
1107 
1108 private:
1109  vtkRenderer(const vtkRenderer&) = delete;
1110  void operator=(const vtkRenderer&) = delete;
1111 };
1112 
1114 {
1115  return this->Lights;
1116 }
1117 
1122 {
1123  return this->Cullers;
1124 }
1125 
1126 #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:578
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:934
vtkRenderer::UseShadows
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:1020
vtkRenderer::PreserveDepthBuffer
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:915
vtkVolume
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:44
vtkRenderer::Pass
vtkRenderPass * Pass
Definition: vtkRenderer.h:1097
vtkRenderer::IsActiveCameraCreated
vtkTypeBool IsActiveCameraCreated()
This method returns 1 if the ActiveCamera has already been set or automatically created by the render...
Definition: vtkRenderer.h:606
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:996
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:886
vtkLightCollection
an ordered list of lights
Definition: vtkLightCollection.h:35
vtkRenderer::AllocatedRenderTime
double AllocatedRenderTime
Definition: vtkRenderer.h:882
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:893
vtkRenderer::RenderTime
vtkTimeStamp RenderTime
Definition: vtkRenderer.h:889
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:1051
vtkRenderer::EnvironmentTexture
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1103
vtkRenderer::UseDepthPeelingForVolumes
bool UseDepthPeelingForVolumes
This flag is on and the GPU supports it, depth-peel volumes along with the translucent geometry.
Definition: vtkRenderer.h:1040
vtkRenderer::Draw
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:949
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:887
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:591
vtkRenderer::RenderWindow
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:881
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:38
vtkRenderer::Layer
int Layer
Definition: vtkRenderer.h:913
vtkRenderer::AutomaticLightCreation
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:885
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:1009
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:1034
vtkRenderer::SetSelector
void SetSelector(vtkHardwareSelector *selector)
Called by vtkHardwareSelector when it begins rendering for selection.
Definition: vtkRenderer.h:1079
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:914
VTK_SIZEHINT
#define VTK_SIZEHINT(...)
Definition: vtkWrappingHints.h:45
vtkRenderer::Interactive
vtkTypeBool Interactive
Definition: vtkRenderer.h:909
vtkActorCollection.h
vtkRenderer::LastRenderTimeInSeconds
double LastRenderTimeInSeconds
Definition: vtkRenderer.h:891
vtkRenderer::ActiveCamera
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:871
vtkViewport::ViewToPose
virtual void ViewToPose(double &, double &, double &)
Definition: vtkViewport.h:253
vtkVolumeCollection.h
vtkRenderer::Volumes
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:878
vtkObject::GetMTime
virtual vtkMTimeType GetMTime()
Return this object's modified time.
vtkRenderer::Cullers
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:875
vtkHardwareSelector
Definition: vtkHardwareSelector.h:123
vtkRenderer::GetLights
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:1113
vtkRenderer::Delegate
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1090
vtkRenderer::PropArrayCount
int PropArrayCount
Definition: vtkRenderer.h:905
vtkRenderer::TimeFactor
double TimeFactor
Definition: vtkRenderer.h:883
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:884
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:1026
vtkRenderer::PropArray
vtkProp ** PropArray
Definition: vtkRenderer.h:904
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:1014
vtkViewport
abstract specification for Viewports
Definition: vtkViewport.h:44
vtkRenderer::Actors
vtkActorCollection * Actors
Definition: vtkRenderer.h:877
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:954
vtkActor2D
a actor that draws 2D data
Definition: vtkActor2D.h:39
vtkRenderer::UseImageBasedLighting
bool UseImageBasedLighting
Definition: vtkRenderer.h:1102
vtkRenderer::Selector
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1086
vtkRenderer::Lights
vtkLightCollection * Lights
Definition: vtkRenderer.h:874
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:928
vtkRenderer::BackgroundTexture
vtkTexture * BackgroundTexture
Definition: vtkRenderer.h:1093
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:67
vtkRenderer::TexturedBackground
bool TexturedBackground
Definition: vtkRenderer.h:1092
vtkActorCollection
an ordered list of actors
Definition: vtkActorCollection.h:36
vtkRenderer::RightBackgroundTexture
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1094
vtkRenderer::MaximumNumberOfPeels
int MaximumNumberOfPeels
In case of depth peeling, define the maximum number of peeling layers.
Definition: vtkRenderer.h:1058
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:872
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:1071
vtkRenderer::DeviceRender
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:300
vtkRenderer::GetCullers
vtkCullerCollection * GetCullers()
Return the collection of cullers.
Definition: vtkRenderer.h:1121
vtkRenderer::Erase
vtkTypeBool Erase
When this flag is off, the renderer will not erase the background or the Zbuffer.
Definition: vtkRenderer.h:942
vtkRenderer::NumberOfPropsRendered
int NumberOfPropsRendered
Definition: vtkRenderer.h:900
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkRenderer::Information
vtkInformation * Information
Definition: vtkRenderer.h:1100
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:285
vtkRenderPass
Perform part of the rendering of a vtkRenderer.
Definition: vtkRenderPass.h:56