VTK  9.2.6
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=========================================================================*/
35#ifndef vtkRenderer_h
36#define vtkRenderer_h
37
38#include "vtkRenderingCoreModule.h" // For export macro
39#include "vtkViewport.h"
40
41#include "vtkActorCollection.h" // Needed for access in inline members
42#include "vtkVolumeCollection.h" // Needed for access in inline members
43
44#include <array> // To store matrices
45
46class vtkFXAAOptions;
47class vtkRenderWindow;
48class vtkVolume;
49class vtkCuller;
50class vtkActor;
51class vtkActor2D;
52class vtkCamera;
54class vtkInformation;
57class vtkLight;
60class vtkRenderPass;
61class vtkTexture;
62
63class vtkRecti;
64class vtkVector3d;
65
66class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
67{
68public:
69 vtkTypeMacro(vtkRenderer, vtkViewport);
70 void PrintSelf(ostream& os, vtkIndent indent) override;
71
77 static vtkRenderer* New();
78
80
85 void AddActor(vtkProp* p);
90
95
100
105
109 vtkLightCollection* GetLights();
110
118
122 void CreateLight(void);
123
129 virtual vtkLight* MakeLight();
130
132
138 vtkGetMacro(TwoSidedLighting, vtkTypeBool);
139 vtkSetMacro(TwoSidedLighting, vtkTypeBool);
140 vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);
142
144
157 vtkSetMacro(LightFollowCamera, vtkTypeBool);
158 vtkGetMacro(LightFollowCamera, vtkTypeBool);
159 vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
161
163
171 vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
172 vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
173 vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);
175
182
187
192
197
204
211
213
219 vtkSetMacro(Erase, vtkTypeBool);
220 vtkGetMacro(Erase, vtkTypeBool);
221 vtkBooleanMacro(Erase, vtkTypeBool);
223
225
230 vtkSetMacro(Draw, vtkTypeBool);
231 vtkGetMacro(Draw, vtkTypeBool);
232 vtkBooleanMacro(Draw, vtkTypeBool);
234
240
247
252
257
261 vtkCullerCollection* GetCullers();
262
264
267 vtkSetVector3Macro(Ambient, double);
268 vtkGetVectorMacro(Ambient, double, 3);
270
272
276 vtkSetMacro(AllocatedRenderTime, double);
277 virtual double GetAllocatedRenderTime();
279
286 virtual double GetTimeFactor();
287
294 virtual void Render();
295
299 virtual void DeviceRender(){};
300
308
319
324 virtual void ClearLights(void) {}
325
329 virtual void Clear() {}
330
335
340
345 void ComputeVisiblePropBounds(double bounds[6]);
346
351
356 virtual void ResetCameraClippingRange();
357
359
362 virtual void ResetCameraClippingRange(const double bounds[6]);
363 virtual void ResetCameraClippingRange(
364 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
366
368
373 vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
374 vtkGetMacro(NearClippingPlaneTolerance, double);
376
378
383 vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
384 vtkGetMacro(ClippingRangeExpansion, double);
386
393 virtual void ResetCamera();
394
404 virtual void ResetCamera(const double bounds[6]);
405
409 virtual void ResetCamera(
410 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
411
416 virtual void ResetCameraScreenSpace();
417
423 virtual void ResetCameraScreenSpace(const double bounds[6]);
424
425 using vtkViewport::DisplayToWorld;
426
430 vtkVector3d DisplayToWorld(const vtkVector3d& display);
431
437 void ZoomToBoxUsingViewAngle(const vtkRecti& box, const double offsetRatio = 1.0);
438
442 virtual void ResetCameraScreenSpace(
443 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
444
446
451 void SetRenderWindow(vtkRenderWindow*);
452 vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
455
457
463 vtkSetMacro(BackingStore, vtkTypeBool);
464 vtkGetMacro(BackingStore, vtkTypeBool);
465 vtkBooleanMacro(BackingStore, vtkTypeBool);
467
469
474 vtkSetMacro(Interactive, vtkTypeBool);
475 vtkGetMacro(Interactive, vtkTypeBool);
476 vtkBooleanMacro(Interactive, vtkTypeBool);
478
480
491 virtual void SetLayer(int layer);
492 vtkGetMacro(Layer, int);
494
496
506 vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
507 vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
508 vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
510
512
516 vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
517 vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
518 vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
520
526
530 void WorldToView() override;
531
533
536 void ViewToWorld() override;
537 void ViewToWorld(double& wx, double& wy, double& wz) override;
539
543 void WorldToView(double& wx, double& wy, double& wz) override;
544
546
549 void WorldToPose(double& wx, double& wy, double& wz) override;
550 void PoseToWorld(double& wx, double& wy, double& wz) override;
551 void ViewToPose(double& wx, double& wy, double& wz) override;
552 void PoseToView(double& wx, double& wy, double& wz) override;
554
559 double GetZ(int x, int y);
560
565
567
570 vtkGetMacro(LastRenderTimeInSeconds, double);
572
574
580 vtkGetMacro(NumberOfPropsRendered, int);
582
584
591 vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
592 {
593 return this->PickProp(selectionX, selectionY, selectionX, selectionY);
594 }
596 double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
598
600
609 vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
610 vtkSmartPointer<vtkSelection> selection) override
611 {
612 return this->PickProp(
613 selectionX, selectionY, selectionX, selectionY, fieldAssociation, selection);
614 }
615 vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
616 double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) override;
618
624 virtual void StereoMidpoint() { return; }
625
633
639 vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
640
642
652 vtkSetMacro(UseDepthPeeling, vtkTypeBool);
653 vtkGetMacro(UseDepthPeeling, vtkTypeBool);
654 vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
656
662 vtkSetMacro(UseDepthPeelingForVolumes, bool);
663 vtkGetMacro(UseDepthPeelingForVolumes, bool);
664 vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
665
667
676 vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
677 vtkGetMacro(OcclusionRatio, double);
679
681
686 vtkSetMacro(MaximumNumberOfPeels, int);
687 vtkGetMacro(MaximumNumberOfPeels, int);
689
691
696 vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
698
700
704 vtkSetMacro(UseSSAO, bool);
705 vtkGetMacro(UseSSAO, bool);
706 vtkBooleanMacro(UseSSAO, bool);
708
710
714 vtkSetMacro(SSAORadius, double);
715 vtkGetMacro(SSAORadius, double);
717
719
723 vtkSetMacro(SSAOBias, double);
724 vtkGetMacro(SSAOBias, double);
726
728
732 vtkSetMacro(SSAOKernelSize, unsigned int);
733 vtkGetMacro(SSAOKernelSize, unsigned int);
735
737
742 vtkSetMacro(SSAOBlur, bool);
743 vtkGetMacro(SSAOBlur, bool);
744 vtkBooleanMacro(SSAOBlur, bool);
746
748
755 vtkGetObjectMacro(Delegate, vtkRendererDelegate);
757
759
764 vtkGetObjectMacro(Selector, vtkHardwareSelector);
766
768
776 vtkGetObjectMacro(BackgroundTexture, vtkTexture);
778
780
785 vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
787
789
793 vtkSetMacro(TexturedBackground, bool);
794 vtkGetMacro(TexturedBackground, bool);
795 vtkBooleanMacro(TexturedBackground, bool);
797
798 // method to release graphics resources in any derived renderers.
800
802
805 vtkSetMacro(UseFXAA, bool);
806 vtkGetMacro(UseFXAA, bool);
807 vtkBooleanMacro(UseFXAA, bool);
809
811
814 vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
817
819
823 vtkSetMacro(UseShadows, vtkTypeBool);
824 vtkGetMacro(UseShadows, vtkTypeBool);
825 vtkBooleanMacro(UseShadows, vtkTypeBool);
827
829
833 vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
834 vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
835 vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
837
838 // Set/Get a custom render pass.
839 // Initial value is NULL.
841 vtkGetObjectMacro(Pass, vtkRenderPass);
842
844
847 vtkGetObjectMacro(Information, vtkInformation);
850
852
858 vtkSetMacro(UseImageBasedLighting, bool);
859 vtkGetMacro(UseImageBasedLighting, bool);
860 vtkBooleanMacro(UseImageBasedLighting, bool);
862
864
875 vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
876 virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
878
880
883 vtkGetVector3Macro(EnvironmentUp, double);
884 vtkSetVector3Macro(EnvironmentUp, double);
886
888
891 vtkGetVector3Macro(EnvironmentRight, double);
892 vtkSetVector3Macro(EnvironmentRight, double);
894
895protected:
897 ~vtkRenderer() override;
898
899 // internal method to expand bounding box to consider model transform
900 // matrix or model view transform matrix based on whether or not deering
901 // frustum is used. 'bounds' buffer is mutated to the expanded box.
902 virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
903
906
909
912
913 double Ambient[3];
920 unsigned char* BackingImage;
921 int BackingStoreSize[2];
923
925
927
928 // Allocate the time for each prop
930
931 // Internal variables indicating the number of props
932 // that have been or will be rendered in each category.
934
935 // A temporary list of props used for culling, and traversal
936 // of all props when rendering
939
940 // Indicates if the renderer should receive events from an interactor.
941 // Typically only used in conjunction with transparent renderers.
943
944 // Shows what layer this renderer belongs to. Only of interested when
945 // there are layered renderers.
946 int Layer;
949
950 // Holds the result of ComputeVisiblePropBounds so that it is visible from
951 // wrapped languages
952 double ComputedVisiblePropBounds[6];
953
962
968
976
983
988
993 const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
994
999 const std::array<double, 16>& GetProjectionTransformationMatrix();
1000
1005 const std::array<double, 16>& GetViewTransformMatrix();
1006
1012 virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
1013
1022
1029
1034 virtual int UpdateCamera(void);
1035
1042
1047 virtual int UpdateLights(void) { return 0; }
1048
1055
1061
1066
1072
1078
1086
1092
1103
1110
1111 bool UseSSAO = false;
1112 double SSAORadius = 0.5;
1113 double SSAOBias = 0.01;
1114 unsigned int SSAOKernelSize = 32;
1115 bool SSAOBlur = false;
1116
1123
1124 // HARDWARE SELECTION ----------------------------------------
1126
1131 {
1132 this->Selector = selector;
1133 this->Modified();
1134 }
1135
1136 // End Ivars for visible cell selecting.
1138
1139 //---------------------------------------------------------------
1142
1146
1147 friend class vtkRenderPass;
1149
1150 // Arbitrary extra information associated with this renderer
1152
1155
1156 double EnvironmentUp[3];
1157 double EnvironmentRight[3];
1158
1159private:
1163 std::array<double, 16> CompositeProjectionTransformationMatrix;
1164
1168 double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1169
1173 vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1174
1178 std::array<double, 16> ProjectionTransformationMatrix;
1179
1183 double LastProjectionTransformationMatrixTiledAspectRatio;
1184
1188 vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1189
1193 std::array<double, 16> ViewTransformMatrix;
1194
1198 vtkMTimeType LastViewTransformCameraModified;
1199
1200 vtkRenderer(const vtkRenderer&) = delete;
1201 void operator=(const vtkRenderer&) = delete;
1202};
1203
1205{
1206 return this->Lights;
1207}
1208
1213{
1214 return this->Cullers;
1215}
1216
1217#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
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:51
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:67
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.
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.
void SetPass(vtkRenderPass *p)
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.
vtkAssemblyPath * PickProp(double selectionX1, double selectionY1, double selectionX2, double selectionY2, int fieldAssociation, vtkSmartPointer< vtkSelection > selection) override
Return the Prop that has the highest z value at the given x1, y1 and x2,y2 positions in the viewport.
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 *)
virtual int UpdateLights(void)
Ask all lights to load themselves into rendering pipeline.
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
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)
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 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
bool TexturedBackground
vtkVolumeCollection * Volumes
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...
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.
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()
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 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...
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
These methods map from one coordinate system to another.
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
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 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
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.
vtkTypeBool LightFollowCamera
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
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.
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:66
record modification and/or execution time
abstract specification for Viewports
Definition vtkViewport.h:50
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(...)