VTK  9.3.1
vtkRenderer.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-License-Identifier: BSD-3-Clause
29 #ifndef vtkRenderer_h
30 #define vtkRenderer_h
31 
32 #include "vtkRenderingCoreModule.h" // For export macro
33 #include "vtkViewport.h"
34 
35 #include "vtkActorCollection.h" // Needed for access in inline members
36 #include "vtkVolumeCollection.h" // Needed for access in inline members
37 
38 #include <array> // To store matrices
39 
40 VTK_ABI_NAMESPACE_BEGIN
41 class vtkFXAAOptions;
42 class vtkRenderWindow;
43 class vtkVolume;
44 class vtkCuller;
45 class vtkActor;
46 class vtkActor2D;
47 class vtkCamera;
49 class vtkInformation;
50 class vtkLightCollection;
52 class vtkLight;
55 class vtkRenderPass;
56 class vtkTexture;
57 
58 class vtkRecti;
59 class vtkVector3d;
60 
61 class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
62 {
63 public:
64  vtkTypeMacro(vtkRenderer, vtkViewport);
65  void PrintSelf(ostream& os, vtkIndent indent) override;
66 
72  static vtkRenderer* New();
73 
75 
80  void AddActor(vtkProp* p);
81  void AddVolume(vtkProp* p);
82  void RemoveActor(vtkProp* p);
83  void RemoveVolume(vtkProp* p);
85 
89  void AddLight(vtkLight*);
90 
94  void RemoveLight(vtkLight*);
95 
99  void RemoveAllLights();
100 
104  vtkLightCollection* GetLights();
105 
112  void SetLightCollection(vtkLightCollection* lights);
113 
117  void CreateLight();
118 
124  virtual vtkLight* MakeLight();
125 
127 
133  vtkGetMacro(TwoSidedLighting, vtkTypeBool);
134  vtkSetMacro(TwoSidedLighting, vtkTypeBool);
135  vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);
137 
139 
152  vtkSetMacro(LightFollowCamera, vtkTypeBool);
153  vtkGetMacro(LightFollowCamera, vtkTypeBool);
154  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
156 
158 
166  vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
167  vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
168  vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);
170 
176  virtual vtkTypeBool UpdateLightsGeometryToFollowCamera();
177 
181  vtkVolumeCollection* GetVolumes();
182 
186  vtkActorCollection* GetActors();
187 
191  void SetActiveCamera(vtkCamera*);
192 
198  vtkCamera* GetActiveCamera();
199 
205  virtual vtkCamera* MakeCamera();
206 
208 
214  vtkSetMacro(Erase, vtkTypeBool);
215  vtkGetMacro(Erase, vtkTypeBool);
216  vtkBooleanMacro(Erase, vtkTypeBool);
218 
220 
225  vtkSetMacro(Draw, vtkTypeBool);
226  vtkGetMacro(Draw, vtkTypeBool);
227  vtkBooleanMacro(Draw, vtkTypeBool);
229 
234  int CaptureGL2PSSpecialProp(vtkProp*);
235 
241  void SetGL2PSSpecialPropCollection(vtkPropCollection*);
242 
246  void AddCuller(vtkCuller*);
247 
251  void RemoveCuller(vtkCuller*);
252 
256  vtkCullerCollection* GetCullers();
257 
259 
262  vtkSetVector3Macro(Ambient, double);
263  vtkGetVectorMacro(Ambient, double, 3);
265 
267 
271  vtkSetMacro(AllocatedRenderTime, double);
272  virtual double GetAllocatedRenderTime();
274 
281  virtual double GetTimeFactor();
282 
289  virtual void Render();
290 
294  virtual void DeviceRender(){};
295 
302  virtual void DeviceRenderOpaqueGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
303 
313  virtual void DeviceRenderTranslucentPolygonalGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
314 
319  virtual void ClearLights() {}
320 
324  virtual void Clear() {}
325 
329  int VisibleActorCount();
330 
334  int VisibleVolumeCount();
335 
340  void ComputeVisiblePropBounds(double bounds[6]);
341 
345  double* ComputeVisiblePropBounds() VTK_SIZEHINT(6);
346 
351  virtual void ResetCameraClippingRange();
352 
354 
357  virtual void ResetCameraClippingRange(const double bounds[6]);
358  virtual void ResetCameraClippingRange(
359  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
361 
363 
368  vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
369  vtkGetMacro(NearClippingPlaneTolerance, double);
371 
373 
378  vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
379  vtkGetMacro(ClippingRangeExpansion, double);
381 
388  virtual void ResetCamera();
389 
399  virtual void ResetCamera(const double bounds[6]);
400 
404  virtual void ResetCamera(
405  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
406 
414  virtual void ResetCameraScreenSpace(double offsetRatio = 0.9);
415 
424  virtual void ResetCameraScreenSpace(const double bounds[6], double offsetRatio = 0.9);
425 
426  using vtkViewport::DisplayToWorld;
427 
431  vtkVector3d DisplayToWorld(const vtkVector3d& display);
432 
438  void ZoomToBoxUsingViewAngle(const vtkRecti& box, double offsetRatio = 1.0);
439 
446  virtual void ResetCameraScreenSpace(double xmin, double xmax, double ymin, double ymax,
447  double zmin, double zmax, double offsetRatio = 0.9);
448 
450 
455  void SetRenderWindow(vtkRenderWindow*);
456  vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
457  vtkWindow* GetVTKWindow() override;
459 
461 
467  vtkSetMacro(BackingStore, vtkTypeBool);
468  vtkGetMacro(BackingStore, vtkTypeBool);
469  vtkBooleanMacro(BackingStore, vtkTypeBool);
471 
473 
478  vtkSetMacro(Interactive, vtkTypeBool);
479  vtkGetMacro(Interactive, vtkTypeBool);
480  vtkBooleanMacro(Interactive, vtkTypeBool);
482 
484 
495  virtual void SetLayer(int layer);
496  vtkGetMacro(Layer, int);
498 
500 
510  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
511  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
512  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
514 
516 
520  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
521  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
522  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
524 
529  vtkTypeBool Transparent();
530 
534  void WorldToView() override;
535 
537 
540  void ViewToWorld() override;
541  void ViewToWorld(double& wx, double& wy, double& wz) override;
543 
547  void WorldToView(double& wx, double& wy, double& wz) override;
548 
550 
553  void WorldToPose(double& wx, double& wy, double& wz) override;
554  void PoseToWorld(double& wx, double& wy, double& wz) override;
555  void ViewToPose(double& wx, double& wy, double& wz) override;
556  void PoseToView(double& wx, double& wy, double& wz) override;
558 
563  double GetZ(int x, int y);
564 
568  vtkMTimeType GetMTime() override;
569 
571 
574  vtkGetMacro(LastRenderTimeInSeconds, double);
576 
578 
584  vtkGetMacro(NumberOfPropsRendered, int);
586 
588 
595  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
596  {
597  return this->PickProp(selectionX, selectionY, selectionX, selectionY);
598  }
600  double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
602 
604 
613  vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
614  vtkSmartPointer<vtkSelection> selection) override
615  {
616  return this->PickProp(
617  selectionX, selectionY, selectionX, selectionY, fieldAssociation, selection);
618  }
619  vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
620  double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) override;
622 
628  virtual void StereoMidpoint() {}
629 
636  double GetTiledAspectRatio();
637 
643  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
644 
646 
656  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
657  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
658  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
660 
666  vtkSetMacro(UseDepthPeelingForVolumes, bool);
667  vtkGetMacro(UseDepthPeelingForVolumes, bool);
668  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
669 
671 
680  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
681  vtkGetMacro(OcclusionRatio, double);
683 
685 
690  vtkSetMacro(MaximumNumberOfPeels, int);
691  vtkGetMacro(MaximumNumberOfPeels, int);
693 
695 
700  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
702 
704 
708  vtkSetMacro(UseSSAO, bool);
709  vtkGetMacro(UseSSAO, bool);
710  vtkBooleanMacro(UseSSAO, bool);
712 
714 
718  vtkSetMacro(SSAORadius, double);
719  vtkGetMacro(SSAORadius, double);
721 
723 
727  vtkSetMacro(SSAOBias, double);
728  vtkGetMacro(SSAOBias, double);
730 
732 
736  vtkSetMacro(SSAOKernelSize, unsigned int);
737  vtkGetMacro(SSAOKernelSize, unsigned int);
739 
741 
746  vtkSetMacro(SSAOBlur, bool);
747  vtkGetMacro(SSAOBlur, bool);
748  vtkBooleanMacro(SSAOBlur, bool);
750 
752 
758  void SetDelegate(vtkRendererDelegate* d);
759  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
761 
763 
768  vtkGetObjectMacro(Selector, vtkHardwareSelector);
770 
772 
777  virtual void SetLeftBackgroundTexture(vtkTexture*);
778  vtkTexture* GetLeftBackgroundTexture();
779  virtual void SetBackgroundTexture(vtkTexture*);
780  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
782 
784 
788  virtual void SetRightBackgroundTexture(vtkTexture*);
789  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
791 
793 
797  vtkSetMacro(TexturedBackground, bool);
798  vtkGetMacro(TexturedBackground, bool);
799  vtkBooleanMacro(TexturedBackground, bool);
801 
802  // method to release graphics resources in any derived renderers.
803  virtual void ReleaseGraphicsResources(vtkWindow*);
804 
806 
809  vtkSetMacro(UseFXAA, bool);
810  vtkGetMacro(UseFXAA, bool);
811  vtkBooleanMacro(UseFXAA, bool);
813 
815 
818  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
819  virtual void SetFXAAOptions(vtkFXAAOptions*);
821 
823 
827  vtkSetMacro(UseShadows, vtkTypeBool);
828  vtkGetMacro(UseShadows, vtkTypeBool);
829  vtkBooleanMacro(UseShadows, vtkTypeBool);
831 
833 
837  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
838  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
839  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
841 
842  // Set/Get a custom render pass.
843  // Initial value is NULL.
844  void SetPass(vtkRenderPass* p);
845  vtkGetObjectMacro(Pass, vtkRenderPass);
846 
848 
851  vtkGetObjectMacro(Information, vtkInformation);
852  virtual void SetInformation(vtkInformation*);
854 
856 
862  vtkSetMacro(UseImageBasedLighting, bool);
863  vtkGetMacro(UseImageBasedLighting, bool);
864  vtkBooleanMacro(UseImageBasedLighting, bool);
866 
868 
879  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
880  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
882 
884 
887  vtkGetVector3Macro(EnvironmentUp, double);
888  vtkSetVector3Macro(EnvironmentUp, double);
890 
892 
895  vtkGetVector3Macro(EnvironmentRight, double);
896  vtkSetVector3Macro(EnvironmentRight, double);
898 
899 protected:
900  vtkRenderer();
901  ~vtkRenderer() override;
902 
903  // internal method to expand bounding box to consider model transform
904  // matrix or model view transform matrix based on whether or not deering
905  // frustum is used. 'bounds' buffer is mutated to the expanded box.
906  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
907 
910 
913 
916 
917  double Ambient[3];
920  double TimeFactor;
924  unsigned char* BackingImage;
925  int BackingStoreSize[2];
927 
929 
931 
932  // Allocate the time for each prop
933  void AllocateTime();
934 
935  // Internal variables indicating the number of props
936  // that have been or will be rendered in each category.
938 
939  // A temporary list of props used for culling, and traversal
940  // of all props when rendering
943 
944  // Indicates if the renderer should receive events from an interactor.
945  // Typically only used in conjunction with transparent renderers.
947 
948  // Shows what layer this renderer belongs to. Only of interested when
949  // there are layered renderers.
950  int Layer;
953 
954  // Holds the result of ComputeVisiblePropBounds so that it is visible from
955  // wrapped languages
956  double ComputedVisiblePropBounds[6];
957 
966 
972 
980 
987 
992 
997  const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
998 
1003  const std::array<double, 16>& GetProjectionTransformationMatrix();
1004 
1009  const std::array<double, 16>& GetViewTransformMatrix();
1010 
1016  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
1017 
1025  virtual int UpdateTranslucentPolygonalGeometry();
1026 
1032  virtual int UpdateOpaquePolygonalGeometry();
1033 
1038  virtual int UpdateCamera();
1039 
1045  virtual vtkTypeBool UpdateLightGeometry();
1046 
1051  virtual int UpdateLights() { return 0; }
1052 
1058  vtkCamera* GetActiveCameraAndResetIfCreated();
1059 
1064  bool UseFXAA;
1065 
1070 
1076 
1082 
1090 
1096 
1107 
1114 
1115  bool UseSSAO = false;
1116  double SSAORadius = 0.5;
1117  double SSAOBias = 0.01;
1118  unsigned int SSAOKernelSize = 32;
1119  bool SSAOBlur = false;
1120 
1127 
1128  // HARDWARE SELECTION ----------------------------------------
1129  friend class vtkHardwareSelector;
1130 
1135  {
1136  this->Selector = selector;
1137  this->Modified();
1138  }
1139 
1140  // End Ivars for visible cell selecting.
1142 
1143  //---------------------------------------------------------------
1144  friend class vtkRendererDelegate;
1146 
1150 
1151  friend class vtkRenderPass;
1153 
1154  // Arbitrary extra information associated with this renderer
1156 
1159 
1160  double EnvironmentUp[3];
1161  double EnvironmentRight[3];
1162 
1163 private:
1167  std::array<double, 16> CompositeProjectionTransformationMatrix;
1168 
1172  double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1173 
1177  vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1178 
1182  std::array<double, 16> ProjectionTransformationMatrix;
1183 
1187  double LastProjectionTransformationMatrixTiledAspectRatio;
1188 
1192  vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1193 
1197  std::array<double, 16> ViewTransformMatrix;
1198 
1202  vtkMTimeType LastViewTransformCameraModified;
1203 
1204  vtkRenderer(const vtkRenderer&) = delete;
1205  void operator=(const vtkRenderer&) = delete;
1206 };
1207 
1209 {
1210  return this->Lights;
1211 }
1212 
1217 {
1218  return this->Cullers;
1219 }
1220 
1221 VTK_ABI_NAMESPACE_END
1222 #endif
vtkAssemblyPath * PickProp(double selectionX, double selectionY, int fieldAssociation, vtkSmartPointer< vtkSelection > selection) override
Return the prop (via a vtkAssemblyPath) that has the highest z value at the given x...
Definition: vtkRenderer.h:613
abstract superclass for all actors, volumes and annotations
Definition: vtkProp.h:45
vtkInformation * Information
Definition: vtkRenderer.h:1155
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:971
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off...
Definition: vtkRenderer.h:1075
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:39
virtual void WorldToPose(double &, double &, double &)
These methods map from one coordinate system to another.
Definition: vtkViewport.h:307
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:40
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:595
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:30
Store vtkAlgorithm input/output information.
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:270
abstract specification for Viewports
Definition: vtkViewport.h:44
vtkRenderPass * Pass
Definition: vtkRenderer.h:1152
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:918
double OcclusionRatio
In case of use of depth peeling technique for rendering translucent material, define the threshold un...
Definition: vtkRenderer.h:1106
a actor that draws 2D data
Definition: vtkActor2D.h:34
record modification and/or execution time
Definition: vtkTimeStamp.h:24
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1158
bool UseDepthPeelingForVolumes
This flag is on and the GPU supports it, depth-peel volumes along with the translucent geometry...
Definition: vtkRenderer.h:1095
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:952
vtkTypeBool IsActiveCameraCreated()
This method returns 1 if the ActiveCamera has already been set or automatically created by the render...
Definition: vtkRenderer.h:643
abstract specification for renderers
Definition: vtkRenderer.h:61
vtkTypeBool BackingStore
Definition: vtkRenderer.h:923
double AllocatedRenderTime
Definition: vtkRenderer.h:919
an ordered list of lights
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1145
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:930
vtkTimeStamp RenderTime
Definition: vtkRenderer.h:926
an ordered list of Props
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:921
int vtkTypeBool
Definition: vtkABI.h:64
double LastRenderTimeInSeconds
Definition: vtkRenderer.h:928
window superclass for vtkRenderWindow
Definition: vtkWindow.h:27
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:915
vtkProp ** PropArray
Definition: vtkRenderer.h:941
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:986
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:912
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.
abstract interface to OpenGL FBOs
void SetSelector(vtkHardwareSelector *selector)
Called by vtkHardwareSelector when it begins rendering for selection.
Definition: vtkRenderer.h:1134
double TimeFactor
Definition: vtkRenderer.h:920
a list of nodes that form an assembly path
vtkTypeBool PreserveColorBuffer
Definition: vtkRenderer.h:951
unsigned char * BackingImage
Definition: vtkRenderer.h:924
a superclass for prop cullers
Definition: vtkCuller.h:29
a simple class to control print indentation
Definition: vtkIndent.h:28
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render...
Definition: vtkRenderer.h:628
a virtual camera for 3D rendering
Definition: vtkCamera.h:40
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:908
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:922
a virtual light for 3D rendering
Definition: vtkLight.h:48
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene...
Definition: vtkRenderer.h:1064
virtual vtkMTimeType GetMTime()
Return this object's modified time.
vtkTypeBool UseDepthPeeling
If this flag is on and the GPU supports it, depth peeling is used for rendering translucent materials...
Definition: vtkRenderer.h:1089
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:1208
virtual void PoseToWorld(double &, double &, double &)
These methods map from one coordinate system to another.
Definition: vtkViewport.h:300
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:991
int PropArrayCount
Definition: vtkRenderer.h:942
an ordered list of volumes
virtual int UpdateLights()
Ask all lights to load themselves into rendering pipeline.
Definition: vtkRenderer.h:1051
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:1069
handles properties associated with a texture map
Definition: vtkTexture.h:57
virtual void Modified()
Update the modification time for this object.
vtkTypeBool Interactive
Definition: vtkRenderer.h:946
vtkLightCollection * Lights
Definition: vtkRenderer.h:911
virtual void ViewToPose(double &, double &, double &)
These methods map from one coordinate system to another.
Definition: vtkViewport.h:299
#define VTK_SIZEHINT(...)
vtkActorCollection * Actors
Definition: vtkRenderer.h:914
bool TexturedBackground
Definition: vtkRenderer.h:1147
an ordered list of actors
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1141
virtual void PoseToView(double &, double &, double &)
These methods map from one coordinate system to another.
Definition: vtkViewport.h:306
double NearClippingPlaneTolerance
Specifies the minimum distance of the near clipping plane as a percentage of the far clipping plane d...
Definition: vtkRenderer.h:965
an ordered list of Cullers
virtual void ClearLights()
Internal method temporarily removes lights before reloading them into graphics pipeline.
Definition: vtkRenderer.h:319
create a window for renderers to draw into
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:1081
virtual void ViewToWorld()
Convert view point coordinates to world coordinates.
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:294
Render the props of a vtkRenderer.
bool UseImageBasedLighting
Definition: vtkRenderer.h:1157
vtkTexture * BackgroundTexture
Definition: vtkRenderer.h:1148
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling...
Definition: vtkRenderer.h:1126
vtkCullerCollection * GetCullers()
Return the collection of cullers.
Definition: vtkRenderer.h:1216
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on...
Perform part of the rendering of a vtkRenderer.
Definition: vtkRenderPass.h:48
virtual vtkWindow * GetVTKWindow()=0
Return the vtkWindow that owns this vtkViewport.
int NumberOfPropsRendered
Definition: vtkRenderer.h:937
vtkLight * CreatedLight
Definition: vtkRenderer.h:909
virtual void WorldToView()
Convert world point coordinates to view coordinates.
virtual void Clear()
Clear the image to the background color.
Definition: vtkRenderer.h:324
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1149
Configuration for FXAA implementations.
int MaximumNumberOfPeels
In case of depth peeling, define the maximum number of peeling layers.
Definition: vtkRenderer.h:1113
vtkTypeBool Erase
When this flag is off, the renderer will not erase the background or the Zbuffer. ...
Definition: vtkRenderer.h:979