VTK  9.1.0
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);
96 
101 
106 
111 
115  vtkLightCollection* GetLights();
116 
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 
188 
193 
198 
203 
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 
246 
253 
258 
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 
314 
325 
330  virtual void ClearLights(void) {}
331 
335  virtual void Clear() {}
336 
341 
346 
351  void ComputeVisiblePropBounds(double bounds[6]);
352 
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 
610  virtual void StereoMidpoint() { return; }
611 
619 
625  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
626 
628 
638  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
639  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
640  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
642 
648  vtkSetMacro(UseDepthPeelingForVolumes, bool);
649  vtkGetMacro(UseDepthPeelingForVolumes, bool);
650  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
651 
653 
662  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
663  vtkGetMacro(OcclusionRatio, double);
665 
667 
672  vtkSetMacro(MaximumNumberOfPeels, int);
673  vtkGetMacro(MaximumNumberOfPeels, int);
675 
677 
682  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
684 
686 
690  vtkSetMacro(UseSSAO, bool);
691  vtkGetMacro(UseSSAO, bool);
692  vtkBooleanMacro(UseSSAO, bool);
694 
696 
700  vtkSetMacro(SSAORadius, double);
701  vtkGetMacro(SSAORadius, double);
703 
705 
709  vtkSetMacro(SSAOBias, double);
710  vtkGetMacro(SSAOBias, double);
712 
714 
718  vtkSetMacro(SSAOKernelSize, unsigned int);
719  vtkGetMacro(SSAOKernelSize, unsigned int);
721 
723 
728  vtkSetMacro(SSAOBlur, bool);
729  vtkGetMacro(SSAOBlur, bool);
730  vtkBooleanMacro(SSAOBlur, bool);
732 
734 
741  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
743 
745 
750  vtkGetObjectMacro(Selector, vtkHardwareSelector);
752 
754 
762  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
764 
766 
771  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
773 
775 
779  vtkSetMacro(TexturedBackground, bool);
780  vtkGetMacro(TexturedBackground, bool);
781  vtkBooleanMacro(TexturedBackground, bool);
783 
784  // method to release graphics resources in any derived renderers.
786 
788 
791  vtkSetMacro(UseFXAA, bool);
792  vtkGetMacro(UseFXAA, bool);
793  vtkBooleanMacro(UseFXAA, bool);
795 
797 
800  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
803 
805 
809  vtkSetMacro(UseShadows, vtkTypeBool);
810  vtkGetMacro(UseShadows, vtkTypeBool);
811  vtkBooleanMacro(UseShadows, vtkTypeBool);
813 
815 
819  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
820  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
821  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
823 
824  // Set/Get a custom render pass.
825  // Initial value is NULL.
827  vtkGetObjectMacro(Pass, vtkRenderPass);
828 
830 
833  vtkGetObjectMacro(Information, vtkInformation);
836 
838 
844  vtkSetMacro(UseImageBasedLighting, bool);
845  vtkGetMacro(UseImageBasedLighting, bool);
846  vtkBooleanMacro(UseImageBasedLighting, bool);
848 
850 
861  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
862  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
864 
866 
869  vtkGetVector3Macro(EnvironmentUp, double);
870  vtkSetVector3Macro(EnvironmentUp, double);
872 
874 
877  vtkGetVector3Macro(EnvironmentRight, double);
878  vtkSetVector3Macro(EnvironmentRight, double);
880 
881 protected:
883  ~vtkRenderer() override;
884 
885  // internal method to expand bounding box to consider model transform
886  // matrix or model view transform matrix based on whether or not deering
887  // frustum is used. 'bounds' buffer is mutated to the expanded box.
888  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
889 
892 
895 
898 
899  double Ambient[3];
902  double TimeFactor;
906  unsigned char* BackingImage;
907  int BackingStoreSize[2];
909 
911 
913 
914  // Allocate the time for each prop
915  void AllocateTime();
916 
917  // Internal variables indicating the number of props
918  // that have been or will be rendered in each category.
920 
921  // A temporary list of props used for culling, and traversal
922  // of all props when rendering
925 
926  // Indicates if the renderer should receive events from an interactor.
927  // Typically only used in conjunction with transparent renderers.
929 
930  // Shows what layer this renderer belongs to. Only of interested when
931  // there are layered renderers.
932  int Layer;
935 
936  // Holds the result of ComputeVisiblePropBounds so that it is visible from
937  // wrapped languages
938  double ComputedVisiblePropBounds[6];
939 
948 
954 
962 
969 
974 
979  const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
980 
985  const std::array<double, 16>& GetProjectionTransformationMatrix();
986 
991  const std::array<double, 16>& GetViewTransformMatrix();
992 
998  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
999 
1008 
1015 
1020  virtual int UpdateCamera(void);
1021 
1028 
1033  virtual int UpdateLights(void) { return 0; }
1034 
1041 
1046  bool UseFXAA;
1047 
1052 
1058 
1064 
1072 
1078 
1089 
1096 
1097  bool UseSSAO = false;
1098  double SSAORadius = 0.5;
1099  double SSAOBias = 0.01;
1100  unsigned int SSAOKernelSize = 32;
1101  bool SSAOBlur = false;
1102 
1109 
1110  // HARDWARE SELECTION ----------------------------------------
1111  friend class vtkHardwareSelector;
1112 
1117  {
1118  this->Selector = selector;
1119  this->Modified();
1120  }
1121 
1122  // End Ivars for visible cell selecting.
1124 
1125  //---------------------------------------------------------------
1126  friend class vtkRendererDelegate;
1128 
1132 
1133  friend class vtkRenderPass;
1135 
1136  // Arbitrary extra information associated with this renderer
1138 
1141 
1142  double EnvironmentUp[3];
1143  double EnvironmentRight[3];
1144 
1145 private:
1149  std::array<double, 16> CompositeProjectionTransformationMatrix;
1150 
1154  double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1155 
1159  vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1160 
1164  std::array<double, 16> ProjectionTransformationMatrix;
1165 
1169  double LastProjectionTransformationMatrixTiledAspectRatio;
1170 
1174  vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1175 
1179  std::array<double, 16> ViewTransformMatrix;
1180 
1184  vtkMTimeType LastViewTransformCameraModified;
1185 
1186  vtkRenderer(const vtkRenderer&) = delete;
1187  void operator=(const vtkRenderer&) = delete;
1188 };
1189 
1191 {
1192  return this->Lights;
1193 }
1194 
1199 {
1200  return this->Cullers;
1201 }
1202 
1203 #endif
a actor that draws 2D data
Definition: vtkActor2D.h:40
an ordered list of actors
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:46
a list of nodes that form an assembly path
a virtual camera for 3D rendering
Definition: vtkCamera.h:46
an ordered list of Cullers
a superclass for prop cullers
Definition: vtkCuller.h:38
Configuration for FXAA implementations.
abstract interface to OpenGL FBOs
a simple class to control print indentation
Definition: vtkIndent.h:34
Store vtkAlgorithm input/output information.
an ordered list of lights
a virtual light for 3D rendering
Definition: vtkLight.h:57
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:36
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:57
Perform part of the rendering of a vtkRenderer.
Definition: vtkRenderPass.h:57
create a window for renderers to draw into
Render the props of a vtkRenderer.
abstract specification for renderers
Definition: vtkRenderer.h:73
void RemoveVolume(vtkProp *p)
virtual void SetLayer(int layer)
Set/Get the layer that this renderer belongs to.
void ViewToWorld(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
virtual void SetFXAAOptions(vtkFXAAOptions *)
const std::array< double, 16 > & GetViewTransformMatrix()
Gets the ActiveCamera ViewTransformMatrix, only computing it if necessary.
virtual void ClearLights(void)
Internal method temporarily removes lights before reloading them into graphics pipeline.
Definition: vtkRenderer.h:330
void AddCuller(vtkCuller *)
Add an culler to the list of cullers.
void SetPass(vtkRenderPass *p)
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:934
vtkLight * CreatedLight
Definition: vtkRenderer.h:891
vtkRenderPass * Pass
Definition: vtkRenderer.h:1134
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:1057
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:910
double GetTiledAspectRatio()
Compute the aspect ratio of this renderer for the current tile.
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:1198
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 *)
virtual int UpdateLights(void)
Ask all lights to load themselves into rendering pipeline.
Definition: vtkRenderer.h:1033
virtual vtkTypeBool UpdateLightsGeometryToFollowCamera(void)
Ask the lights in the scene that are not in world space (for instance, Headlights or CameraLights tha...
~vtkRenderer() override
virtual int UpdateGeometry(vtkFrameBufferObjectBase *fbo=nullptr)
Ask all props to update and draw any opaque and translucent geometry.
vtkWindow * GetVTKWindow() override
Return the vtkWindow that owns this vtkViewport.
vtkActorCollection * GetActors()
Return any actors in this renderer.
int Transparent()
Returns a boolean indicating if this renderer is transparent.
virtual int UpdateCamera(void)
Ask the active camera to do whatever it needs to do prior to rendering.
bool UseImageBasedLighting
Definition: vtkRenderer.h:1139
int VisibleActorCount()
Returns the number of visible actors.
vtkTypeBool BackingStore
Definition: vtkRenderer.h:905
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1140
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:1077
void RemoveActor(vtkProp *p)
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:1116
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:1095
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
Definition: vtkRenderer.h:1108
void AllocateTime()
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:900
int VisibleVolumeCount()
Returns the number of visible volumes.
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:904
int NumberOfPropsRendered
Definition: vtkRenderer.h:919
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
Definition: vtkRenderer.h:610
virtual vtkTypeBool UpdateLightGeometry(void)
Update the geometry of the lights in the scene that are not in world space (for instance,...
virtual int UpdateOpaquePolygonalGeometry()
Ask all props to update and draw any opaque polygonal geometry.
double TimeFactor
Definition: vtkRenderer.h:902
bool TexturedBackground
Definition: vtkRenderer.h:1129
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:897
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:1088
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
void PoseToView(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
vtkTypeBool Erase
When this flag is off, the renderer will not erase the background or the Zbuffer.
Definition: vtkRenderer.h:961
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:973
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene.
Definition: vtkRenderer.h:1046
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:953
int CaptureGL2PSSpecialProp(vtkProp *)
This function is called to capture an instance of vtkProp that requires special handling during vtkRe...
vtkTypeBool IsActiveCameraCreated()
This method returns 1 if the ActiveCamera has already been set or automatically created by the render...
Definition: vtkRenderer.h:625
unsigned char * BackingImage
Definition: vtkRenderer.h:906
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1127
void SetLightCollection(vtkLightCollection *lights)
Set the collection of lights.
virtual void ReleaseGraphicsResources(vtkWindow *)
void PoseToWorld(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
void RemoveAllLights()
Remove all lights from the list of lights.
vtkTexture * BackgroundTexture
Definition: vtkRenderer.h:1130
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:923
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:894
vtkCamera * GetActiveCamera()
Get the current camera.
void AddActor(vtkProp *p)
Add/Remove different types of props to the renderer.
int PropArrayCount
Definition: vtkRenderer.h:924
virtual double GetTimeFactor()
Get the ratio between allocated time and actual render time.
double AllocatedRenderTime
Definition: vtkRenderer.h:901
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:947
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:968
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1123
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:305
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:903
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1131
vtkTypeBool UseDepthPeeling
If this flag is on and the GPU supports it, depth peeling is used for rendering translucent materials...
Definition: vtkRenderer.h:1071
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:1063
void WorldToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkLightCollection * Lights
Definition: vtkRenderer.h:893
void CreateLight(void)
Create and add a light to renderer.
vtkTexture * GetLeftBackgroundTexture()
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)
vtkTimeStamp RenderTime
Definition: vtkRenderer.h:908
virtual void Render()
CALLED BY vtkRenderWindow ONLY.
virtual int UpdateTranslucentPolygonalGeometry()
Ask all props to update and draw any translucent polygonal geometry.
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:1190
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:912
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:1051
void ViewToPose(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
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 that has the highest z value at the given x1, y1 and x2,y2 positions in the viewport.
virtual void SetBackgroundTexture(vtkTexture *)
void AddVolume(vtkProp *p)
void WorldToView(double &wx, double &wy, double &wz) override
Convert world point coordinates to view coordinates.
virtual double GetAllocatedRenderTime()
virtual void Clear()
Clear the image to the background color.
Definition: vtkRenderer.h:335
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:933
void SetGL2PSSpecialPropCollection(vtkPropCollection *)
Set the prop collection object used during vtkRenderWindow::CaptureGL2PSSpecialProps().
vtkActorCollection * Actors
Definition: vtkRenderer.h:896
void SetDelegate(vtkRendererDelegate *d)
Set/Get a custom Render call.
vtkTypeBool Interactive
Definition: vtkRenderer.h:928
vtkInformation * Information
Definition: vtkRenderer.h:1137
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:890
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:66
record modification and/or execution time
Definition: vtkTimeStamp.h:33
abstract specification for Viewports
Definition: vtkViewport.h:47
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:45
window superclass for vtkRenderWindow
Definition: vtkWindow.h:39
int vtkTypeBool
Definition: vtkABI.h:69
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:287
#define VTK_SIZEHINT(...)