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
29#ifndef vtkRenderer_h
30#define vtkRenderer_h
31
32#include "vtkRenderingCoreModule.h" // For export macro
33#include "vtkViewport.h"
34
35#include "vtkActorCollection.h" // Needed for access in inline members
36#include "vtkVolumeCollection.h" // Needed for access in inline members
37
38#include <array> // To store matrices
39
40VTK_ABI_NAMESPACE_BEGIN
41class vtkFXAAOptions;
42class vtkRenderWindow;
43class vtkVolume;
44class vtkCuller;
45class vtkActor;
46class vtkActor2D;
47class vtkCamera;
49class vtkInformation;
52class vtkLight;
55class vtkRenderPass;
56class vtkTexture;
57
58class vtkRecti;
59class vtkVector3d;
60
61class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
62{
63public:
64 vtkTypeMacro(vtkRenderer, vtkViewport);
65 void PrintSelf(ostream& os, vtkIndent indent) override;
66
72 static vtkRenderer* New();
73
75
80 void AddActor(vtkProp* p);
85
90
95
100
104 vtkLightCollection* GetLights();
105
113
118
124 virtual vtkLight* MakeLight();
125
127
133 vtkGetMacro(TwoSidedLighting, vtkTypeBool);
134 vtkSetMacro(TwoSidedLighting, vtkTypeBool);
135 vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);
137
139
152 vtkSetMacro(LightFollowCamera, vtkTypeBool);
153 vtkGetMacro(LightFollowCamera, vtkTypeBool);
154 vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
156
158
166 vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
167 vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
168 vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);
170
177
182
187
192
199
206
208
214 vtkSetMacro(Erase, vtkTypeBool);
215 vtkGetMacro(Erase, vtkTypeBool);
216 vtkBooleanMacro(Erase, vtkTypeBool);
218
220
225 vtkSetMacro(Draw, vtkTypeBool);
226 vtkGetMacro(Draw, vtkTypeBool);
227 vtkBooleanMacro(Draw, vtkTypeBool);
229
235
242
247
252
256 vtkCullerCollection* GetCullers();
257
259
262 vtkSetVector3Macro(Ambient, double);
263 vtkGetVectorMacro(Ambient, double, 3);
265
267
271 vtkSetMacro(AllocatedRenderTime, double);
272 virtual double GetAllocatedRenderTime();
274
281 virtual double GetTimeFactor();
282
289 virtual void Render();
290
294 virtual void DeviceRender(){};
295
303
314
319 virtual void ClearLights() {}
320
324 virtual void Clear() {}
325
330
335
340 void ComputeVisiblePropBounds(double bounds[6]);
341
346
351 virtual void ResetCameraClippingRange();
352
354
357 virtual void ResetCameraClippingRange(const double bounds[6]);
358 virtual void ResetCameraClippingRange(
359 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
361
363
368 vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
369 vtkGetMacro(NearClippingPlaneTolerance, double);
371
373
378 vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
379 vtkGetMacro(ClippingRangeExpansion, double);
381
388 virtual void ResetCamera();
389
399 virtual void ResetCamera(const double bounds[6]);
400
404 virtual void ResetCamera(
405 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
406
414 virtual void ResetCameraScreenSpace(double offsetRatio = 0.9);
415
424 virtual void ResetCameraScreenSpace(const double bounds[6], double offsetRatio = 0.9);
425
426 using vtkViewport::DisplayToWorld;
427
431 vtkVector3d DisplayToWorld(const vtkVector3d& display);
432
438 void ZoomToBoxUsingViewAngle(const vtkRecti& box, double offsetRatio = 1.0);
439
446 virtual void ResetCameraScreenSpace(double xmin, double xmax, double ymin, double ymax,
447 double zmin, double zmax, double offsetRatio = 0.9);
448
450
455 void SetRenderWindow(vtkRenderWindow*);
456 vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
459
461
467 vtkSetMacro(BackingStore, vtkTypeBool);
468 vtkGetMacro(BackingStore, vtkTypeBool);
469 vtkBooleanMacro(BackingStore, vtkTypeBool);
471
473
478 vtkSetMacro(Interactive, vtkTypeBool);
479 vtkGetMacro(Interactive, vtkTypeBool);
480 vtkBooleanMacro(Interactive, vtkTypeBool);
482
484
495 virtual void SetLayer(int layer);
496 vtkGetMacro(Layer, int);
498
500
510 vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
511 vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
512 vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
514
516
520 vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
521 vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
522 vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
524
530
534 void WorldToView() override;
535
537
540 void ViewToWorld() override;
541 void ViewToWorld(double& wx, double& wy, double& wz) override;
543
547 void WorldToView(double& wx, double& wy, double& wz) override;
548
550
553 void WorldToPose(double& wx, double& wy, double& wz) override;
554 void PoseToWorld(double& wx, double& wy, double& wz) override;
555 void ViewToPose(double& wx, double& wy, double& wz) override;
556 void PoseToView(double& wx, double& wy, double& wz) override;
558
563 double GetZ(int x, int y);
564
569
571
574 vtkGetMacro(LastRenderTimeInSeconds, double);
576
578
584 vtkGetMacro(NumberOfPropsRendered, int);
586
588
595 vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
596 {
597 return this->PickProp(selectionX, selectionY, selectionX, selectionY);
598 }
600 double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
602
604
613 vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
614 vtkSmartPointer<vtkSelection> selection) override
615 {
616 return this->PickProp(
617 selectionX, selectionY, selectionX, selectionY, fieldAssociation, selection);
618 }
619 vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
620 double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) override;
622
628 virtual void StereoMidpoint() {}
629
637
643 vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
644
646
656 vtkSetMacro(UseDepthPeeling, vtkTypeBool);
657 vtkGetMacro(UseDepthPeeling, vtkTypeBool);
658 vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
660
666 vtkSetMacro(UseDepthPeelingForVolumes, bool);
667 vtkGetMacro(UseDepthPeelingForVolumes, bool);
668 vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
669
671
680 vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
681 vtkGetMacro(OcclusionRatio, double);
683
685
690 vtkSetMacro(MaximumNumberOfPeels, int);
691 vtkGetMacro(MaximumNumberOfPeels, int);
693
695
700 vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
702
704
708 vtkSetMacro(UseSSAO, bool);
709 vtkGetMacro(UseSSAO, bool);
710 vtkBooleanMacro(UseSSAO, bool);
712
714
718 vtkSetMacro(SSAORadius, double);
719 vtkGetMacro(SSAORadius, double);
721
723
727 vtkSetMacro(SSAOBias, double);
728 vtkGetMacro(SSAOBias, double);
730
732
736 vtkSetMacro(SSAOKernelSize, unsigned int);
737 vtkGetMacro(SSAOKernelSize, unsigned int);
739
741
746 vtkSetMacro(SSAOBlur, bool);
747 vtkGetMacro(SSAOBlur, bool);
748 vtkBooleanMacro(SSAOBlur, bool);
750
752
759 vtkGetObjectMacro(Delegate, vtkRendererDelegate);
761
763
768 vtkGetObjectMacro(Selector, vtkHardwareSelector);
770
772
780 vtkGetObjectMacro(BackgroundTexture, vtkTexture);
782
784
789 vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
791
793
797 vtkSetMacro(TexturedBackground, bool);
798 vtkGetMacro(TexturedBackground, bool);
799 vtkBooleanMacro(TexturedBackground, bool);
801
802 // method to release graphics resources in any derived renderers.
804
806
809 vtkSetMacro(UseFXAA, bool);
810 vtkGetMacro(UseFXAA, bool);
811 vtkBooleanMacro(UseFXAA, bool);
813
815
818 vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
821
823
827 vtkSetMacro(UseShadows, vtkTypeBool);
828 vtkGetMacro(UseShadows, vtkTypeBool);
829 vtkBooleanMacro(UseShadows, vtkTypeBool);
831
833
837 vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
838 vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
839 vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
841
842 // Set/Get a custom render pass.
843 // Initial value is NULL.
845 vtkGetObjectMacro(Pass, vtkRenderPass);
846
848
851 vtkGetObjectMacro(Information, vtkInformation);
854
856
862 vtkSetMacro(UseImageBasedLighting, bool);
863 vtkGetMacro(UseImageBasedLighting, bool);
864 vtkBooleanMacro(UseImageBasedLighting, bool);
866
868
879 vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
880 virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
882
884
887 vtkGetVector3Macro(EnvironmentUp, double);
888 vtkSetVector3Macro(EnvironmentUp, double);
890
892
895 vtkGetVector3Macro(EnvironmentRight, double);
896 vtkSetVector3Macro(EnvironmentRight, double);
898
899protected:
901 ~vtkRenderer() override;
902
903 // internal method to expand bounding box to consider model transform
904 // matrix or model view transform matrix based on whether or not deering
905 // frustum is used. 'bounds' buffer is mutated to the expanded box.
906 virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
907
910
913
916
917 double Ambient[3];
924 unsigned char* BackingImage;
925 int BackingStoreSize[2];
927
929
931
932 // Allocate the time for each prop
934
935 // Internal variables indicating the number of props
936 // that have been or will be rendered in each category.
938
939 // A temporary list of props used for culling, and traversal
940 // of all props when rendering
943
944 // Indicates if the renderer should receive events from an interactor.
945 // Typically only used in conjunction with transparent renderers.
947
948 // Shows what layer this renderer belongs to. Only of interested when
949 // there are layered renderers.
950 int Layer;
953
954 // Holds the result of ComputeVisiblePropBounds so that it is visible from
955 // wrapped languages
956 double ComputedVisiblePropBounds[6];
957
966
972
980
987
992
997 const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
998
1003 const std::array<double, 16>& GetProjectionTransformationMatrix();
1004
1009 const std::array<double, 16>& GetViewTransformMatrix();
1010
1016 virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
1017
1026
1033
1038 virtual int UpdateCamera();
1039
1046
1051 virtual int UpdateLights() { return 0; }
1052
1059
1065
1070
1076
1082
1090
1096
1107
1114
1115 bool UseSSAO = false;
1116 double SSAORadius = 0.5;
1117 double SSAOBias = 0.01;
1118 unsigned int SSAOKernelSize = 32;
1119 bool SSAOBlur = false;
1120
1127
1128 // HARDWARE SELECTION ----------------------------------------
1130
1135 {
1136 this->Selector = selector;
1137 this->Modified();
1138 }
1139
1140 // End Ivars for visible cell selecting.
1142
1143 //---------------------------------------------------------------
1146
1150
1151 friend class vtkRenderPass;
1153
1154 // Arbitrary extra information associated with this renderer
1156
1159
1160 double EnvironmentUp[3];
1161 double EnvironmentRight[3];
1162
1163private:
1167 std::array<double, 16> CompositeProjectionTransformationMatrix;
1168
1172 double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1173
1177 vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1178
1182 std::array<double, 16> ProjectionTransformationMatrix;
1183
1187 double LastProjectionTransformationMatrixTiledAspectRatio;
1188
1192 vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1193
1197 std::array<double, 16> ViewTransformMatrix;
1198
1202 vtkMTimeType LastViewTransformCameraModified;
1203
1204 vtkRenderer(const vtkRenderer&) = delete;
1205 void operator=(const vtkRenderer&) = delete;
1206};
1207
1209{
1210 return this->Lights;
1211}
1212
1217{
1218 return this->Cullers;
1219}
1220
1221VTK_ABI_NAMESPACE_END
1222#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:46
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:62
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:28
int vtkTypeBool
Definition vtkABI.h:64
vtkTypeUInt32 vtkMTimeType
Definition vtkType.h:270
#define VTK_SIZEHINT(...)