VTK  9.0.20210729
vtkRenderer.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkRenderer.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
41 #ifndef vtkRenderer_h
42 #define vtkRenderer_h
43 
44 #include "vtkRenderingCoreModule.h" // For export macro
45 #include "vtkViewport.h"
46 
47 #include "vtkActorCollection.h" // Needed for access in inline members
48 #include "vtkVolumeCollection.h" // Needed for access in inline members
49 
50 class vtkFXAAOptions;
51 class vtkRenderWindow;
52 class vtkVolume;
53 class vtkCuller;
54 class vtkActor;
55 class vtkActor2D;
56 class vtkCamera;
58 class vtkInformation;
59 class vtkLightCollection;
61 class vtkLight;
64 class vtkRenderPass;
65 class vtkTexture;
66 
67 class 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(void);
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(void) {}
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 
420  virtual void ResetCameraScreenSpace();
421 
427  virtual void ResetCameraScreenSpace(const double bounds[6]);
428 
429  using vtkViewport::DisplayToWorld;
430 
434  vtkVector3d DisplayToWorld(const vtkVector3d& display);
435 
440  void ZoomToBoxUsingViewAngle(const vtkRecti& box);
441 
445  virtual void ResetCameraScreenSpace(
446  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
447 
449 
454  void SetRenderWindow(vtkRenderWindow*);
455  vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
456  vtkWindow* GetVTKWindow() override;
458 
460 
466  vtkSetMacro(BackingStore, vtkTypeBool);
467  vtkGetMacro(BackingStore, vtkTypeBool);
468  vtkBooleanMacro(BackingStore, vtkTypeBool);
470 
472 
477  vtkSetMacro(Interactive, vtkTypeBool);
478  vtkGetMacro(Interactive, vtkTypeBool);
479  vtkBooleanMacro(Interactive, vtkTypeBool);
481 
483 
494  virtual void SetLayer(int layer);
495  vtkGetMacro(Layer, int);
497 
499 
509  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
510  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
511  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
513 
515 
519  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
520  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
521  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
523 
528  int Transparent();
529 
533  void WorldToView() override;
534 
536 
539  void ViewToWorld() override;
540  void ViewToWorld(double& wx, double& wy, double& wz) override;
542 
546  void WorldToView(double& wx, double& wy, double& wz) override;
547 
549 
552  void WorldToPose(double& wx, double& wy, double& wz) override;
553  void PoseToWorld(double& wx, double& wy, double& wz) override;
554  void ViewToPose(double& wx, double& wy, double& wz) override;
555  void PoseToView(double& wx, double& wy, double& wz) override;
557 
562  double GetZ(int x, int y);
563 
567  vtkMTimeType GetMTime() override;
568 
570 
573  vtkGetMacro(LastRenderTimeInSeconds, double);
575 
577 
583  vtkGetMacro(NumberOfPropsRendered, int);
585 
587 
594  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
595  {
596  return this->PickProp(selectionX, selectionY, selectionX, selectionY);
597  }
599  double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
601 
607  virtual void StereoMidpoint() { return; }
608 
616 
622  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
623 
625 
635  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
636  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
637  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
639 
645  vtkSetMacro(UseDepthPeelingForVolumes, bool);
646  vtkGetMacro(UseDepthPeelingForVolumes, bool);
647  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
648 
650 
659  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
660  vtkGetMacro(OcclusionRatio, double);
662 
664 
669  vtkSetMacro(MaximumNumberOfPeels, int);
670  vtkGetMacro(MaximumNumberOfPeels, int);
672 
674 
679  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
681 
683 
687  vtkSetMacro(UseSSAO, bool);
688  vtkGetMacro(UseSSAO, bool);
689  vtkBooleanMacro(UseSSAO, bool);
691 
693 
697  vtkSetMacro(SSAORadius, double);
698  vtkGetMacro(SSAORadius, double);
700 
702 
706  vtkSetMacro(SSAOBias, double);
707  vtkGetMacro(SSAOBias, double);
709 
711 
715  vtkSetMacro(SSAOKernelSize, unsigned int);
716  vtkGetMacro(SSAOKernelSize, unsigned int);
718 
720 
725  vtkSetMacro(SSAOBlur, bool);
726  vtkGetMacro(SSAOBlur, bool);
727  vtkBooleanMacro(SSAOBlur, bool);
729 
731 
738  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
740 
742 
747  vtkGetObjectMacro(Selector, vtkHardwareSelector);
749 
751 
759  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
761 
763 
768  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
770 
772 
776  vtkSetMacro(TexturedBackground, bool);
777  vtkGetMacro(TexturedBackground, bool);
778  vtkBooleanMacro(TexturedBackground, bool);
780 
781  // method to release graphics resources in any derived renderers.
783 
785 
788  vtkSetMacro(UseFXAA, bool);
789  vtkGetMacro(UseFXAA, bool);
790  vtkBooleanMacro(UseFXAA, bool);
792 
794 
797  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
800 
802 
806  vtkSetMacro(UseShadows, vtkTypeBool);
807  vtkGetMacro(UseShadows, vtkTypeBool);
808  vtkBooleanMacro(UseShadows, vtkTypeBool);
810 
812 
816  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
817  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
818  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
820 
821  // Set/Get a custom render pass.
822  // Initial value is NULL.
824  vtkGetObjectMacro(Pass, vtkRenderPass);
825 
827 
830  vtkGetObjectMacro(Information, vtkInformation);
833 
835 
841  vtkSetMacro(UseImageBasedLighting, bool);
842  vtkGetMacro(UseImageBasedLighting, bool);
843  vtkBooleanMacro(UseImageBasedLighting, bool);
845 
847 
858  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
859  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
861 
863 
866  vtkGetVector3Macro(EnvironmentUp, double);
867  vtkSetVector3Macro(EnvironmentUp, double);
869 
871 
874  vtkGetVector3Macro(EnvironmentRight, double);
875  vtkSetVector3Macro(EnvironmentRight, double);
877 
878 protected:
880  ~vtkRenderer() override;
881 
882  // internal method to expand bounding box to consider model transform
883  // matrix or model view transform matrix based on whether or not deering
884  // frustum is used. 'bounds' buffer is mutated to the expanded box.
885  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
886 
889 
892 
895 
896  double Ambient[3];
899  double TimeFactor;
903  unsigned char* BackingImage;
904  int BackingStoreSize[2];
906 
908 
910 
911  // Allocate the time for each prop
912  void AllocateTime();
913 
914  // Internal variables indicating the number of props
915  // that have been or will be rendered in each category.
917 
918  // A temporary list of props used for culling, and traversal
919  // of all props when rendering
922 
923  // Indicates if the renderer should receive events from an interactor.
924  // Typically only used in conjunction with transparent renderers.
926 
927  // Shows what layer this renderer belongs to. Only of interested when
928  // there are layered renderers.
929  int Layer;
932 
933  // Holds the result of ComputeVisiblePropBounds so that it is visible from
934  // wrapped languages
935  double ComputedVisiblePropBounds[6];
936 
945 
951 
959 
966 
971 
977  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
978 
987 
994 
999  virtual int UpdateCamera(void);
1000 
1007 
1012  virtual int UpdateLights(void) { return 0; }
1013 
1020 
1025  bool UseFXAA;
1026 
1031 
1037 
1043 
1051 
1057 
1068 
1075 
1076  bool UseSSAO = false;
1077  double SSAORadius = 0.5;
1078  double SSAOBias = 0.01;
1079  unsigned int SSAOKernelSize = 32;
1080  bool SSAOBlur = false;
1081 
1088 
1089  // HARDWARE SELECTION ----------------------------------------
1090  friend class vtkHardwareSelector;
1091 
1096  {
1097  this->Selector = selector;
1098  this->Modified();
1099  }
1100 
1101  // End Ivars for visible cell selecting.
1103 
1104  //---------------------------------------------------------------
1105  friend class vtkRendererDelegate;
1107 
1111 
1112  friend class vtkRenderPass;
1114 
1115  // Arbitrary extra information associated with this renderer
1117 
1120 
1121  double EnvironmentUp[3];
1122  double EnvironmentRight[3];
1123 
1124 private:
1125  vtkRenderer(const vtkRenderer&) = delete;
1126  void operator=(const vtkRenderer&) = delete;
1127 };
1128 
1130 {
1131  return this->Lights;
1132 }
1133 
1138 {
1139  return this->Cullers;
1140 }
1141 
1142 #endif
vtkRenderer::UpdateOpaquePolygonalGeometry
virtual int UpdateOpaquePolygonalGeometry()
Ask all props to update and draw any opaque polygonal geometry.
vtkRenderer::UpdateCamera
virtual int UpdateCamera(void)
Ask the active camera to do whatever it needs to do prior to rendering.
vtkVolumeCollection
an ordered list of volumes
Definition: vtkVolumeCollection.h:36
vtkRenderer::SetBackgroundTexture
virtual void SetBackgroundTexture(vtkTexture *)
vtkRenderer::PickProp
vtkAssemblyPath * PickProp(double selectionX, double selectionY) override
Return the prop (via a vtkAssemblyPath) that has the highest z value at the given x,...
Definition: vtkRenderer.h:594
vtkRenderer::Render
virtual void Render()
CALLED BY vtkRenderWindow ONLY.
vtkRenderer::CaptureGL2PSSpecialProp
int CaptureGL2PSSpecialProp(vtkProp *)
This function is called to capture an instance of vtkProp that requires special handling during vtkRe...
vtkRenderer::SetLightCollection
void SetLightCollection(vtkLightCollection *lights)
Set the collection of lights.
vtkRenderer::DeviceRenderOpaqueGeometry
virtual void DeviceRenderOpaqueGeometry(vtkFrameBufferObjectBase *fbo=nullptr)
Render opaque polygonal geometry.
vtkLight
a virtual light for 3D rendering
Definition: vtkLight.h:57
vtkRenderer::AddActor
void AddActor(vtkProp *p)
Add/Remove different types of props to the renderer.
vtkRenderer::ClippingRangeExpansion
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:950
vtkRenderer::UseShadows
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:1036
vtkRenderer::PreserveDepthBuffer
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:931
vtkRenderer::UpdateLightGeometry
virtual vtkTypeBool UpdateLightGeometry(void)
Update the geometry of the lights in the scene that are not in world space (for instance,...
vtkVolume
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:45
vtkRenderer::SetInformation
virtual void SetInformation(vtkInformation *)
vtkRenderer::Pass
vtkRenderPass * Pass
Definition: vtkRenderer.h:1113
vtkRenderer::IsActiveCameraCreated
vtkTypeBool IsActiveCameraCreated()
This method returns 1 if the ActiveCamera has already been set or automatically created by the render...
Definition: vtkRenderer.h:622
vtkRenderer::Clear
virtual void Clear()
Clear the image to the background color.
Definition: vtkRenderer.h:333
vtkRenderer::SetDelegate
void SetDelegate(vtkRendererDelegate *d)
Set/Get a custom Render call.
vtkRenderer::WorldToView
void WorldToView(double &wx, double &wy, double &wz) override
Convert world point coordinates to view coordinates.
vtkRenderer::SetLeftBackgroundTexture
virtual void SetLeftBackgroundTexture(vtkTexture *)
Set/Get the texture to be used for the monocular or stereo left eye background.
vtkRenderer::RemoveVolume
void RemoveVolume(vtkProp *p)
vtkRenderer::AddVolume
void AddVolume(vtkProp *p)
vtkRenderer::UpdateLights
virtual int UpdateLights(void)
Ask all lights to load themselves into rendering pipeline.
Definition: vtkRenderer.h:1012
vtkRenderer::ComputeVisiblePropBounds
void ComputeVisiblePropBounds(double bounds[6])
Compute the bounding box of all the visible props Used in ResetCamera() and ResetCameraClippingRange(...
vtkRenderer::MakeCamera
virtual vtkCamera * MakeCamera()
Create a new Camera sutible for use with this type of Renderer.
vtkRenderer::GetAllocatedRenderTime
virtual double GetAllocatedRenderTime()
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:33
vtkRenderer::BackingStore
vtkTypeBool BackingStore
Definition: vtkRenderer.h:902
vtkRenderer::GetMTime
vtkMTimeType GetMTime() override
Return the MTime of the renderer also considering its ivars.
vtkLightCollection
an ordered list of lights
Definition: vtkLightCollection.h:36
vtkRenderer::AllocatedRenderTime
double AllocatedRenderTime
Definition: vtkRenderer.h:898
vtkRenderer::ClearLights
virtual void ClearLights(void)
Internal method temporarily removes lights before reloading them into graphics pipeline.
Definition: vtkRenderer.h:328
vtkObject::Modified
virtual void Modified()
Update the modification time for this object.
vtkRenderer::LightFollowCamera
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:909
vtkRenderer::ReleaseGraphicsResources
virtual void ReleaseGraphicsResources(vtkWindow *)
vtkRenderer::RenderTime
vtkTimeStamp RenderTime
Definition: vtkRenderer.h:905
vtkFXAAOptions
Configuration for FXAA implementations.
Definition: vtkFXAAOptions.h:31
vtkRenderer::OcclusionRatio
double OcclusionRatio
In case of use of depth peeling technique for rendering translucent material, define the threshold un...
Definition: vtkRenderer.h:1067
vtkRenderer::ViewToWorld
void ViewToWorld(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
vtkRenderer::EnvironmentTexture
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1119
vtkRenderer::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkRenderer::VisibleVolumeCount
int VisibleVolumeCount()
Returns the number of visible volumes.
vtkRenderer::UseDepthPeelingForVolumes
bool UseDepthPeelingForVolumes
This flag is on and the GPU supports it, depth-peel volumes along with the translucent geometry.
Definition: vtkRenderer.h:1056
vtkRenderer::GetActors
vtkActorCollection * GetActors()
Return any actors in this renderer.
vtkRenderer::Draw
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:965
vtkViewport::PickProp
virtual vtkAssemblyPath * PickProp(double selectionX, double selectionY)=0
Return the Prop that has the highest z value at the given x, y position in the viewport.
vtkViewport.h
vtkAssemblyPath
a list of nodes that form an assembly path
Definition: vtkAssemblyPath.h:42
vtkRenderer::Transparent
int Transparent()
Returns a boolean indicating if this renderer is transparent.
vtkRenderer::BackingImage
unsigned char * BackingImage
Definition: vtkRenderer.h:903
vtkFrameBufferObjectBase
abstract interface to OpenGL FBOs
Definition: vtkFrameBufferObjectBase.h:33
vtkRenderer::StereoMidpoint
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
Definition: vtkRenderer.h:607
vtkRenderer::RenderWindow
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:897
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:39
vtkRenderer::AllocateTime
void AllocateTime()
vtkRenderer::Layer
int Layer
Definition: vtkRenderer.h:929
vtkRenderer::AutomaticLightCreation
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:901
vtkRenderer::UseFXAA
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene.
Definition: vtkRenderer.h:1025
vtkRenderer::UseDepthPeeling
vtkTypeBool UseDepthPeeling
If this flag is on and the GPU supports it, depth peeling is used for rendering translucent materials...
Definition: vtkRenderer.h:1050
vtkRenderer::vtkRenderer
vtkRenderer()
vtkRenderer::SetSelector
void SetSelector(vtkHardwareSelector *selector)
Called by vtkHardwareSelector when it begins rendering for selection.
Definition: vtkRenderer.h:1095
vtkRenderer::GetActiveCamera
vtkCamera * GetActiveCamera()
Get the current camera.
vtkRenderer::SetGL2PSSpecialPropCollection
void SetGL2PSSpecialPropCollection(vtkPropCollection *)
Set the prop collection object used during vtkRenderWindow::CaptureGL2PSSpecialProps().
vtkRendererDelegate
Render the props of a vtkRenderer.
Definition: vtkRendererDelegate.h:38
vtkTexture
handles properties associated with a texture map
Definition: vtkTexture.h:66
vtkRenderer::GetVolumes
vtkVolumeCollection * GetVolumes()
Return the collection of volumes.
vtkRenderer::PreserveColorBuffer
vtkTypeBool PreserveColorBuffer
Definition: vtkRenderer.h:930
vtkRenderer::SetEnvironmentTexture
virtual void SetEnvironmentTexture(vtkTexture *texture, bool isSRGB=false)
vtkRenderer::~vtkRenderer
~vtkRenderer() override
VTK_SIZEHINT
#define VTK_SIZEHINT(...)
Definition: vtkWrappingHints.h:48
vtkRenderer::Interactive
vtkTypeBool Interactive
Definition: vtkRenderer.h:925
vtkActorCollection.h
vtkRenderer::LastRenderTimeInSeconds
double LastRenderTimeInSeconds
Definition: vtkRenderer.h:907
vtkRenderer::ActiveCamera
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:887
vtkVolumeCollection.h
vtkRenderer::PoseToWorld
void PoseToWorld(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
vtkRenderer::Volumes
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:894
vtkRenderer::Cullers
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:891
vtkRenderer::SetFXAAOptions
virtual void SetFXAAOptions(vtkFXAAOptions *)
vtkHardwareSelector
Definition: vtkHardwareSelector.h:124
vtkRenderer::GetLights
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:1129
vtkRenderer::Delegate
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1106
vtkRenderer::PropArrayCount
int PropArrayCount
Definition: vtkRenderer.h:921
vtkRenderer::TimeFactor
double TimeFactor
Definition: vtkRenderer.h:899
vtkActor
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:46
vtkRenderer::UpdateLightsGeometryToFollowCamera
virtual vtkTypeBool UpdateLightsGeometryToFollowCamera(void)
Ask the lights in the scene that are not in world space (for instance, Headlights or CameraLights tha...
vtkCuller
a superclass for prop cullers
Definition: vtkCuller.h:38
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:34
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:36
vtkRenderer::CreateLight
void CreateLight(void)
Create and add a light to renderer.
vtkRenderer::TwoSidedLighting
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:900
vtkRenderer::GetActiveCameraAndResetIfCreated
vtkCamera * GetActiveCameraAndResetIfCreated()
Get the current camera and reset it only if it gets created automatically (see GetActiveCamera).
vtkCamera
a virtual camera for 3D rendering
Definition: vtkCamera.h:46
vtkRenderer::PickProp
vtkAssemblyPath * PickProp(double selectionX1, double selectionY1, double selectionX2, double selectionY2) override
Return the Prop that has the highest z value at the given x1, y1 and x2,y2 positions in the viewport.
vtkRenderer::UpdateGeometry
virtual int UpdateGeometry(vtkFrameBufferObjectBase *fbo=nullptr)
Ask all props to update and draw any opaque and translucent geometry.
vtkRenderer::UseHiddenLineRemoval
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:1042
vtkRenderer::PropArray
vtkProp ** PropArray
Definition: vtkRenderer.h:920
vtkCullerCollection
an ordered list of Cullers
Definition: vtkCullerCollection.h:35
vtkRenderer::UpdateTranslucentPolygonalGeometry
virtual int UpdateTranslucentPolygonalGeometry()
Ask all props to update and draw any translucent polygonal geometry.
vtkRenderer::GetZ
double GetZ(int x, int y)
Given a pixel location, return the Z value.
vtkRenderer::FXAAOptions
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:1030
vtkRenderer::SetRightBackgroundTexture
virtual void SetRightBackgroundTexture(vtkTexture *)
Set/Get the texture to be used for the right eye background.
vtkViewport
abstract specification for Viewports
Definition: vtkViewport.h:45
vtkRenderer::SetPass
void SetPass(vtkRenderPass *p)
vtkRenderer::WorldToView
void WorldToView() override
Convert world point coordinates to view coordinates.
vtkRenderer::Actors
vtkActorCollection * Actors
Definition: vtkRenderer.h:893
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:74
vtkRenderer::ComputeVisiblePropBounds
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkProp
abstract superclass for all actors, volumes and annotations
Definition: vtkProp.h:57
vtkRenderer::GetVTKWindow
vtkWindow * GetVTKWindow() override
Return the vtkWindow that owns this vtkViewport.
vtkRenderer::RemoveLight
void RemoveLight(vtkLight *)
Remove a light from the list of lights.
vtkRenderer::GL2PSSpecialPropCollection
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:970
vtkActor2D
a actor that draws 2D data
Definition: vtkActor2D.h:40
vtkRenderer::UseImageBasedLighting
bool UseImageBasedLighting
Definition: vtkRenderer.h:1118
vtkRenderer::Selector
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1102
vtkRenderer::Lights
vtkLightCollection * Lights
Definition: vtkRenderer.h:890
vtkRenderer::PoseToView
void PoseToView(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
vtkRenderer::NearClippingPlaneTolerance
double NearClippingPlaneTolerance
Specifies the minimum distance of the near clipping plane as a percentage of the far clipping plane d...
Definition: vtkRenderer.h:944
vtkRenderer::RemoveCuller
void RemoveCuller(vtkCuller *)
Remove an actor from the list of cullers.
vtkRenderer::BackgroundTexture
vtkTexture * BackgroundTexture
Definition: vtkRenderer.h:1109
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:71
vtkRenderer::RemoveAllLights
void RemoveAllLights()
Remove all lights from the list of lights.
vtkRenderer::TexturedBackground
bool TexturedBackground
Definition: vtkRenderer.h:1108
vtkRenderer::AddLight
void AddLight(vtkLight *)
Add a light to the list of lights.
vtkRenderer::ViewToWorld
void ViewToWorld() override
Convert view point coordinates to world coordinates.
vtkRenderer::GetLeftBackgroundTexture
vtkTexture * GetLeftBackgroundTexture()
vtkActorCollection
an ordered list of actors
Definition: vtkActorCollection.h:37
vtkRenderer::RightBackgroundTexture
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1110
vtkRenderer::SetActiveCamera
void SetActiveCamera(vtkCamera *)
Specify the camera to use for this renderer.
vtkRenderer::MaximumNumberOfPeels
int MaximumNumberOfPeels
In case of depth peeling, define the maximum number of peeling layers.
Definition: vtkRenderer.h:1074
vtkRenderer::VisibleActorCount
int VisibleActorCount()
Returns the number of visible actors.
vtkRenderer::DeviceRenderTranslucentPolygonalGeometry
virtual void DeviceRenderTranslucentPolygonalGeometry(vtkFrameBufferObjectBase *fbo=nullptr)
Render translucent polygonal geometry.
vtkRenderer::GetTimeFactor
virtual double GetTimeFactor()
Get the ratio between allocated time and actual render time.
vtkRecti
Definition: vtkRect.h:322
vtkRenderer::ExpandBounds
virtual void ExpandBounds(double bounds[6], vtkMatrix4x4 *matrix)
vtkRenderWindow
create a window for renderers to draw into
Definition: vtkRenderWindow.h:96
vtkRenderer::MakeLight
virtual vtkLight * MakeLight()
Create a new Light sutible for use with this type of Renderer.
vtkRenderer::RemoveActor
void RemoveActor(vtkProp *p)
vtkRenderer::WorldToPose
void WorldToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkRenderer::New
static vtkRenderer * New()
Create a vtkRenderer with a black background, a white ambient light, two-sided lighting turned on,...
vtkRenderer::CreatedLight
vtkLight * CreatedLight
Definition: vtkRenderer.h:888
vtkRenderer::AddCuller
void AddCuller(vtkCuller *)
Add an culler to the list of cullers.
vtkPropCollection
an ordered list of Props
Definition: vtkPropCollection.h:36
vtkRenderer::GetTiledAspectRatio
double GetTiledAspectRatio()
Compute the aspect ratio of this renderer for the current tile.
vtkRenderer::LastRenderingUsedDepthPeeling
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
Definition: vtkRenderer.h:1087
vtkRenderer::DeviceRender
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:303
vtkRenderer::GetCullers
vtkCullerCollection * GetCullers()
Return the collection of cullers.
Definition: vtkRenderer.h:1137
vtkVector3d
Definition: vtkVector.h:488
vtkRenderer::ViewToPose
void ViewToPose(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
vtkRenderer::Erase
vtkTypeBool Erase
When this flag is off, the renderer will not erase the background or the Zbuffer.
Definition: vtkRenderer.h:958
vtkRenderer::NumberOfPropsRendered
int NumberOfPropsRendered
Definition: vtkRenderer.h:916
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkRenderer::Information
vtkInformation * Information
Definition: vtkRenderer.h:1116
vtkRenderer::SetLayer
virtual void SetLayer(int layer)
Set/Get the layer that this renderer belongs to.
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:287
vtkRenderPass
Perform part of the rendering of a vtkRenderer.
Definition: vtkRenderPass.h:57