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
38 #ifndef vtkRenderer_h
39 #define vtkRenderer_h
40 
41 #include "vtkRenderingCoreModule.h" // For export macro
42 #include "vtkViewport.h"
43 
44 #include "vtkActorCollection.h" // Needed for access in inline members
45 #include "vtkVolumeCollection.h" // Needed for access in inline members
46 
47 #include <array> // To store matrices
48 
49 VTK_ABI_NAMESPACE_BEGIN
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 vtkRecti;
68 class vtkVector3d;
69 
70 class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
71 {
72 public:
73  vtkTypeMacro(vtkRenderer, vtkViewport);
74  void PrintSelf(ostream& os, vtkIndent indent) override;
75 
81  static vtkRenderer* New();
82 
84 
89  void AddActor(vtkProp* p);
90  void AddVolume(vtkProp* p);
91  void RemoveActor(vtkProp* p);
94 
99 
104 
109 
113  vtkLightCollection* GetLights();
114 
122 
126  void CreateLight();
127 
133  virtual vtkLight* MakeLight();
134 
136 
142  vtkGetMacro(TwoSidedLighting, vtkTypeBool);
143  vtkSetMacro(TwoSidedLighting, vtkTypeBool);
144  vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);
146 
148 
161  vtkSetMacro(LightFollowCamera, vtkTypeBool);
162  vtkGetMacro(LightFollowCamera, vtkTypeBool);
163  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
165 
167 
175  vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
176  vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
177  vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);
179 
186 
191 
196 
201 
208 
214  virtual vtkCamera* MakeCamera();
215 
217 
223  vtkSetMacro(Erase, vtkTypeBool);
224  vtkGetMacro(Erase, vtkTypeBool);
225  vtkBooleanMacro(Erase, vtkTypeBool);
227 
229 
234  vtkSetMacro(Draw, vtkTypeBool);
235  vtkGetMacro(Draw, vtkTypeBool);
236  vtkBooleanMacro(Draw, vtkTypeBool);
238 
244 
251 
256 
261 
265  vtkCullerCollection* GetCullers();
266 
268 
271  vtkSetVector3Macro(Ambient, double);
272  vtkGetVectorMacro(Ambient, double, 3);
274 
276 
280  vtkSetMacro(AllocatedRenderTime, double);
281  virtual double GetAllocatedRenderTime();
283 
290  virtual double GetTimeFactor();
291 
298  virtual void Render();
299 
303  virtual void DeviceRender(){};
304 
312 
323 
328  virtual void ClearLights() {}
329 
333  virtual void Clear() {}
334 
339 
344 
349  void ComputeVisiblePropBounds(double bounds[6]);
350 
355 
360  virtual void ResetCameraClippingRange();
361 
363 
366  virtual void ResetCameraClippingRange(const double bounds[6]);
367  virtual void ResetCameraClippingRange(
368  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
370 
372 
377  vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
378  vtkGetMacro(NearClippingPlaneTolerance, double);
380 
382 
387  vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
388  vtkGetMacro(ClippingRangeExpansion, double);
390 
397  virtual void ResetCamera();
398 
408  virtual void ResetCamera(const double bounds[6]);
409 
413  virtual void ResetCamera(
414  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
415 
423  virtual void ResetCameraScreenSpace(double offsetRatio = 0.9);
424 
433  virtual void ResetCameraScreenSpace(const double bounds[6], double offsetRatio = 0.9);
434 
435  using vtkViewport::DisplayToWorld;
436 
440  vtkVector3d DisplayToWorld(const vtkVector3d& display);
441 
447  void ZoomToBoxUsingViewAngle(const vtkRecti& box, double offsetRatio = 1.0);
448 
455  virtual void ResetCameraScreenSpace(double xmin, double xmax, double ymin, double ymax,
456  double zmin, double zmax, double offsetRatio = 0.9);
457 
459 
464  void SetRenderWindow(vtkRenderWindow*);
465  vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
466  vtkWindow* GetVTKWindow() override;
468 
470 
476  vtkSetMacro(BackingStore, vtkTypeBool);
477  vtkGetMacro(BackingStore, vtkTypeBool);
478  vtkBooleanMacro(BackingStore, vtkTypeBool);
480 
482 
487  vtkSetMacro(Interactive, vtkTypeBool);
488  vtkGetMacro(Interactive, vtkTypeBool);
489  vtkBooleanMacro(Interactive, vtkTypeBool);
491 
493 
504  virtual void SetLayer(int layer);
505  vtkGetMacro(Layer, int);
507 
509 
519  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
520  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
521  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
523 
525 
529  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
530  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
531  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
533 
539 
543  void WorldToView() override;
544 
546 
549  void ViewToWorld() override;
550  void ViewToWorld(double& wx, double& wy, double& wz) override;
552 
556  void WorldToView(double& wx, double& wy, double& wz) override;
557 
559 
562  void WorldToPose(double& wx, double& wy, double& wz) override;
563  void PoseToWorld(double& wx, double& wy, double& wz) override;
564  void ViewToPose(double& wx, double& wy, double& wz) override;
565  void PoseToView(double& wx, double& wy, double& wz) override;
567 
572  double GetZ(int x, int y);
573 
577  vtkMTimeType GetMTime() override;
578 
580 
583  vtkGetMacro(LastRenderTimeInSeconds, double);
585 
587 
593  vtkGetMacro(NumberOfPropsRendered, int);
595 
597 
604  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
605  {
606  return this->PickProp(selectionX, selectionY, selectionX, selectionY);
607  }
609  double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
611 
613 
622  vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
623  vtkSmartPointer<vtkSelection> selection) override
624  {
625  return this->PickProp(
626  selectionX, selectionY, selectionX, selectionY, fieldAssociation, selection);
627  }
628  vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
629  double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) override;
631 
637  virtual void StereoMidpoint() {}
638 
646 
652  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
653 
655 
665  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
666  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
667  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
669 
675  vtkSetMacro(UseDepthPeelingForVolumes, bool);
676  vtkGetMacro(UseDepthPeelingForVolumes, bool);
677  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
678 
680 
689  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
690  vtkGetMacro(OcclusionRatio, double);
692 
694 
699  vtkSetMacro(MaximumNumberOfPeels, int);
700  vtkGetMacro(MaximumNumberOfPeels, int);
702 
704 
709  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
711 
713 
717  vtkSetMacro(UseSSAO, bool);
718  vtkGetMacro(UseSSAO, bool);
719  vtkBooleanMacro(UseSSAO, bool);
721 
723 
727  vtkSetMacro(SSAORadius, double);
728  vtkGetMacro(SSAORadius, double);
730 
732 
736  vtkSetMacro(SSAOBias, double);
737  vtkGetMacro(SSAOBias, double);
739 
741 
745  vtkSetMacro(SSAOKernelSize, unsigned int);
746  vtkGetMacro(SSAOKernelSize, unsigned int);
748 
750 
755  vtkSetMacro(SSAOBlur, bool);
756  vtkGetMacro(SSAOBlur, bool);
757  vtkBooleanMacro(SSAOBlur, bool);
759 
761 
768  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
770 
772 
777  vtkGetObjectMacro(Selector, vtkHardwareSelector);
779 
781 
789  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
791 
793 
798  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
800 
802 
806  vtkSetMacro(TexturedBackground, bool);
807  vtkGetMacro(TexturedBackground, bool);
808  vtkBooleanMacro(TexturedBackground, bool);
810 
811  // method to release graphics resources in any derived renderers.
813 
815 
818  vtkSetMacro(UseFXAA, bool);
819  vtkGetMacro(UseFXAA, bool);
820  vtkBooleanMacro(UseFXAA, bool);
822 
824 
827  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
830 
832 
836  vtkSetMacro(UseShadows, vtkTypeBool);
837  vtkGetMacro(UseShadows, vtkTypeBool);
838  vtkBooleanMacro(UseShadows, vtkTypeBool);
840 
842 
846  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
847  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
848  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
850 
851  // Set/Get a custom render pass.
852  // Initial value is NULL.
854  vtkGetObjectMacro(Pass, vtkRenderPass);
855 
857 
860  vtkGetObjectMacro(Information, vtkInformation);
863 
865 
871  vtkSetMacro(UseImageBasedLighting, bool);
872  vtkGetMacro(UseImageBasedLighting, bool);
873  vtkBooleanMacro(UseImageBasedLighting, bool);
875 
877 
888  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
889  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
891 
893 
896  vtkGetVector3Macro(EnvironmentUp, double);
897  vtkSetVector3Macro(EnvironmentUp, double);
899 
901 
904  vtkGetVector3Macro(EnvironmentRight, double);
905  vtkSetVector3Macro(EnvironmentRight, double);
907 
908 protected:
910  ~vtkRenderer() override;
911 
912  // internal method to expand bounding box to consider model transform
913  // matrix or model view transform matrix based on whether or not deering
914  // frustum is used. 'bounds' buffer is mutated to the expanded box.
915  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
916 
919 
922 
925 
926  double Ambient[3];
929  double TimeFactor;
933  unsigned char* BackingImage;
934  int BackingStoreSize[2];
936 
938 
940 
941  // Allocate the time for each prop
942  void AllocateTime();
943 
944  // Internal variables indicating the number of props
945  // that have been or will be rendered in each category.
947 
948  // A temporary list of props used for culling, and traversal
949  // of all props when rendering
952 
953  // Indicates if the renderer should receive events from an interactor.
954  // Typically only used in conjunction with transparent renderers.
956 
957  // Shows what layer this renderer belongs to. Only of interested when
958  // there are layered renderers.
959  int Layer;
962 
963  // Holds the result of ComputeVisiblePropBounds so that it is visible from
964  // wrapped languages
965  double ComputedVisiblePropBounds[6];
966 
975 
981 
989 
996 
1001 
1006  const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
1007 
1012  const std::array<double, 16>& GetProjectionTransformationMatrix();
1013 
1018  const std::array<double, 16>& GetViewTransformMatrix();
1019 
1025  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
1026 
1035 
1042 
1047  virtual int UpdateCamera();
1048 
1055 
1060  virtual int UpdateLights() { return 0; }
1061 
1068 
1073  bool UseFXAA;
1074 
1079 
1085 
1091 
1099 
1105 
1116 
1123 
1124  bool UseSSAO = false;
1125  double SSAORadius = 0.5;
1126  double SSAOBias = 0.01;
1127  unsigned int SSAOKernelSize = 32;
1128  bool SSAOBlur = false;
1129 
1136 
1137  // HARDWARE SELECTION ----------------------------------------
1138  friend class vtkHardwareSelector;
1139 
1144  {
1145  this->Selector = selector;
1146  this->Modified();
1147  }
1148 
1149  // End Ivars for visible cell selecting.
1151 
1152  //---------------------------------------------------------------
1153  friend class vtkRendererDelegate;
1155 
1159 
1160  friend class vtkRenderPass;
1162 
1163  // Arbitrary extra information associated with this renderer
1165 
1168 
1169  double EnvironmentUp[3];
1170  double EnvironmentRight[3];
1171 
1172 private:
1176  std::array<double, 16> CompositeProjectionTransformationMatrix;
1177 
1181  double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1182 
1186  vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1187 
1191  std::array<double, 16> ProjectionTransformationMatrix;
1192 
1196  double LastProjectionTransformationMatrixTiledAspectRatio;
1197 
1201  vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1202 
1206  std::array<double, 16> ViewTransformMatrix;
1207 
1211  vtkMTimeType LastViewTransformCameraModified;
1212 
1213  vtkRenderer(const vtkRenderer&) = delete;
1214  void operator=(const vtkRenderer&) = delete;
1215 };
1216 
1218 {
1219  return this->Lights;
1220 }
1221 
1226 {
1227  return this->Cullers;
1228 }
1229 
1230 VTK_ABI_NAMESPACE_END
1231 #endif
a actor that draws 2D data
Definition: vtkActor2D.h:44
an ordered list of actors
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:50
a list of nodes that form an assembly path
a virtual camera for 3D rendering
Definition: vtkCamera.h:50
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:38
Store vtkAlgorithm input/output information.
an ordered list of lights
a virtual light for 3D rendering
Definition: vtkLight.h:58
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:40
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:55
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:71
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:1060
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:961
vtkLight * CreatedLight
Definition: vtkRenderer.h:918
vtkRenderPass * Pass
Definition: vtkRenderer.h:1161
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:1084
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:937
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:1225
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:622
~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:1166
int VisibleActorCount()
Returns the number of visible actors.
vtkTypeBool BackingStore
Definition: vtkRenderer.h:932
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1167
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:1104
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:1143
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:1122
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
Definition: vtkRenderer.h:1135
void AllocateTime()
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:927
int VisibleVolumeCount()
Returns the number of visible volumes.
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:931
int NumberOfPropsRendered
Definition: vtkRenderer.h:946
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
Definition: vtkRenderer.h:637
virtual int UpdateOpaquePolygonalGeometry()
Ask all props to update and draw any opaque polygonal geometry.
double TimeFactor
Definition: vtkRenderer.h:929
bool TexturedBackground
Definition: vtkRenderer.h:1156
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:924
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:1115
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:604
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:988
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:1000
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene.
Definition: vtkRenderer.h:1073
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:980
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:652
unsigned char * BackingImage
Definition: vtkRenderer.h:933
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1154
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:1157
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:950
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:921
vtkCamera * GetActiveCamera()
Get the current camera.
void AddActor(vtkProp *p)
Add/Remove different types of props to the renderer.
int PropArrayCount
Definition: vtkRenderer.h:951
virtual double GetTimeFactor()
Get the ratio between allocated time and actual render time.
double AllocatedRenderTime
Definition: vtkRenderer.h:928
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:974
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:995
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1150
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:303
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:930
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1158
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:1098
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:1090
void WorldToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkLightCollection * Lights
Definition: vtkRenderer.h:920
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:935
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:328
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:1217
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:939
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:1078
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:333
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:960
void SetGL2PSSpecialPropCollection(vtkPropCollection *)
Set the prop collection object used during vtkRenderWindow::CaptureGL2PSSpecialProps().
vtkActorCollection * Actors
Definition: vtkRenderer.h:923
void SetDelegate(vtkRendererDelegate *d)
Set/Get a custom Render call.
vtkTypeBool Interactive
Definition: vtkRenderer.h:955
vtkInformation * Information
Definition: vtkRenderer.h:1164
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:917
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:67
record modification and/or execution time
Definition: vtkTimeStamp.h:34
abstract specification for Viewports
Definition: vtkViewport.h:54
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:49
window superclass for vtkRenderWindow
Definition: vtkWindow.h:37
int vtkTypeBool
Definition: vtkABI.h:64
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:270
#define VTK_SIZEHINT(...)