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
26#ifndef vtkRenderer_h
27#define vtkRenderer_h
28
29#include "vtkRenderingCoreModule.h" // For export macro
30#include "vtkViewport.h"
31
32#include "vtkActorCollection.h" // Needed for access in inline members
33#include "vtkVolumeCollection.h" // Needed for access in inline members
34
35#include <array> // To store matrices
36
37VTK_ABI_NAMESPACE_BEGIN
38class vtkFXAAOptions;
39class vtkRenderWindow;
40class vtkVolume;
41class vtkCuller;
42class vtkActor;
43class vtkActor2D;
44class vtkCamera;
46class vtkInformation;
49class vtkLight;
52class vtkRenderPass;
53class vtkTexture;
54
55class vtkRecti;
56class vtkVector3d;
57
58class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
59{
60public:
61 vtkTypeMacro(vtkRenderer, vtkViewport);
62 void PrintSelf(ostream& os, vtkIndent indent) override;
63
69 static vtkRenderer* New();
70
72
77 void AddActor(vtkProp* p);
82
87
92
97
101 vtkLightCollection* GetLights();
102
110
115
121 virtual vtkLight* MakeLight();
122
124
130 vtkGetMacro(TwoSidedLighting, vtkTypeBool);
131 vtkSetMacro(TwoSidedLighting, vtkTypeBool);
132 vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);
134
136
149 vtkSetMacro(LightFollowCamera, vtkTypeBool);
150 vtkGetMacro(LightFollowCamera, vtkTypeBool);
151 vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
153
155
163 vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
164 vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
165 vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);
167
174
179
184
189
196
203
205
211 vtkSetMacro(Erase, vtkTypeBool);
212 vtkGetMacro(Erase, vtkTypeBool);
213 vtkBooleanMacro(Erase, vtkTypeBool);
215
217
222 vtkSetMacro(Draw, vtkTypeBool);
223 vtkGetMacro(Draw, vtkTypeBool);
224 vtkBooleanMacro(Draw, vtkTypeBool);
226
232
239
244
249
253 vtkCullerCollection* GetCullers();
254
256
259 vtkSetVector3Macro(Ambient, double);
260 vtkGetVectorMacro(Ambient, double, 3);
262
264
268 vtkSetMacro(AllocatedRenderTime, double);
269 virtual double GetAllocatedRenderTime();
271
278 virtual double GetTimeFactor();
279
286 virtual void Render();
287
291 virtual void DeviceRender(){};
292
300
311
316 virtual void ClearLights() {}
317
321 virtual void Clear() {}
322
327
332
337 void ComputeVisiblePropBounds(double bounds[6]);
338
343
348 virtual void ResetCameraClippingRange();
349
351
354 virtual void ResetCameraClippingRange(const double bounds[6]);
355 virtual void ResetCameraClippingRange(
356 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
358
360
365 vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
366 vtkGetMacro(NearClippingPlaneTolerance, double);
368
370
375 vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
376 vtkGetMacro(ClippingRangeExpansion, double);
378
385 virtual void ResetCamera();
386
396 virtual void ResetCamera(const double bounds[6]);
397
401 virtual void ResetCamera(
402 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
403
411 virtual void ResetCameraScreenSpace(double offsetRatio = 0.9);
412
421 virtual void ResetCameraScreenSpace(const double bounds[6], double offsetRatio = 0.9);
422
423 using vtkViewport::DisplayToWorld;
424
428 vtkVector3d DisplayToWorld(const vtkVector3d& display);
429
435 void ZoomToBoxUsingViewAngle(const vtkRecti& box, double offsetRatio = 1.0);
436
443 virtual void ResetCameraScreenSpace(double xmin, double xmax, double ymin, double ymax,
444 double zmin, double zmax, double offsetRatio = 0.9);
445
447
452 void SetRenderWindow(vtkRenderWindow*);
453 vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
456
458
464 vtkSetMacro(BackingStore, vtkTypeBool);
465 vtkGetMacro(BackingStore, vtkTypeBool);
466 vtkBooleanMacro(BackingStore, vtkTypeBool);
468
470
475 vtkSetMacro(Interactive, vtkTypeBool);
476 vtkGetMacro(Interactive, vtkTypeBool);
477 vtkBooleanMacro(Interactive, vtkTypeBool);
479
481
492 virtual void SetLayer(int layer);
493 vtkGetMacro(Layer, int);
495
497
507 vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
508 vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
509 vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
511
513
517 vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
518 vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
519 vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
521
527
531 void WorldToView() override;
532
534
537 void ViewToWorld() override;
538 void ViewToWorld(double& wx, double& wy, double& wz) override;
540
544 void WorldToView(double& wx, double& wy, double& wz) override;
545
547
550 void WorldToPose(double& wx, double& wy, double& wz) override;
551 void PoseToWorld(double& wx, double& wy, double& wz) override;
552 void ViewToPose(double& wx, double& wy, double& wz) override;
553 void PoseToView(double& wx, double& wy, double& wz) override;
555
560 double GetZ(int x, int y);
561
566
568
571 vtkGetMacro(LastRenderTimeInSeconds, double);
573
575
581 vtkGetMacro(NumberOfPropsRendered, int);
583
585
592 vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
593 {
594 return this->PickProp(selectionX, selectionY, selectionX, selectionY);
595 }
597 double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
599
601
610 vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
611 vtkSmartPointer<vtkSelection> selection) override
612 {
613 return this->PickProp(
614 selectionX, selectionY, selectionX, selectionY, fieldAssociation, selection);
615 }
616 vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
617 double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) override;
619
625 virtual void StereoMidpoint() {}
626
634
640 vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
641
643
653 vtkSetMacro(UseDepthPeeling, vtkTypeBool);
654 vtkGetMacro(UseDepthPeeling, vtkTypeBool);
655 vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
657
663 vtkSetMacro(UseDepthPeelingForVolumes, bool);
664 vtkGetMacro(UseDepthPeelingForVolumes, bool);
665 vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
666
668
677 vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
678 vtkGetMacro(OcclusionRatio, double);
680
682
687 vtkSetMacro(MaximumNumberOfPeels, int);
688 vtkGetMacro(MaximumNumberOfPeels, int);
690
692
697 vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
699
701
705 vtkSetMacro(UseSSAO, bool);
706 vtkGetMacro(UseSSAO, bool);
707 vtkBooleanMacro(UseSSAO, bool);
709
711
715 vtkSetMacro(SSAORadius, double);
716 vtkGetMacro(SSAORadius, double);
718
720
724 vtkSetMacro(SSAOBias, double);
725 vtkGetMacro(SSAOBias, double);
727
729
733 vtkSetMacro(SSAOKernelSize, unsigned int);
734 vtkGetMacro(SSAOKernelSize, unsigned int);
736
738
743 vtkSetMacro(SSAOBlur, bool);
744 vtkGetMacro(SSAOBlur, bool);
745 vtkBooleanMacro(SSAOBlur, bool);
747
749
756 vtkGetObjectMacro(Delegate, vtkRendererDelegate);
758
760
765 vtkGetObjectMacro(Selector, vtkHardwareSelector);
767
769
777 vtkGetObjectMacro(BackgroundTexture, vtkTexture);
779
781
786 vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
788
790
794 vtkSetMacro(TexturedBackground, bool);
795 vtkGetMacro(TexturedBackground, bool);
796 vtkBooleanMacro(TexturedBackground, bool);
798
799 // method to release graphics resources in any derived renderers.
801
803
806 vtkSetMacro(UseFXAA, bool);
807 vtkGetMacro(UseFXAA, bool);
808 vtkBooleanMacro(UseFXAA, bool);
810
812
815 vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
818
820
824 vtkSetMacro(UseShadows, vtkTypeBool);
825 vtkGetMacro(UseShadows, vtkTypeBool);
826 vtkBooleanMacro(UseShadows, vtkTypeBool);
828
830
834 vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
835 vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
836 vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
838
839 // Set/Get a custom render pass.
840 // Initial value is NULL.
842 vtkGetObjectMacro(Pass, vtkRenderPass);
843
845
848 vtkGetObjectMacro(Information, vtkInformation);
851
853
859 vtkSetMacro(UseImageBasedLighting, bool);
860 vtkGetMacro(UseImageBasedLighting, bool);
861 vtkBooleanMacro(UseImageBasedLighting, bool);
863
865
876 vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
877 virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
879
881
884 vtkGetVector3Macro(EnvironmentUp, double);
885 vtkSetVector3Macro(EnvironmentUp, double);
887
889
892 vtkGetVector3Macro(EnvironmentRight, double);
893 vtkSetVector3Macro(EnvironmentRight, double);
895
896protected:
898 ~vtkRenderer() override;
899
900 // internal method to expand bounding box to consider model transform
901 // matrix or model view transform matrix based on whether or not deering
902 // frustum is used. 'bounds' buffer is mutated to the expanded box.
903 virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
904
907
910
913
914 double Ambient[3];
921 unsigned char* BackingImage;
922 int BackingStoreSize[2];
924
926
928
929 // Allocate the time for each prop
931
932 // Internal variables indicating the number of props
933 // that have been or will be rendered in each category.
935
936 // A temporary list of props used for culling, and traversal
937 // of all props when rendering
940
941 // Indicates if the renderer should receive events from an interactor.
942 // Typically only used in conjunction with transparent renderers.
944
945 // Shows what layer this renderer belongs to. Only of interested when
946 // there are layered renderers.
947 int Layer;
950
951 // Holds the result of ComputeVisiblePropBounds so that it is visible from
952 // wrapped languages
953 double ComputedVisiblePropBounds[6];
954
963
969
977
984
989
994 const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
995
1000 const std::array<double, 16>& GetProjectionTransformationMatrix();
1001
1006 const std::array<double, 16>& GetViewTransformMatrix();
1007
1013 virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
1014
1023
1030
1035 virtual int UpdateCamera();
1036
1043
1048 virtual int UpdateLights() { return 0; }
1049
1056
1062
1067
1073
1079
1087
1093
1104
1111
1112 bool UseSSAO = false;
1113 double SSAORadius = 0.5;
1114 double SSAOBias = 0.01;
1115 unsigned int SSAOKernelSize = 32;
1116 bool SSAOBlur = false;
1117
1124
1125 // HARDWARE SELECTION ----------------------------------------
1127
1132 {
1133 this->Selector = selector;
1134 this->Modified();
1135 }
1136
1137 // End Ivars for visible cell selecting.
1139
1140 //---------------------------------------------------------------
1143
1147
1148 friend class vtkRenderPass;
1150
1151 // Arbitrary extra information associated with this renderer
1153
1156
1157 double EnvironmentUp[3];
1158 double EnvironmentRight[3];
1159
1160private:
1164 std::array<double, 16> CompositeProjectionTransformationMatrix;
1165
1169 double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1170
1174 vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1175
1179 std::array<double, 16> ProjectionTransformationMatrix;
1180
1184 double LastProjectionTransformationMatrixTiledAspectRatio;
1185
1189 vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1190
1194 std::array<double, 16> ViewTransformMatrix;
1195
1199 vtkMTimeType LastViewTransformCameraModified;
1200
1201 vtkRenderer(const vtkRenderer&) = delete;
1202 void operator=(const vtkRenderer&) = delete;
1203};
1204
1206{
1207 return this->Lights;
1208}
1209
1214{
1215 return this->Cullers;
1216}
1217
1218VTK_ABI_NAMESPACE_END
1219#endif
a actor that draws 2D data
Definition vtkActor2D.h:35
an ordered list of actors
represents an object (geometry & properties) in a rendered scene
Definition vtkActor.h:41
a list of nodes that form an assembly path
a virtual camera for 3D rendering
Definition vtkCamera.h:41
an ordered list of Cullers
a superclass for prop cullers
Definition vtkCuller.h:30
Configuration for FXAA implementations.
abstract interface to OpenGL FBOs
a simple class to control print indentation
Definition vtkIndent.h:29
Store vtkAlgorithm input/output information.
an ordered list of lights
a virtual light for 3D rendering
Definition vtkLight.h:49
represent and manipulate 4x4 transformation matrices
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:43
Perform part of the rendering of a vtkRenderer.
create a window for renderers to draw into
Render the props of a vtkRenderer.
abstract specification for renderers
Definition vtkRenderer.h:59
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.
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
Convert view point coordinates to world coordinates.
virtual void SetFXAAOptions(vtkFXAAOptions *)
The configuration object for FXAA antialiasing.
virtual int UpdateCamera()
Ask the active camera to do whatever it needs to do prior to rendering.
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,...
vtkCamera * GetActiveCamera()
Get the current camera.
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.
vtkTypeBool PreserveDepthBuffer
vtkLight * CreatedLight
vtkRenderPass * Pass
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
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
double GetTiledAspectRatio()
Compute the aspect ratio of this renderer for the current tile.
void CreateLight()
Create and add a light to renderer.
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,...
void AddLight(vtkLight *)
Add a light to the list of lights.
vtkCullerCollection * GetCullers()
Return the collection of cullers.
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 *)
Set/Get the information object associated with this algorithm.
~vtkRenderer() override
virtual int UpdateGeometry(vtkFrameBufferObjectBase *fbo=nullptr)
Ask all props to update and draw any opaque and translucent geometry.
bool UseImageBasedLighting
int VisibleActorCount()
Returns the number of visible actors.
vtkTypeBool BackingStore
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
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.
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.
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.
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
void AllocateTime()
vtkRenderWindow * RenderWindow
int VisibleVolumeCount()
Returns the number of visible volumes.
vtkTypeBool AutomaticLightCreation
int NumberOfPropsRendered
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
virtual int UpdateOpaquePolygonalGeometry()
Ask all props to update and draw any opaque polygonal geometry.
double TimeFactor
bool TexturedBackground
vtkVolumeCollection * Volumes
vtkWindow * GetVTKWindow() override
Specify the rendering window in which to draw.
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...
const std::array< double, 16 > & GetProjectionTransformationMatrix()
Gets the ActiveCamera ProjectionTransformationMatrix, only computing it if necessary.
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.
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene.
vtkVolumeCollection * GetVolumes()
Return the collection of volumes.
vtkTexture * GetLeftBackgroundTexture()
Set/Get the texture to be used for the monocular or stereo left eye background.
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
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,...
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...
unsigned char * BackingImage
static vtkRenderer * New()
Create a vtkRenderer with a black background, a white ambient light, two-sided lighting turned on,...
vtkRendererDelegate * Delegate
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
double GetZ(int x, int y)
Given a pixel location, return the Z value.
vtkProp ** PropArray
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkCullerCollection * Cullers
void AddActor(vtkProp *p)
Add/Remove different types of props to the renderer.
virtual double GetTimeFactor()
Get the ratio between allocated time and actual render time.
double AllocatedRenderTime
double NearClippingPlaneTolerance
Specifies the minimum distance of the near clipping plane as a percentage of the far clipping plane d...
vtkTypeBool Draw
When this flag is off, render commands are ignored.
vtkHardwareSelector * Selector
virtual void DeviceRender()
Create an image.
vtkTypeBool TwoSidedLighting
vtkTexture * RightBackgroundTexture
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...
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
void WorldToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkLightCollection * Lights
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)
Set/Get the environment texture used for image based lighting.
vtkTimeStamp RenderTime
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.
vtkLightCollection * GetLights()
Return the collection of lights.
vtkTypeBool LightFollowCamera
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
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.
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.
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
void SetGL2PSSpecialPropCollection(vtkPropCollection *)
Set the prop collection object used during vtkRenderWindow::CaptureGL2PSSpecialProps().
vtkActorCollection * Actors
void SetDelegate(vtkRendererDelegate *d)
Set/Get a custom Render call.
vtkTypeBool Interactive
vtkInformation * Information
vtkAssemblyPath * PickProp(double selectionX, double selectionY) override
Return the prop (via a vtkAssemblyPath) that has the highest z value at the given x,...
vtkCamera * ActiveCamera
Hold a reference to a vtkObjectBase instance.
handles properties associated with a texture map
Definition vtkTexture.h:58
record modification and/or execution time
abstract specification for Viewports
Definition vtkViewport.h:45
virtual vtkAssemblyPath * PickProp(double selectionX, double selectionY)=0
Return the Prop that has the highest z value at the given x, y position in the viewport.
an ordered list of volumes
represents a volume (data & properties) in a rendered scene
Definition vtkVolume.h:40
window superclass for vtkRenderWindow
Definition vtkWindow.h:25
int vtkTypeBool
Definition vtkABI.h:64
vtkTypeUInt32 vtkMTimeType
Definition vtkType.h:270
#define VTK_SIZEHINT(...)