VTK  9.3.0
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);
85 
90 
95 
100 
104  vtkLightCollection* GetLights();
105 
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 
177 
182 
187 
192 
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 
235 
242 
247 
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 
303 
314 
319  virtual void ClearLights() {}
320 
324  virtual void Clear() {}
325 
330 
335 
340  void ComputeVisiblePropBounds(double bounds[6]);
341 
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 
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 
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 
759  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
761 
763 
768  vtkGetObjectMacro(Selector, vtkHardwareSelector);
770 
772 
780  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
782 
784 
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.
804 
806 
809  vtkSetMacro(UseFXAA, bool);
810  vtkGetMacro(UseFXAA, bool);
811  vtkBooleanMacro(UseFXAA, bool);
813 
815 
818  vtkGetObjectMacro(FXAAOptions, 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.
845  vtkGetObjectMacro(Pass, vtkRenderPass);
846 
848 
851  vtkGetObjectMacro(Information, 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:
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 
1026 
1033 
1038  virtual int UpdateCamera();
1039 
1046 
1051  virtual int UpdateLights() { return 0; }
1052 
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
a actor that draws 2D data
Definition: vtkActor2D.h:35
an ordered list of actors
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:41
a list of nodes that form an assembly path
a virtual camera for 3D rendering
Definition: vtkCamera.h:41
an ordered list of Cullers
a superclass for prop cullers
Definition: vtkCuller.h:30
Configuration for FXAA implementations.
abstract interface to OpenGL FBOs
a simple class to control print indentation
Definition: vtkIndent.h:29
Store vtkAlgorithm input/output information.
an ordered list of lights
a virtual light for 3D rendering
Definition: vtkLight.h:49
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:31
virtual void Modified()
Update the modification time for this object.
an ordered list of Props
abstract superclass for all actors, volumes and annotations
Definition: vtkProp.h:46
Perform part of the rendering of a vtkRenderer.
Definition: vtkRenderPass.h:49
create a window for renderers to draw into
Render the props of a vtkRenderer.
abstract specification for renderers
Definition: vtkRenderer.h:62
void RemoveVolume(vtkProp *p)
Add/Remove different types of props to the renderer.
virtual void SetLayer(int layer)
Set/Get the layer that this renderer belongs to.
void ViewToWorld(double &wx, double &wy, double &wz) override
Convert view point coordinates to world coordinates.
virtual void SetFXAAOptions(vtkFXAAOptions *)
The configuration object for FXAA antialiasing.
const std::array< double, 16 > & GetViewTransformMatrix()
Gets the ActiveCamera ViewTransformMatrix, only computing it if necessary.
virtual int UpdateCamera()
Ask the active camera to do whatever it needs to do prior to rendering.
void AddCuller(vtkCuller *)
Add an culler to the list of cullers.
virtual vtkTypeBool UpdateLightGeometry()
Update the geometry of the lights in the scene that are not in world space (for instance,...
void SetPass(vtkRenderPass *p)
virtual int UpdateLights()
Ask all lights to load themselves into rendering pipeline.
Definition: vtkRenderer.h:1051
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:952
vtkLight * CreatedLight
Definition: vtkRenderer.h:909
vtkRenderPass * Pass
Definition: vtkRenderer.h:1152
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:1075
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
static vtkRenderer * New()
Create a vtkRenderer with a black background, a white ambient light, two-sided lighting turned on,...
double LastRenderTimeInSeconds
Definition: vtkRenderer.h:928
double GetTiledAspectRatio()
Compute the aspect ratio of this renderer for the current tile.
void CreateLight()
Create and add a light to renderer.
vtkCamera * GetActiveCameraAndResetIfCreated()
Get the current camera and reset it only if it gets created automatically (see GetActiveCamera).
void AddLight(vtkLight *)
Add a light to the list of lights.
vtkCullerCollection * GetCullers()
Return the collection of cullers.
Definition: vtkRenderer.h:1216
virtual vtkLight * MakeLight()
Create a new Light sutible for use with this type of Renderer.
virtual void SetRightBackgroundTexture(vtkTexture *)
Set/Get the texture to be used for the right eye background.
virtual void SetInformation(vtkInformation *)
Set/Get the information object associated with this algorithm.
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
~vtkRenderer() override
virtual int UpdateGeometry(vtkFrameBufferObjectBase *fbo=nullptr)
Ask all props to update and draw any opaque and translucent geometry.
vtkWindow * GetVTKWindow() override
Specify the rendering window in which to draw.
vtkActorCollection * GetActors()
Return any actors in this renderer.
bool UseImageBasedLighting
Definition: vtkRenderer.h:1157
int VisibleActorCount()
Returns the number of visible actors.
vtkTypeBool BackingStore
Definition: vtkRenderer.h:923
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1158
void RemoveLight(vtkLight *)
Remove a light from the list of lights.
bool UseDepthPeelingForVolumes
This flag is on and the GPU supports it, depth-peel volumes along with the translucent geometry.
Definition: vtkRenderer.h:1095
void RemoveActor(vtkProp *p)
Add/Remove different types of props to the renderer.
virtual void SetLeftBackgroundTexture(vtkTexture *)
Set/Get the texture to be used for the monocular or stereo left eye background.
void SetSelector(vtkHardwareSelector *selector)
Called by vtkHardwareSelector when it begins rendering for selection.
Definition: vtkRenderer.h:1134
vtkMTimeType GetMTime() override
Return the MTime of the renderer also considering its ivars.
int MaximumNumberOfPeels
In case of depth peeling, define the maximum number of peeling layers.
Definition: vtkRenderer.h:1113
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
Definition: vtkRenderer.h:1126
void AllocateTime()
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:918
int VisibleVolumeCount()
Returns the number of visible volumes.
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:922
int NumberOfPropsRendered
Definition: vtkRenderer.h:937
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
Definition: vtkRenderer.h:628
virtual int UpdateOpaquePolygonalGeometry()
Ask all props to update and draw any opaque polygonal geometry.
double TimeFactor
Definition: vtkRenderer.h:920
bool TexturedBackground
Definition: vtkRenderer.h:1147
vtkAssemblyPath * PickProp(double selectionX1, double selectionY1, double selectionX2, double selectionY2, int fieldAssociation, vtkSmartPointer< vtkSelection > selection) override
Return the prop (via a vtkAssemblyPath) that has the highest z value at the given x,...
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:915
virtual void ExpandBounds(double bounds[6], vtkMatrix4x4 *matrix)
void RemoveCuller(vtkCuller *)
Remove an actor from the list of cullers.
double OcclusionRatio
In case of use of depth peeling technique for rendering translucent material, define the threshold un...
Definition: vtkRenderer.h:1106
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
void PoseToView(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkTypeBool Erase
When this flag is off, the renderer will not erase the background or the Zbuffer.
Definition: vtkRenderer.h:979
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:991
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
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:971
int CaptureGL2PSSpecialProp(vtkProp *)
This function is called to capture an instance of vtkProp that requires special handling during vtkRe...
vtkTypeBool Transparent()
Returns a boolean indicating if this renderer is transparent.
vtkTypeBool IsActiveCameraCreated()
This method returns 1 if the ActiveCamera has already been set or automatically created by the render...
Definition: vtkRenderer.h:643
unsigned char * BackingImage
Definition: vtkRenderer.h:924
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1145
void SetLightCollection(vtkLightCollection *lights)
Set the collection of lights.
virtual void ReleaseGraphicsResources(vtkWindow *)
void PoseToWorld(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
void RemoveAllLights()
Remove all lights from the list of lights.
vtkTexture * BackgroundTexture
Definition: vtkRenderer.h:1148
virtual vtkCamera * MakeCamera()
Create a new Camera sutible for use with this type of Renderer.
double GetZ(int x, int y)
Given a pixel location, return the Z value.
vtkProp ** PropArray
Definition: vtkRenderer.h:941
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:912
vtkCamera * GetActiveCamera()
Get the current camera.
void AddActor(vtkProp *p)
Add/Remove different types of props to the renderer.
int PropArrayCount
Definition: vtkRenderer.h:942
virtual double GetTimeFactor()
Get the ratio between allocated time and actual render time.
double AllocatedRenderTime
Definition: vtkRenderer.h:919
const std::array< double, 16 > & GetProjectionTransformationMatrix()
Gets the ActiveCamera ProjectionTransformationMatrix, only computing it if necessary.
double NearClippingPlaneTolerance
Specifies the minimum distance of the near clipping plane as a percentage of the far clipping plane d...
Definition: vtkRenderer.h:965
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:986
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1141
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:294
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:921
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1149
virtual vtkTypeBool UpdateLightsGeometryToFollowCamera()
Ask the lights in the scene that are not in world space (for instance, Headlights or CameraLights tha...
vtkTypeBool UseDepthPeeling
If this flag is on and the GPU supports it, depth peeling is used for rendering translucent materials...
Definition: vtkRenderer.h:1089
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:1081
void WorldToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkLightCollection * Lights
Definition: vtkRenderer.h:911
vtkTexture * GetLeftBackgroundTexture()
Set/Get the texture to be used for the monocular or stereo left eye background.
void ViewToWorld() override
Convert view point coordinates to world coordinates.
vtkVolumeCollection * GetVolumes()
Return the collection of volumes.
void SetActiveCamera(vtkCamera *)
Specify the camera to use for this renderer.
virtual void SetEnvironmentTexture(vtkTexture *texture, bool isSRGB=false)
Set/Get the environment texture used for image based lighting.
vtkTimeStamp RenderTime
Definition: vtkRenderer.h:926
virtual void Render()
CALLED BY vtkRenderWindow ONLY.
virtual int UpdateTranslucentPolygonalGeometry()
Ask all props to update and draw any translucent polygonal geometry.
virtual void ClearLights()
Internal method temporarily removes lights before reloading them into graphics pipeline.
Definition: vtkRenderer.h:319
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:1208
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:930
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:1069
void ViewToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
void WorldToView() override
Convert world point coordinates to view coordinates.
virtual void DeviceRenderOpaqueGeometry(vtkFrameBufferObjectBase *fbo=nullptr)
Render opaque polygonal geometry.
vtkAssemblyPath * PickProp(double selectionX1, double selectionY1, double selectionX2, double selectionY2) override
Return the prop (via a vtkAssemblyPath) that has the highest z value at the given x,...
virtual void SetBackgroundTexture(vtkTexture *)
Set/Get the texture to be used for the monocular or stereo left eye background.
void AddVolume(vtkProp *p)
Add/Remove different types of props to the renderer.
void WorldToView(double &wx, double &wy, double &wz) override
Convert world point coordinates to view coordinates.
virtual double GetAllocatedRenderTime()
Set/Get the amount of time this renderer is allowed to spend rendering its scene.
virtual void Clear()
Clear the image to the background color.
Definition: vtkRenderer.h:324
void ComputeVisiblePropBounds(double bounds[6])
Compute the bounding box of all the visible props Used in ResetCamera() and ResetCameraClippingRange(...
virtual void DeviceRenderTranslucentPolygonalGeometry(vtkFrameBufferObjectBase *fbo=nullptr)
Render translucent polygonal geometry.
vtkTypeBool PreserveColorBuffer
Definition: vtkRenderer.h:951
void SetGL2PSSpecialPropCollection(vtkPropCollection *)
Set the prop collection object used during vtkRenderWindow::CaptureGL2PSSpecialProps().
vtkActorCollection * Actors
Definition: vtkRenderer.h:914
void SetDelegate(vtkRendererDelegate *d)
Set/Get a custom Render call.
vtkTypeBool Interactive
Definition: vtkRenderer.h:946
vtkInformation * Information
Definition: vtkRenderer.h:1155
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:908
const std::array< double, 16 > & GetCompositeProjectionTransformationMatrix()
Gets the ActiveCamera CompositeProjectionTransformationMatrix, only computing it if necessary.
handles properties associated with a texture map
Definition: vtkTexture.h:58
record modification and/or execution time
Definition: vtkTimeStamp.h:25
abstract specification for Viewports
Definition: vtkViewport.h:45
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.
an ordered list of volumes
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:40
window superclass for vtkRenderWindow
Definition: vtkWindow.h:28
int vtkTypeBool
Definition: vtkABI.h:64
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:270
#define VTK_SIZEHINT(...)