VTK  9.3.20230928
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
138 #ifndef vtkRenderer_h
139 #define vtkRenderer_h
140 
141 #include "vtkRenderingCoreModule.h" // For export macro
142 #include "vtkViewport.h"
143 
144 #include "vtkActorCollection.h" // Needed for access in inline members
145 #include "vtkVolumeCollection.h" // Needed for access in inline members
146 
147 #include <array> // To store matrices
148 
149 VTK_ABI_NAMESPACE_BEGIN
150 class vtkFXAAOptions;
151 class vtkRenderWindow;
152 class vtkVolume;
153 class vtkCuller;
154 class vtkActor;
155 class vtkActor2D;
156 class vtkCamera;
158 class vtkInformation;
159 class vtkLightCollection;
160 class vtkCullerCollection;
161 class vtkLight;
162 class vtkHardwareSelector;
163 class vtkRendererDelegate;
164 class vtkRenderPass;
165 class vtkTexture;
166 
167 class vtkRecti;
168 class vtkVector3d;
169 
170 class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
171 {
172 public:
173  vtkTypeMacro(vtkRenderer, vtkViewport);
174  void PrintSelf(ostream& os, vtkIndent indent) override;
175 
181  static vtkRenderer* New();
182 
184 
189  void AddActor(vtkProp* p);
190  void AddVolume(vtkProp* p);
194 
199 
204 
209 
213  vtkLightCollection* GetLights();
214 
222 
226  void CreateLight();
227 
233  virtual vtkLight* MakeLight();
234 
236 
242  vtkGetMacro(TwoSidedLighting, vtkTypeBool);
243  vtkSetMacro(TwoSidedLighting, vtkTypeBool);
244  vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);
246 
248 
261  vtkSetMacro(LightFollowCamera, vtkTypeBool);
262  vtkGetMacro(LightFollowCamera, vtkTypeBool);
263  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
265 
267 
275  vtkGetMacro(AutomaticLightCreation, vtkTypeBool);
276  vtkSetMacro(AutomaticLightCreation, vtkTypeBool);
277  vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);
279 
286 
291 
296 
301 
308 
314  virtual vtkCamera* MakeCamera();
315 
317 
323  vtkSetMacro(Erase, vtkTypeBool);
324  vtkGetMacro(Erase, vtkTypeBool);
325  vtkBooleanMacro(Erase, vtkTypeBool);
327 
329 
334  vtkSetMacro(Draw, vtkTypeBool);
335  vtkGetMacro(Draw, vtkTypeBool);
336  vtkBooleanMacro(Draw, vtkTypeBool);
338 
344 
351 
356 
361 
365  vtkCullerCollection* GetCullers();
366 
368 
371  vtkSetVector3Macro(Ambient, double);
372  vtkGetVectorMacro(Ambient, double, 3);
374 
376 
380  vtkSetMacro(AllocatedRenderTime, double);
381  virtual double GetAllocatedRenderTime();
383 
390  virtual double GetTimeFactor();
391 
398  virtual void Render();
399 
403  virtual void DeviceRender() {}
404 
412 
423 
428  virtual void ClearLights() {}
429 
433  virtual void Clear() {}
434 
439 
444 
449  void ComputeVisiblePropBounds(double bounds[6]);
450 
455 
460  virtual void ResetCameraClippingRange();
461 
463 
466  virtual void ResetCameraClippingRange(const double bounds[6]);
467  virtual void ResetCameraClippingRange(
468  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
470 
472 
477  vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);
478  vtkGetMacro(NearClippingPlaneTolerance, double);
480 
482 
487  vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);
488  vtkGetMacro(ClippingRangeExpansion, double);
490 
497  virtual void ResetCamera();
498 
508  virtual void ResetCamera(const double bounds[6]);
509 
513  virtual void ResetCamera(
514  double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
515 
523  virtual void ResetCameraScreenSpace(double offsetRatio = 0.9);
524 
533  virtual void ResetCameraScreenSpace(const double bounds[6], double offsetRatio = 0.9);
534 
535  using vtkViewport::DisplayToWorld;
536 
540  vtkVector3d DisplayToWorld(const vtkVector3d& display);
541 
547  void ZoomToBoxUsingViewAngle(const vtkRecti& box, double offsetRatio = 1.0);
548 
555  virtual void ResetCameraScreenSpace(double xmin, double xmax, double ymin, double ymax,
556  double zmin, double zmax, double offsetRatio = 0.9);
557 
559 
564  void SetRenderWindow(vtkRenderWindow*);
565  vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }
566  vtkWindow* GetVTKWindow() override;
568 
570 
576  vtkSetMacro(BackingStore, vtkTypeBool);
577  vtkGetMacro(BackingStore, vtkTypeBool);
578  vtkBooleanMacro(BackingStore, vtkTypeBool);
580 
582 
587  vtkSetMacro(Interactive, vtkTypeBool);
588  vtkGetMacro(Interactive, vtkTypeBool);
589  vtkBooleanMacro(Interactive, vtkTypeBool);
591 
593 
604  virtual void SetLayer(int layer);
605  vtkGetMacro(Layer, int);
607 
609 
619  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
620  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
621  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
623 
625 
629  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
630  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
631  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
633 
639 
643  void WorldToView() override;
644 
646 
649  void ViewToWorld() override;
650  void ViewToWorld(double& wx, double& wy, double& wz) override;
652 
656  void WorldToView(double& wx, double& wy, double& wz) override;
657 
659 
662  void WorldToPose(double& wx, double& wy, double& wz) override;
663  void PoseToWorld(double& wx, double& wy, double& wz) override;
664  void ViewToPose(double& wx, double& wy, double& wz) override;
665  void PoseToView(double& wx, double& wy, double& wz) override;
667 
672  double GetZ(int x, int y);
673 
677  vtkMTimeType GetMTime() override;
678 
680 
683  vtkGetMacro(LastRenderTimeInSeconds, double);
685 
687 
693  vtkGetMacro(NumberOfPropsRendered, int);
695 
697 
704  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
705  {
706  return this->PickProp(selectionX, selectionY, selectionX, selectionY);
707  }
709  double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;
711 
713 
722  vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
723  vtkSmartPointer<vtkSelection> selection) override
724  {
725  return this->PickProp(
726  selectionX, selectionY, selectionX, selectionY, fieldAssociation, selection);
727  }
728  vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
729  double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) override;
731 
737  virtual void StereoMidpoint() {}
738 
746 
752  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
753 
755 
765  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
766  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
767  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
769 
775  vtkSetMacro(UseDepthPeelingForVolumes, bool);
776  vtkGetMacro(UseDepthPeelingForVolumes, bool);
777  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
778 
780 
789  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
790  vtkGetMacro(OcclusionRatio, double);
792 
794 
799  vtkSetMacro(MaximumNumberOfPeels, int);
800  vtkGetMacro(MaximumNumberOfPeels, int);
802 
804 
809  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
811 
813 
817  vtkSetMacro(UseSSAO, bool);
818  vtkGetMacro(UseSSAO, bool);
819  vtkBooleanMacro(UseSSAO, bool);
821 
823 
827  vtkSetMacro(SSAORadius, double);
828  vtkGetMacro(SSAORadius, double);
830 
832 
836  vtkSetMacro(SSAOBias, double);
837  vtkGetMacro(SSAOBias, double);
839 
841 
845  vtkSetMacro(SSAOKernelSize, unsigned int);
846  vtkGetMacro(SSAOKernelSize, unsigned int);
848 
850 
855  vtkSetMacro(SSAOBlur, bool);
856  vtkGetMacro(SSAOBlur, bool);
857  vtkBooleanMacro(SSAOBlur, bool);
859 
861 
868  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
870 
872 
877  vtkGetObjectMacro(Selector, vtkHardwareSelector);
879 
881 
889  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
891 
893 
898  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
900 
902 
906  vtkSetMacro(TexturedBackground, bool);
907  vtkGetMacro(TexturedBackground, bool);
908  vtkBooleanMacro(TexturedBackground, bool);
910 
911  // method to release graphics resources in any derived renderers.
913 
915 
918  vtkSetMacro(UseFXAA, bool);
919  vtkGetMacro(UseFXAA, bool);
920  vtkBooleanMacro(UseFXAA, bool);
922 
924 
927  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
930 
932 
936  vtkSetMacro(UseShadows, vtkTypeBool);
937  vtkGetMacro(UseShadows, vtkTypeBool);
938  vtkBooleanMacro(UseShadows, vtkTypeBool);
940 
942 
946  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
947  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
948  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
950 
951  // Set/Get a custom render pass.
952  // Initial value is NULL.
954  vtkGetObjectMacro(Pass, vtkRenderPass);
955 
957 
960  vtkGetObjectMacro(Information, vtkInformation);
963 
965 
971  vtkSetMacro(UseImageBasedLighting, bool);
972  vtkGetMacro(UseImageBasedLighting, bool);
973  vtkBooleanMacro(UseImageBasedLighting, bool);
975 
977 
982  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
983  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
985 
987 
990  vtkGetVector3Macro(EnvironmentUp, double);
991  vtkSetVector3Macro(EnvironmentUp, double);
993 
995 
998  vtkGetVector3Macro(EnvironmentRight, double);
999  vtkSetVector3Macro(EnvironmentRight, double);
1001 
1002 protected:
1004  ~vtkRenderer() override;
1005 
1006  // internal method to expand bounding box to consider model transform
1007  // matrix or model view transform matrix based on whether or not deering
1008  // frustum is used. 'bounds' buffer is mutated to the expanded box.
1009  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
1010 
1013 
1016 
1019 
1020  double Ambient[3];
1023  double TimeFactor;
1027  unsigned char* BackingImage;
1028  int BackingStoreSize[2];
1030 
1032 
1034 
1035  // Allocate the time for each prop
1037 
1038  // Internal variables indicating the number of props
1039  // that have been or will be rendered in each category.
1041 
1042  // A temporary list of props used for culling, and traversal
1043  // of all props when rendering
1046 
1047  // Indicates if the renderer should receive events from an interactor.
1048  // Typically only used in conjunction with transparent renderers.
1050 
1051  // Shows what layer this renderer belongs to. Only of interested when
1052  // there are layered renderers.
1053  int Layer;
1056 
1057  // Holds the result of ComputeVisiblePropBounds so that it is visible from
1058  // wrapped languages
1059  double ComputedVisiblePropBounds[6];
1060 
1069 
1075 
1083 
1090 
1095 
1100  const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
1101 
1106  const std::array<double, 16>& GetProjectionTransformationMatrix();
1107 
1112  const std::array<double, 16>& GetViewTransformMatrix();
1113 
1119  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
1120 
1129 
1136 
1141  virtual int UpdateCamera();
1142 
1149 
1154  virtual int UpdateLights() { return 0; }
1155 
1162 
1167  bool UseFXAA;
1168 
1173 
1179 
1185 
1193 
1199 
1210 
1217 
1218  bool UseSSAO = false;
1219  double SSAORadius = 0.5;
1220  double SSAOBias = 0.01;
1221  unsigned int SSAOKernelSize = 32;
1222  bool SSAOBlur = false;
1223 
1230 
1231  // HARDWARE SELECTION ----------------------------------------
1232  friend class vtkHardwareSelector;
1233 
1238  {
1239  this->Selector = selector;
1240  this->Modified();
1241  }
1242 
1243  // End Ivars for visible cell selecting.
1245 
1246  //---------------------------------------------------------------
1247  friend class vtkRendererDelegate;
1249 
1253 
1254  friend class vtkRenderPass;
1256 
1257  // Arbitrary extra information associated with this renderer
1259 
1262 
1263  double EnvironmentUp[3];
1264  double EnvironmentRight[3];
1265 
1266 private:
1270  std::array<double, 16> CompositeProjectionTransformationMatrix;
1271 
1275  double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1276 
1280  vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1281 
1285  std::array<double, 16> ProjectionTransformationMatrix;
1286 
1290  double LastProjectionTransformationMatrixTiledAspectRatio;
1291 
1295  vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1296 
1300  std::array<double, 16> ViewTransformMatrix;
1301 
1305  vtkMTimeType LastViewTransformCameraModified;
1306 
1307  vtkRenderer(const vtkRenderer&) = delete;
1308  void operator=(const vtkRenderer&) = delete;
1309 };
1310 
1312 {
1313  return this->Lights;
1314 }
1315 
1320 {
1321  return this->Cullers;
1322 }
1323 
1324 VTK_ABI_NAMESPACE_END
1325 #endif
a actor that draws 2D data
Definition: vtkActor2D.h:144
an ordered list of actors
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:150
a list of nodes that form an assembly path
a virtual camera for 3D rendering
Definition: vtkCamera.h:150
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:108
Store vtkAlgorithm input/output information.
an ordered list of lights
a virtual light for 3D rendering
Definition: vtkLight.h:158
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:140
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:65
Perform part of the rendering of a vtkRenderer.
Definition: vtkRenderPass.h:49
create a window for renderers to draw into
Render the props of a vtkRenderer.
abstract specification for renderers
Definition: vtkRenderer.h:171
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.
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.
const std::array< double, 16 > & GetViewTransformMatrix()
Gets the ActiveCamera ViewTransformMatrix, only computing it if necessary.
virtual int UpdateCamera()
Ask the active camera to do whatever it needs to do prior to rendering.
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.
Definition: vtkRenderer.h:1154
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:1055
vtkLight * CreatedLight
Definition: vtkRenderer.h:1012
vtkRenderPass * Pass
Definition: vtkRenderer.h:1255
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:1178
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
static vtkRenderer * New()
Create a vtkRenderer with a black background, a white ambient light, two-sided lighting turned on,...
double LastRenderTimeInSeconds
Definition: vtkRenderer.h:1031
double GetTiledAspectRatio()
Compute the aspect ratio of this renderer for the current tile.
void CreateLight()
Create and add a light to renderer.
vtkCamera * GetActiveCameraAndResetIfCreated()
Get the current camera and reset it only if it gets created automatically (see GetActiveCamera).
void AddLight(vtkLight *)
Add a light to the list of lights.
vtkCullerCollection * GetCullers()
Return the collection of cullers.
Definition: vtkRenderer.h:1319
virtual vtkLight * MakeLight()
Create a new Light 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.
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,...
Definition: vtkRenderer.h:722
~vtkRenderer() override
virtual int UpdateGeometry(vtkFrameBufferObjectBase *fbo=nullptr)
Ask all props to update and draw any opaque and translucent geometry.
vtkWindow * GetVTKWindow() override
Specify the rendering window in which to draw.
vtkActorCollection * GetActors()
Return any actors in this renderer.
bool UseImageBasedLighting
Definition: vtkRenderer.h:1260
int VisibleActorCount()
Returns the number of visible actors.
vtkTypeBool BackingStore
Definition: vtkRenderer.h:1026
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1261
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:1198
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.
Definition: vtkRenderer.h:1237
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:1216
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
Definition: vtkRenderer.h:1229
void AllocateTime()
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:1021
int VisibleVolumeCount()
Returns the number of visible volumes.
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:1025
int NumberOfPropsRendered
Definition: vtkRenderer.h:1040
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
Definition: vtkRenderer.h:737
virtual int UpdateOpaquePolygonalGeometry()
Ask all props to update and draw any opaque polygonal geometry.
double TimeFactor
Definition: vtkRenderer.h:1023
bool TexturedBackground
Definition: vtkRenderer.h:1250
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,...
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:1018
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:1209
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:704
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.
Definition: vtkRenderer.h:1082
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:1094
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene.
Definition: vtkRenderer.h:1167
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:1074
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...
Definition: vtkRenderer.h:752
unsigned char * BackingImage
Definition: vtkRenderer.h:1027
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1248
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
Definition: vtkRenderer.h:1251
virtual vtkCamera * MakeCamera()
Create a new Camera sutible for use with this type of Renderer.
double GetZ(int x, int y)
Given a pixel location, return the Z value.
vtkProp ** PropArray
Definition: vtkRenderer.h:1044
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:1015
vtkCamera * GetActiveCamera()
Get the current camera.
void AddActor(vtkProp *p)
Add/Remove different types of props to the renderer.
int PropArrayCount
Definition: vtkRenderer.h:1045
virtual double GetTimeFactor()
Get the ratio between allocated time and actual render time.
double AllocatedRenderTime
Definition: vtkRenderer.h:1022
const std::array< double, 16 > & GetProjectionTransformationMatrix()
Gets the ActiveCamera ProjectionTransformationMatrix, only computing it if necessary.
double NearClippingPlaneTolerance
Specifies the minimum distance of the near clipping plane as a percentage of the far clipping plane d...
Definition: vtkRenderer.h:1068
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:1089
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1244
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:403
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:1024
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1252
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...
Definition: vtkRenderer.h:1192
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:1184
void WorldToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkLightCollection * Lights
Definition: vtkRenderer.h:1014
vtkTexture * GetLeftBackgroundTexture()
Set/Get the texture to be used for the monocular or stereo left eye background.
void ViewToWorld() override
Convert view point coordinates to world coordinates.
vtkVolumeCollection * GetVolumes()
Return the collection of volumes.
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
Definition: vtkRenderer.h:1029
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.
Definition: vtkRenderer.h:428
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:1311
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:1033
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:1172
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.
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,...
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.
Definition: vtkRenderer.h:433
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:1054
void SetGL2PSSpecialPropCollection(vtkPropCollection *)
Set the prop collection object used during vtkRenderWindow::CaptureGL2PSSpecialProps().
vtkActorCollection * Actors
Definition: vtkRenderer.h:1017
void SetDelegate(vtkRendererDelegate *d)
Set/Get a custom Render call.
vtkTypeBool Interactive
Definition: vtkRenderer.h:1049
vtkInformation * Information
Definition: vtkRenderer.h:1258
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:1011
const std::array< double, 16 > & GetCompositeProjectionTransformationMatrix()
Gets the ActiveCamera CompositeProjectionTransformationMatrix, only computing it if necessary.
handles properties associated with a texture map
Definition: vtkTexture.h:167
record modification and/or execution time
Definition: vtkTimeStamp.h:44
abstract specification for Viewports
Definition: vtkViewport.h:64
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:119
window superclass for vtkRenderWindow
Definition: vtkWindow.h:47
int vtkTypeBool
Definition: vtkABI.h:64
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:270
#define VTK_SIZEHINT(...)