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
52class vtkFXAAOptions;
53class vtkRenderWindow;
54class vtkVolume;
55class vtkCuller;
56class vtkActor;
57class vtkActor2D;
58class vtkCamera;
60class vtkInformation;
63class vtkLight;
66class vtkRenderPass;
67class vtkTexture;
68
69class vtkRecti;
70class vtkVector3d;
71
72class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
73{
74public:
75 vtkTypeMacro(vtkRenderer, vtkViewport);
76 void PrintSelf(ostream& os, vtkIndent indent) override;
77
83 static vtkRenderer* New();
84
86
91 void AddActor(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
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; }
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
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
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
881protected:
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];
906 unsigned char* BackingImage;
907 int BackingStoreSize[2];
909
911
913
914 // Allocate the time for each prop
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
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 ----------------------------------------
1112
1117 {
1118 this->Selector = selector;
1119 this->Modified();
1120 }
1121
1122 // End Ivars for visible cell selecting.
1124
1125 //---------------------------------------------------------------
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
1145private:
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.
vtkCamera * GetActiveCameraAndResetIfCreated()
Get the current camera and reset it only if it gets created automatically (see GetActiveCamera).
void ViewToWorld(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
virtual void SetFXAAOptions(vtkFXAAOptions *)
virtual void ClearLights(void)
Internal method temporarily removes lights before reloading them into graphics pipeline.
Definition: vtkRenderer.h:330
vtkCamera * GetActiveCamera()
Get the current camera.
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
vtkActorCollection * GetActors()
Return any actors in this renderer.
const std::array< double, 16 > & GetViewTransformMatrix()
Gets the ActiveCamera ViewTransformMatrix, only computing it if necessary.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
double LastRenderTimeInSeconds
Definition: vtkRenderer.h:910
double GetTiledAspectRatio()
Compute the aspect ratio of this renderer for the current tile.
void AddLight(vtkLight *)
Add a light to the list of lights.
vtkCullerCollection * GetCullers()
Return the collection of cullers.
Definition: vtkRenderer.h:1198
virtual vtkCamera * MakeCamera()
Create a new Camera 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.
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
const std::array< double, 16 > & GetCompositeProjectionTransformationMatrix()
Gets the ActiveCamera CompositeProjectionTransformationMatrix, only computing it if necessary.
virtual vtkLight * MakeLight()
Create a new Light sutible for use with this type of Renderer.
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.
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
vtkWindow * GetVTKWindow() override
Return the vtkWindow that owns this vtkViewport.
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
const std::array< double, 16 > & GetProjectionTransformationMatrix()
Gets the ActiveCamera ProjectionTransformationMatrix, only computing it if necessary.
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
vtkVolumeCollection * GetVolumes()
Return the collection of volumes.
vtkTexture * GetLeftBackgroundTexture()
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:953
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.
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
static vtkRenderer * New()
Create a vtkRenderer with a black background, a white ambient light, two-sided lighting turned on,...
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
double GetZ(int x, int y)
Given a pixel location, return the Z value.
vtkProp ** PropArray
Definition: vtkRenderer.h:923
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:894
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
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.
void ViewToWorld() override
Convert view point coordinates to world coordinates.
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.
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
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
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:890
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(...)