VTK  9.2.6
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 #include <array> // To store matrices
51 
52 class vtkFXAAOptions;
53 class vtkRenderWindow;
54 class vtkVolume;
55 class vtkCuller;
56 class vtkActor;
57 class vtkActor2D;
58 class vtkCamera;
60 class vtkInformation;
61 class vtkLightCollection;
63 class vtkLight;
66 class vtkRenderPass;
67 class vtkTexture;
68 
69 class vtkRecti;
70 class vtkVector3d;
71 
72 class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
73 {
74 public:
75  vtkTypeMacro(vtkRenderer, vtkViewport);
76  void PrintSelf(ostream& os, vtkIndent indent) override;
77 
83  static vtkRenderer* New();
84 
86 
91  void AddActor(vtkProp* p);
92  void AddVolume(vtkProp* p);
93  void RemoveActor(vtkProp* p);
94  void RemoveVolume(vtkProp* p);
96 
100  void AddLight(vtkLight*);
101 
105  void RemoveLight(vtkLight*);
106 
110  void RemoveAllLights();
111 
115  vtkLightCollection* GetLights();
116 
123  void SetLightCollection(vtkLightCollection* lights);
124 
128  void CreateLight(void);
129 
135  virtual vtkLight* MakeLight();
136 
138 
144  vtkGetMacro(TwoSidedLighting, vtkTypeBool);
145  vtkSetMacro(TwoSidedLighting, vtkTypeBool);
146  vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);
148 
150 
163  vtkSetMacro(LightFollowCamera, vtkTypeBool);
164  vtkGetMacro(LightFollowCamera, vtkTypeBool);
165  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
167 
169 
177  vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
178  vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
179  vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);
181 
187  virtual vtkTypeBool UpdateLightsGeometryToFollowCamera(void);
188 
192  vtkVolumeCollection* GetVolumes();
193 
197  vtkActorCollection* GetActors();
198 
202  void SetActiveCamera(vtkCamera*);
203 
209  vtkCamera* GetActiveCamera();
210 
216  virtual vtkCamera* MakeCamera();
217 
219 
225  vtkSetMacro(Erase, vtkTypeBool);
226  vtkGetMacro(Erase, vtkTypeBool);
227  vtkBooleanMacro(Erase, vtkTypeBool);
229 
231 
236  vtkSetMacro(Draw, vtkTypeBool);
237  vtkGetMacro(Draw, vtkTypeBool);
238  vtkBooleanMacro(Draw, vtkTypeBool);
240 
245  int CaptureGL2PSSpecialProp(vtkProp*);
246 
252  void SetGL2PSSpecialPropCollection(vtkPropCollection*);
253 
257  void AddCuller(vtkCuller*);
258 
262  void RemoveCuller(vtkCuller*);
263 
267  vtkCullerCollection* GetCullers();
268 
270 
273  vtkSetVector3Macro(Ambient, double);
274  vtkGetVectorMacro(Ambient, double, 3);
276 
278 
282  vtkSetMacro(AllocatedRenderTime, double);
283  virtual double GetAllocatedRenderTime();
285 
292  virtual double GetTimeFactor();
293 
300  virtual void Render();
301 
305  virtual void DeviceRender(){};
306 
313  virtual void DeviceRenderOpaqueGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
314 
324  virtual void DeviceRenderTranslucentPolygonalGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
325 
330  virtual void ClearLights(void) {}
331 
335  virtual void Clear() {}
336 
340  int VisibleActorCount();
341 
345  int VisibleVolumeCount();
346 
351  void ComputeVisiblePropBounds(double bounds[6]);
352 
356  double* ComputeVisiblePropBounds() VTK_SIZEHINT(6);
357 
362  virtual void ResetCameraClippingRange();
363 
365 
368  virtual void ResetCameraClippingRange(const double bounds[6]);
369  virtual void ResetCameraClippingRange(
370  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
372 
374 
379  vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
380  vtkGetMacro(NearClippingPlaneTolerance, double);
382 
384 
389  vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
390  vtkGetMacro(ClippingRangeExpansion, double);
392 
399  virtual void ResetCamera();
400 
410  virtual void ResetCamera(const double bounds[6]);
411 
415  virtual void ResetCamera(
416  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
417 
422  virtual void ResetCameraScreenSpace();
423 
429  virtual void ResetCameraScreenSpace(const double bounds[6]);
430 
431  using vtkViewport::DisplayToWorld;
432 
436  vtkVector3d DisplayToWorld(const vtkVector3d& display);
437 
443  void ZoomToBoxUsingViewAngle(const vtkRecti& box, const double offsetRatio = 1.0);
444 
448  virtual void ResetCameraScreenSpace(
449  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
450 
452 
457  void SetRenderWindow(vtkRenderWindow*);
458  vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
459  vtkWindow* GetVTKWindow() override;
461 
463 
469  vtkSetMacro(BackingStore, vtkTypeBool);
470  vtkGetMacro(BackingStore, vtkTypeBool);
471  vtkBooleanMacro(BackingStore, vtkTypeBool);
473 
475 
480  vtkSetMacro(Interactive, vtkTypeBool);
481  vtkGetMacro(Interactive, vtkTypeBool);
482  vtkBooleanMacro(Interactive, vtkTypeBool);
484 
486 
497  virtual void SetLayer(int layer);
498  vtkGetMacro(Layer, int);
500 
502 
512  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
513  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
514  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
516 
518 
522  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
523  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
524  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
526 
531  int Transparent();
532 
536  void WorldToView() override;
537 
539 
542  void ViewToWorld() override;
543  void ViewToWorld(double& wx, double& wy, double& wz) override;
545 
549  void WorldToView(double& wx, double& wy, double& wz) override;
550 
552 
555  void WorldToPose(double& wx, double& wy, double& wz) override;
556  void PoseToWorld(double& wx, double& wy, double& wz) override;
557  void ViewToPose(double& wx, double& wy, double& wz) override;
558  void PoseToView(double& wx, double& wy, double& wz) override;
560 
565  double GetZ(int x, int y);
566 
570  vtkMTimeType GetMTime() override;
571 
573 
576  vtkGetMacro(LastRenderTimeInSeconds, double);
578 
580 
586  vtkGetMacro(NumberOfPropsRendered, int);
588 
590 
597  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
598  {
599  return this->PickProp(selectionX, selectionY, selectionX, selectionY);
600  }
602  double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
604 
606 
615  vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
616  vtkSmartPointer<vtkSelection> selection) override
617  {
618  return this->PickProp(
619  selectionX, selectionY, selectionX, selectionY, fieldAssociation, selection);
620  }
621  vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
622  double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) override;
624 
630  virtual void StereoMidpoint() { return; }
631 
638  double GetTiledAspectRatio();
639 
645  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
646 
648 
658  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
659  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
660  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
662 
668  vtkSetMacro(UseDepthPeelingForVolumes, bool);
669  vtkGetMacro(UseDepthPeelingForVolumes, bool);
670  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
671 
673 
682  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
683  vtkGetMacro(OcclusionRatio, double);
685 
687 
692  vtkSetMacro(MaximumNumberOfPeels, int);
693  vtkGetMacro(MaximumNumberOfPeels, int);
695 
697 
702  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
704 
706 
710  vtkSetMacro(UseSSAO, bool);
711  vtkGetMacro(UseSSAO, bool);
712  vtkBooleanMacro(UseSSAO, bool);
714 
716 
720  vtkSetMacro(SSAORadius, double);
721  vtkGetMacro(SSAORadius, double);
723 
725 
729  vtkSetMacro(SSAOBias, double);
730  vtkGetMacro(SSAOBias, double);
732 
734 
738  vtkSetMacro(SSAOKernelSize, unsigned int);
739  vtkGetMacro(SSAOKernelSize, unsigned int);
741 
743 
748  vtkSetMacro(SSAOBlur, bool);
749  vtkGetMacro(SSAOBlur, bool);
750  vtkBooleanMacro(SSAOBlur, bool);
752 
754 
760  void SetDelegate(vtkRendererDelegate* d);
761  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
763 
765 
770  vtkGetObjectMacro(Selector, vtkHardwareSelector);
772 
774 
779  virtual void SetLeftBackgroundTexture(vtkTexture*);
780  vtkTexture* GetLeftBackgroundTexture();
781  virtual void SetBackgroundTexture(vtkTexture*);
782  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
784 
786 
790  virtual void SetRightBackgroundTexture(vtkTexture*);
791  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
793 
795 
799  vtkSetMacro(TexturedBackground, bool);
800  vtkGetMacro(TexturedBackground, bool);
801  vtkBooleanMacro(TexturedBackground, bool);
803 
804  // method to release graphics resources in any derived renderers.
805  virtual void ReleaseGraphicsResources(vtkWindow*);
806 
808 
811  vtkSetMacro(UseFXAA, bool);
812  vtkGetMacro(UseFXAA, bool);
813  vtkBooleanMacro(UseFXAA, bool);
815 
817 
820  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
821  virtual void SetFXAAOptions(vtkFXAAOptions*);
823 
825 
829  vtkSetMacro(UseShadows, vtkTypeBool);
830  vtkGetMacro(UseShadows, vtkTypeBool);
831  vtkBooleanMacro(UseShadows, vtkTypeBool);
833 
835 
839  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
840  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
841  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
843 
844  // Set/Get a custom render pass.
845  // Initial value is NULL.
846  void SetPass(vtkRenderPass* p);
847  vtkGetObjectMacro(Pass, vtkRenderPass);
848 
850 
853  vtkGetObjectMacro(Information, vtkInformation);
854  virtual void SetInformation(vtkInformation*);
856 
858 
864  vtkSetMacro(UseImageBasedLighting, bool);
865  vtkGetMacro(UseImageBasedLighting, bool);
866  vtkBooleanMacro(UseImageBasedLighting, bool);
868 
870 
881  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
882  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
884 
886 
889  vtkGetVector3Macro(EnvironmentUp, double);
890  vtkSetVector3Macro(EnvironmentUp, double);
892 
894 
897  vtkGetVector3Macro(EnvironmentRight, double);
898  vtkSetVector3Macro(EnvironmentRight, double);
900 
901 protected:
902  vtkRenderer();
903  ~vtkRenderer() override;
904 
905  // internal method to expand bounding box to consider model transform
906  // matrix or model view transform matrix based on whether or not deering
907  // frustum is used. 'bounds' buffer is mutated to the expanded box.
908  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
909 
912 
915 
918 
919  double Ambient[3];
922  double TimeFactor;
926  unsigned char* BackingImage;
927  int BackingStoreSize[2];
929 
931 
933 
934  // Allocate the time for each prop
935  void AllocateTime();
936 
937  // Internal variables indicating the number of props
938  // that have been or will be rendered in each category.
940 
941  // A temporary list of props used for culling, and traversal
942  // of all props when rendering
945 
946  // Indicates if the renderer should receive events from an interactor.
947  // Typically only used in conjunction with transparent renderers.
949 
950  // Shows what layer this renderer belongs to. Only of interested when
951  // there are layered renderers.
952  int Layer;
955 
956  // Holds the result of ComputeVisiblePropBounds so that it is visible from
957  // wrapped languages
958  double ComputedVisiblePropBounds[6];
959 
968 
974 
982 
989 
994 
999  const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
1000 
1005  const std::array<double, 16>& GetProjectionTransformationMatrix();
1006 
1011  const std::array<double, 16>& GetViewTransformMatrix();
1012 
1018  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
1019 
1027  virtual int UpdateTranslucentPolygonalGeometry();
1028 
1034  virtual int UpdateOpaquePolygonalGeometry();
1035 
1040  virtual int UpdateCamera(void);
1041 
1047  virtual vtkTypeBool UpdateLightGeometry(void);
1048 
1053  virtual int UpdateLights(void) { return 0; }
1054 
1060  vtkCamera* GetActiveCameraAndResetIfCreated();
1061 
1066  bool UseFXAA;
1067 
1072 
1078 
1084 
1092 
1098 
1109 
1116 
1117  bool UseSSAO = false;
1118  double SSAORadius = 0.5;
1119  double SSAOBias = 0.01;
1120  unsigned int SSAOKernelSize = 32;
1121  bool SSAOBlur = false;
1122 
1129 
1130  // HARDWARE SELECTION ----------------------------------------
1131  friend class vtkHardwareSelector;
1132 
1137  {
1138  this->Selector = selector;
1139  this->Modified();
1140  }
1141 
1142  // End Ivars for visible cell selecting.
1144 
1145  //---------------------------------------------------------------
1146  friend class vtkRendererDelegate;
1148 
1152 
1153  friend class vtkRenderPass;
1155 
1156  // Arbitrary extra information associated with this renderer
1158 
1161 
1162  double EnvironmentUp[3];
1163  double EnvironmentRight[3];
1164 
1165 private:
1169  std::array<double, 16> CompositeProjectionTransformationMatrix;
1170 
1174  double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1175 
1179  vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1180 
1184  std::array<double, 16> ProjectionTransformationMatrix;
1185 
1189  double LastProjectionTransformationMatrixTiledAspectRatio;
1190 
1194  vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1195 
1199  std::array<double, 16> ViewTransformMatrix;
1200 
1204  vtkMTimeType LastViewTransformCameraModified;
1205 
1206  vtkRenderer(const vtkRenderer&) = delete;
1207  void operator=(const vtkRenderer&) = delete;
1208 };
1209 
1211 {
1212  return this->Lights;
1213 }
1214 
1219 {
1220  return this->Cullers;
1221 }
1222 
1223 #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:615
abstract superclass for all actors, volumes and annotations
Definition: vtkProp.h:56
vtkInformation * Information
Definition: vtkRenderer.h:1157
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:973
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off...
Definition: vtkRenderer.h:1077
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:50
virtual void WorldToPose(double &, double &, double &)
These methods map from one coordinate system to another.
Definition: vtkViewport.h:281
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:51
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:597
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:41
Store vtkAlgorithm input/output information.
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:287
abstract specification for Viewports
Definition: vtkViewport.h:55
vtkRenderPass * Pass
Definition: vtkRenderer.h:1154
virtual void ClearLights(void)
Internal method temporarily removes lights before reloading them into graphics pipeline.
Definition: vtkRenderer.h:330
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:920
double OcclusionRatio
In case of use of depth peeling technique for rendering translucent material, define the threshold un...
Definition: vtkRenderer.h:1108
virtual int UpdateLights(void)
Ask all lights to load themselves into rendering pipeline.
Definition: vtkRenderer.h:1053
a actor that draws 2D data
Definition: vtkActor2D.h:45
record modification and/or execution time
Definition: vtkTimeStamp.h:35
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1160
bool UseDepthPeelingForVolumes
This flag is on and the GPU supports it, depth-peel volumes along with the translucent geometry...
Definition: vtkRenderer.h:1097
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:954
vtkTypeBool IsActiveCameraCreated()
This method returns 1 if the ActiveCamera has already been set or automatically created by the render...
Definition: vtkRenderer.h:645
abstract specification for renderers
Definition: vtkRenderer.h:72
vtkTypeBool BackingStore
Definition: vtkRenderer.h:925
double AllocatedRenderTime
Definition: vtkRenderer.h:921
an ordered list of lights
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1147
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:932
vtkTimeStamp RenderTime
Definition: vtkRenderer.h:928
an ordered list of Props
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:923
int vtkTypeBool
Definition: vtkABI.h:69
double LastRenderTimeInSeconds
Definition: vtkRenderer.h:930
window superclass for vtkRenderWindow
Definition: vtkWindow.h:38
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:917
vtkProp ** PropArray
Definition: vtkRenderer.h:943
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:988
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:914
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:1136
double TimeFactor
Definition: vtkRenderer.h:922
a list of nodes that form an assembly path
vtkTypeBool PreserveColorBuffer
Definition: vtkRenderer.h:953
unsigned char * BackingImage
Definition: vtkRenderer.h:926
a superclass for prop cullers
Definition: vtkCuller.h:40
a simple class to control print indentation
Definition: vtkIndent.h:39
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render...
Definition: vtkRenderer.h:630
a virtual camera for 3D rendering
Definition: vtkCamera.h:51
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:910
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:924
a virtual light for 3D rendering
Definition: vtkLight.h:59
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene...
Definition: vtkRenderer.h:1066
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:1091
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:1210
virtual void PoseToWorld(double &, double &, double &)
These methods map from one coordinate system to another.
Definition: vtkViewport.h:274
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:993
int PropArrayCount
Definition: vtkRenderer.h:944
an ordered list of volumes
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:1071
handles properties associated with a texture map
Definition: vtkTexture.h:68
virtual void Modified()
Update the modification time for this object.
vtkTypeBool Interactive
Definition: vtkRenderer.h:948
vtkLightCollection * Lights
Definition: vtkRenderer.h:913
virtual void ViewToPose(double &, double &, double &)
These methods map from one coordinate system to another.
Definition: vtkViewport.h:273
#define VTK_SIZEHINT(...)
vtkActorCollection * Actors
Definition: vtkRenderer.h:916
bool TexturedBackground
Definition: vtkRenderer.h:1149
an ordered list of actors
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1143
virtual void PoseToView(double &, double &, double &)
These methods map from one coordinate system to another.
Definition: vtkViewport.h:280
double NearClippingPlaneTolerance
Specifies the minimum distance of the near clipping plane as a percentage of the far clipping plane d...
Definition: vtkRenderer.h:967
an ordered list of Cullers
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:1083
virtual void ViewToWorld()
Convert view point coordinates to world coordinates.
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:305
Render the props of a vtkRenderer.
bool UseImageBasedLighting
Definition: vtkRenderer.h:1159
vtkTexture * BackgroundTexture
Definition: vtkRenderer.h:1150
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling...
Definition: vtkRenderer.h:1128
vtkCullerCollection * GetCullers()
Return the collection of cullers.
Definition: vtkRenderer.h:1218
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:59
virtual vtkWindow * GetVTKWindow()=0
Return the vtkWindow that owns this vtkViewport.
int NumberOfPropsRendered
Definition: vtkRenderer.h:939
vtkLight * CreatedLight
Definition: vtkRenderer.h:911
virtual void WorldToView()
Convert world point coordinates to view coordinates.
virtual void Clear()
Clear the image to the background color.
Definition: vtkRenderer.h:335
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1151
Configuration for FXAA implementations.
int MaximumNumberOfPeels
In case of depth peeling, define the maximum number of peeling layers.
Definition: vtkRenderer.h:1115
vtkTypeBool Erase
When this flag is off, the renderer will not erase the background or the Zbuffer. ...
Definition: vtkRenderer.h:981