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=========================================================================*/
150#ifndef vtkRenderer_h
151#define vtkRenderer_h
152
153#include "vtkRenderingCoreModule.h" // For export macro
154#include "vtkViewport.h"
155
156#include "vtkActorCollection.h" // Needed for access in inline members
157#include "vtkVolumeCollection.h" // Needed for access in inline members
158
159#include <array> // To store matrices
160
161class vtkFXAAOptions;
162class vtkRenderWindow;
163class vtkVolume;
164class vtkCuller;
165class vtkActor;
166class vtkActor2D;
167class vtkCamera;
169class vtkInformation;
172class vtkLight;
175class vtkRenderPass;
176class vtkTexture;
177
178class vtkRecti;
179class vtkVector3d;
180
181class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
182{
183public:
184 vtkTypeMacro(vtkRenderer, vtkViewport);
185 void PrintSelf(ostream& os, vtkIndent indent) override;
186
192 static vtkRenderer* New();
193
195
205
210
215
220
224 vtkLightCollection* GetLights();
225
233
237 void CreateLight(void);
238
244 virtual vtkLight* MakeLight();
245
247
253 vtkGetMacro(TwoSidedLighting, vtkTypeBool);
254 vtkSetMacro(TwoSidedLighting, vtkTypeBool);
255 vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);
257
259
272 vtkSetMacro(LightFollowCamera, vtkTypeBool);
273 vtkGetMacro(LightFollowCamera, vtkTypeBool);
274 vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
276
278
286 vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
287 vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
288 vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);
290
297
302
307
312
319
326
328
334 vtkSetMacro(Erase, vtkTypeBool);
335 vtkGetMacro(Erase, vtkTypeBool);
336 vtkBooleanMacro(Erase, vtkTypeBool);
338
340
345 vtkSetMacro(Draw, vtkTypeBool);
346 vtkGetMacro(Draw, vtkTypeBool);
347 vtkBooleanMacro(Draw, vtkTypeBool);
349
355
362
367
372
376 vtkCullerCollection* GetCullers();
377
379
382 vtkSetVector3Macro(Ambient, double);
383 vtkGetVectorMacro(Ambient, double, 3);
385
387
391 vtkSetMacro(AllocatedRenderTime, double);
392 virtual double GetAllocatedRenderTime();
394
401 virtual double GetTimeFactor();
402
409 virtual void Render();
410
414 virtual void DeviceRender(){};
415
423
434
439 virtual void ClearLights(void) {}
440
444 virtual void Clear() {}
445
450
455
460 void ComputeVisiblePropBounds(double bounds[6]);
461
466
471 virtual void ResetCameraClippingRange();
472
474
477 virtual void ResetCameraClippingRange(const double bounds[6]);
478 virtual void ResetCameraClippingRange(
479 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
481
483
488 vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
489 vtkGetMacro(NearClippingPlaneTolerance, double);
491
493
498 vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
499 vtkGetMacro(ClippingRangeExpansion, double);
501
508 virtual void ResetCamera();
509
519 virtual void ResetCamera(const double bounds[6]);
520
524 virtual void ResetCamera(
525 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
526
531 virtual void ResetCameraScreenSpace();
532
538 virtual void ResetCameraScreenSpace(const double bounds[6]);
539
540 using vtkViewport::DisplayToWorld;
541
545 vtkVector3d DisplayToWorld(const vtkVector3d& display);
546
552 void ZoomToBoxUsingViewAngle(const vtkRecti& box, const double offsetRatio = 1.0);
553
557 virtual void ResetCameraScreenSpace(
558 double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
559
561
566 void SetRenderWindow(vtkRenderWindow*);
567 vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
570
572
578 vtkSetMacro(BackingStore, vtkTypeBool);
579 vtkGetMacro(BackingStore, vtkTypeBool);
580 vtkBooleanMacro(BackingStore, vtkTypeBool);
582
584
589 vtkSetMacro(Interactive, vtkTypeBool);
590 vtkGetMacro(Interactive, vtkTypeBool);
591 vtkBooleanMacro(Interactive, vtkTypeBool);
593
595
606 virtual void SetLayer(int layer);
607 vtkGetMacro(Layer, int);
609
611
621 vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
622 vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
623 vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
625
627
631 vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
632 vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
633 vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
635
641
645 void WorldToView() override;
646
648
651 void ViewToWorld() override;
652 void ViewToWorld(double& wx, double& wy, double& wz) override;
654
658 void WorldToView(double& wx, double& wy, double& wz) override;
659
661
664 void WorldToPose(double& wx, double& wy, double& wz) override;
665 void PoseToWorld(double& wx, double& wy, double& wz) override;
666 void ViewToPose(double& wx, double& wy, double& wz) override;
667 void PoseToView(double& wx, double& wy, double& wz) override;
669
674 double GetZ(int x, int y);
675
680
682
685 vtkGetMacro(LastRenderTimeInSeconds, double);
687
689
695 vtkGetMacro(NumberOfPropsRendered, int);
697
699
706 vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
707 {
708 return this->PickProp(selectionX, selectionY, selectionX, selectionY);
709 }
711 double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
713
719 virtual void StereoMidpoint() { return; }
720
728
734 vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
735
737
747 vtkSetMacro(UseDepthPeeling, vtkTypeBool);
748 vtkGetMacro(UseDepthPeeling, vtkTypeBool);
749 vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
751
757 vtkSetMacro(UseDepthPeelingForVolumes, bool);
758 vtkGetMacro(UseDepthPeelingForVolumes, bool);
759 vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
760
762
771 vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
772 vtkGetMacro(OcclusionRatio, double);
774
776
781 vtkSetMacro(MaximumNumberOfPeels, int);
782 vtkGetMacro(MaximumNumberOfPeels, int);
784
786
791 vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
793
795
799 vtkSetMacro(UseSSAO, bool);
800 vtkGetMacro(UseSSAO, bool);
801 vtkBooleanMacro(UseSSAO, bool);
803
805
809 vtkSetMacro(SSAORadius, double);
810 vtkGetMacro(SSAORadius, double);
812
814
818 vtkSetMacro(SSAOBias, double);
819 vtkGetMacro(SSAOBias, double);
821
823
827 vtkSetMacro(SSAOKernelSize, unsigned int);
828 vtkGetMacro(SSAOKernelSize, unsigned int);
830
832
837 vtkSetMacro(SSAOBlur, bool);
838 vtkGetMacro(SSAOBlur, bool);
839 vtkBooleanMacro(SSAOBlur, bool);
841
843
850 vtkGetObjectMacro(Delegate, vtkRendererDelegate);
852
854
859 vtkGetObjectMacro(Selector, vtkHardwareSelector);
861
863
871 vtkGetObjectMacro(BackgroundTexture, vtkTexture);
873
875
880 vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
882
884
888 vtkSetMacro(TexturedBackground, bool);
889 vtkGetMacro(TexturedBackground, bool);
890 vtkBooleanMacro(TexturedBackground, bool);
892
893 // method to release graphics resources in any derived renderers.
895
897
900 vtkSetMacro(UseFXAA, bool);
901 vtkGetMacro(UseFXAA, bool);
902 vtkBooleanMacro(UseFXAA, bool);
904
906
909 vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
912
914
918 vtkSetMacro(UseShadows, vtkTypeBool);
919 vtkGetMacro(UseShadows, vtkTypeBool);
920 vtkBooleanMacro(UseShadows, vtkTypeBool);
922
924
928 vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
929 vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
930 vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
932
933 // Set/Get a custom render pass.
934 // Initial value is NULL.
936 vtkGetObjectMacro(Pass, vtkRenderPass);
937
939
942 vtkGetObjectMacro(Information, vtkInformation);
945
947
953 vtkSetMacro(UseImageBasedLighting, bool);
954 vtkGetMacro(UseImageBasedLighting, bool);
955 vtkBooleanMacro(UseImageBasedLighting, bool);
957
959
970 vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
971 virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
973
975
978 vtkGetVector3Macro(EnvironmentUp, double);
979 vtkSetVector3Macro(EnvironmentUp, double);
981
983
986 vtkGetVector3Macro(EnvironmentRight, double);
987 vtkSetVector3Macro(EnvironmentRight, double);
989
990protected:
992 ~vtkRenderer() override;
993
994 // internal method to expand bounding box to consider model transform
995 // matrix or model view transform matrix based on whether or not deering
996 // frustum is used. 'bounds' buffer is mutated to the expanded box.
997 virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
998
1001
1004
1007
1008 double Ambient[3];
1015 unsigned char* BackingImage;
1016 int BackingStoreSize[2];
1018
1020
1022
1023 // Allocate the time for each prop
1025
1026 // Internal variables indicating the number of props
1027 // that have been or will be rendered in each category.
1029
1030 // A temporary list of props used for culling, and traversal
1031 // of all props when rendering
1034
1035 // Indicates if the renderer should receive events from an interactor.
1036 // Typically only used in conjunction with transparent renderers.
1038
1039 // Shows what layer this renderer belongs to. Only of interested when
1040 // there are layered renderers.
1044
1045 // Holds the result of ComputeVisiblePropBounds so that it is visible from
1046 // wrapped languages
1047 double ComputedVisiblePropBounds[6];
1048
1057
1063
1071
1078
1083
1088 const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
1089
1094 const std::array<double, 16>& GetProjectionTransformationMatrix();
1095
1100 const std::array<double, 16>& GetViewTransformMatrix();
1101
1107 virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
1108
1117
1124
1129 virtual int UpdateCamera(void);
1130
1137
1142 virtual int UpdateLights(void) { return 0; }
1143
1150
1156
1161
1167
1173
1181
1187
1198
1205
1206 bool UseSSAO = false;
1207 double SSAORadius = 0.5;
1208 double SSAOBias = 0.01;
1209 unsigned int SSAOKernelSize = 32;
1210 bool SSAOBlur = false;
1211
1218
1219 // HARDWARE SELECTION ----------------------------------------
1221
1226 {
1227 this->Selector = selector;
1228 this->Modified();
1229 }
1230
1231 // End Ivars for visible cell selecting.
1233
1234 //---------------------------------------------------------------
1237
1241
1242 friend class vtkRenderPass;
1244
1245 // Arbitrary extra information associated with this renderer
1247
1250
1251 double EnvironmentUp[3];
1252 double EnvironmentRight[3];
1253
1254private:
1258 std::array<double, 16> CompositeProjectionTransformationMatrix;
1259
1263 double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1264
1268 vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1269
1273 std::array<double, 16> ProjectionTransformationMatrix;
1274
1278 double LastProjectionTransformationMatrixTiledAspectRatio;
1279
1283 vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1284
1288 std::array<double, 16> ViewTransformMatrix;
1289
1293 vtkMTimeType LastViewTransformCameraModified;
1294
1295 vtkRenderer(const vtkRenderer&) = delete;
1296 void operator=(const vtkRenderer&) = delete;
1297};
1298
1300{
1301 return this->Lights;
1302}
1303
1308{
1309 return this->Cullers;
1310}
1311
1312#endif
a actor that draws 2D data
Definition: vtkActor2D.h:149
an ordered list of actors
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:155
a list of nodes that form an assembly path
a virtual camera for 3D rendering
Definition: vtkCamera.h:155
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:113
Store vtkAlgorithm input/output information.
an ordered list of lights
a virtual light for 3D rendering
Definition: vtkLight.h:166
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:145
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:76
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:182
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:439
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:1043
vtkLight * CreatedLight
Definition: vtkRenderer.h:1000
vtkRenderPass * Pass
Definition: vtkRenderer.h:1243
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:1166
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:1019
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:1307
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:1142
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:1248
int VisibleActorCount()
Returns the number of visible actors.
vtkTypeBool BackingStore
Definition: vtkRenderer.h:1014
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:1249
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:1186
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:1225
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:1204
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
Definition: vtkRenderer.h:1217
void AllocateTime()
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:1009
int VisibleVolumeCount()
Returns the number of visible volumes.
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:1013
int NumberOfPropsRendered
Definition: vtkRenderer.h:1028
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
Definition: vtkRenderer.h:719
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:1011
bool TexturedBackground
Definition: vtkRenderer.h:1238
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:1006
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:1197
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:1070
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:1082
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene.
Definition: vtkRenderer.h:1155
vtkVolumeCollection * GetVolumes()
Return the collection of volumes.
vtkTexture * GetLeftBackgroundTexture()
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:1062
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:734
unsigned char * BackingImage
Definition: vtkRenderer.h:1015
static vtkRenderer * New()
Create a vtkRenderer with a black background, a white ambient light, two-sided lighting turned on,...
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1236
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:1239
double GetZ(int x, int y)
Given a pixel location, return the Z value.
vtkProp ** PropArray
Definition: vtkRenderer.h:1032
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:1003
void AddActor(vtkProp *p)
Add/Remove different types of props to the renderer.
int PropArrayCount
Definition: vtkRenderer.h:1033
virtual double GetTimeFactor()
Get the ratio between allocated time and actual render time.
double AllocatedRenderTime
Definition: vtkRenderer.h:1010
double NearClippingPlaneTolerance
Specifies the minimum distance of the near clipping plane as a percentage of the far clipping plane d...
Definition: vtkRenderer.h:1056
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:1077
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1232
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:414
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:1012
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1240
vtkTypeBool UseDepthPeeling
If this flag is on and the GPU supports it, depth peeling is used for rendering translucent materials...
Definition: vtkRenderer.h:1180
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:1172
void WorldToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkLightCollection * Lights
Definition: vtkRenderer.h:1002
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:1017
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:1299
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:1021
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:1160
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:444
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:1042
void SetGL2PSSpecialPropCollection(vtkPropCollection *)
Set the prop collection object used during vtkRenderWindow::CaptureGL2PSSpecialProps().
vtkActorCollection * Actors
Definition: vtkRenderer.h:1005
void SetDelegate(vtkRendererDelegate *d)
Set/Get a custom Render call.
vtkTypeBool Interactive
Definition: vtkRenderer.h:1037
vtkInformation * Information
Definition: vtkRenderer.h:1246
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:706
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:999
handles properties associated with a texture map
Definition: vtkTexture.h:175
record modification and/or execution time
Definition: vtkTimeStamp.h:52
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:144
window superclass for vtkRenderWindow
Definition: vtkWindow.h:39
int vtkTypeBool
Definition: vtkABI.h:69
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:287
#define VTK_SIZEHINT(...)