VTK  9.1.20220524
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 
161 class vtkFXAAOptions;
162 class vtkRenderWindow;
163 class vtkVolume;
164 class vtkCuller;
165 class vtkActor;
166 class vtkActor2D;
167 class vtkCamera;
169 class vtkInformation;
170 class vtkLightCollection;
171 class vtkCullerCollection;
172 class vtkLight;
173 class vtkHardwareSelector;
174 class vtkRendererDelegate;
175 class vtkRenderPass;
176 class vtkTexture;
177 
178 class vtkRecti;
179 class vtkVector3d;
180 
181 class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
182 {
183 public:
184  vtkTypeMacro(vtkRenderer, vtkViewport);
185  void PrintSelf(ostream& os, vtkIndent indent) override;
186 
192  static vtkRenderer* New();
193 
195 
200  void AddActor(vtkProp* p);
201  void AddVolume(vtkProp* p);
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 
325  virtual vtkCamera* MakeCamera();
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; }
568  vtkWindow* GetVTKWindow() override;
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 
640  int Transparent();
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 
679  vtkMTimeType GetMTime() override;
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 
715 
724  vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
725  vtkSmartPointer<vtkSelection> selection) override
726  {
727  return this->PickProp(
728  selectionX, selectionY, selectionX, selectionY, fieldAssociation, selection);
729  }
730  vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
731  double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) override;
733 
739  virtual void StereoMidpoint() { return; }
740 
748 
754  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }
755 
757 
767  vtkSetMacro(UseDepthPeeling, vtkTypeBool);
768  vtkGetMacro(UseDepthPeeling, vtkTypeBool);
769  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);
771 
777  vtkSetMacro(UseDepthPeelingForVolumes, bool);
778  vtkGetMacro(UseDepthPeelingForVolumes, bool);
779  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);
780 
782 
791  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);
792  vtkGetMacro(OcclusionRatio, double);
794 
796 
801  vtkSetMacro(MaximumNumberOfPeels, int);
802  vtkGetMacro(MaximumNumberOfPeels, int);
804 
806 
811  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);
813 
815 
819  vtkSetMacro(UseSSAO, bool);
820  vtkGetMacro(UseSSAO, bool);
821  vtkBooleanMacro(UseSSAO, bool);
823 
825 
829  vtkSetMacro(SSAORadius, double);
830  vtkGetMacro(SSAORadius, double);
832 
834 
838  vtkSetMacro(SSAOBias, double);
839  vtkGetMacro(SSAOBias, double);
841 
843 
847  vtkSetMacro(SSAOKernelSize, unsigned int);
848  vtkGetMacro(SSAOKernelSize, unsigned int);
850 
852 
857  vtkSetMacro(SSAOBlur, bool);
858  vtkGetMacro(SSAOBlur, bool);
859  vtkBooleanMacro(SSAOBlur, bool);
861 
863 
870  vtkGetObjectMacro(Delegate, vtkRendererDelegate);
872 
874 
879  vtkGetObjectMacro(Selector, vtkHardwareSelector);
881 
883 
891  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
893 
895 
900  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
902 
904 
908  vtkSetMacro(TexturedBackground, bool);
909  vtkGetMacro(TexturedBackground, bool);
910  vtkBooleanMacro(TexturedBackground, bool);
912 
913  // method to release graphics resources in any derived renderers.
915 
917 
920  vtkSetMacro(UseFXAA, bool);
921  vtkGetMacro(UseFXAA, bool);
922  vtkBooleanMacro(UseFXAA, bool);
924 
926 
929  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);
932 
934 
938  vtkSetMacro(UseShadows, vtkTypeBool);
939  vtkGetMacro(UseShadows, vtkTypeBool);
940  vtkBooleanMacro(UseShadows, vtkTypeBool);
942 
944 
948  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);
949  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);
950  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);
952 
953  // Set/Get a custom render pass.
954  // Initial value is NULL.
956  vtkGetObjectMacro(Pass, vtkRenderPass);
957 
959 
962  vtkGetObjectMacro(Information, vtkInformation);
965 
967 
973  vtkSetMacro(UseImageBasedLighting, bool);
974  vtkGetMacro(UseImageBasedLighting, bool);
975  vtkBooleanMacro(UseImageBasedLighting, bool);
977 
979 
990  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);
991  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);
993 
995 
998  vtkGetVector3Macro(EnvironmentUp, double);
999  vtkSetVector3Macro(EnvironmentUp, double);
1001 
1003 
1006  vtkGetVector3Macro(EnvironmentRight, double);
1007  vtkSetVector3Macro(EnvironmentRight, double);
1009 
1010 protected:
1012  ~vtkRenderer() override;
1013 
1014  // internal method to expand bounding box to consider model transform
1015  // matrix or model view transform matrix based on whether or not deering
1016  // frustum is used. 'bounds' buffer is mutated to the expanded box.
1017  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);
1018 
1021 
1024 
1027 
1028  double Ambient[3];
1031  double TimeFactor;
1035  unsigned char* BackingImage;
1036  int BackingStoreSize[2];
1038 
1040 
1042 
1043  // Allocate the time for each prop
1045 
1046  // Internal variables indicating the number of props
1047  // that have been or will be rendered in each category.
1049 
1050  // A temporary list of props used for culling, and traversal
1051  // of all props when rendering
1054 
1055  // Indicates if the renderer should receive events from an interactor.
1056  // Typically only used in conjunction with transparent renderers.
1058 
1059  // Shows what layer this renderer belongs to. Only of interested when
1060  // there are layered renderers.
1061  int Layer;
1064 
1065  // Holds the result of ComputeVisiblePropBounds so that it is visible from
1066  // wrapped languages
1067  double ComputedVisiblePropBounds[6];
1068 
1077 
1083 
1091 
1098 
1103 
1108  const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
1109 
1114  const std::array<double, 16>& GetProjectionTransformationMatrix();
1115 
1120  const std::array<double, 16>& GetViewTransformMatrix();
1121 
1127  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);
1128 
1137 
1144 
1149  virtual int UpdateCamera(void);
1150 
1157 
1162  virtual int UpdateLights(void) { return 0; }
1163 
1170 
1175  bool UseFXAA;
1176 
1181 
1187 
1193 
1201 
1207 
1218 
1225 
1226  bool UseSSAO = false;
1227  double SSAORadius = 0.5;
1228  double SSAOBias = 0.01;
1229  unsigned int SSAOKernelSize = 32;
1230  bool SSAOBlur = false;
1231 
1238 
1239  // HARDWARE SELECTION ----------------------------------------
1240  friend class vtkHardwareSelector;
1241 
1246  {
1247  this->Selector = selector;
1248  this->Modified();
1249  }
1250 
1251  // End Ivars for visible cell selecting.
1253 
1254  //---------------------------------------------------------------
1255  friend class vtkRendererDelegate;
1257 
1261 
1262  friend class vtkRenderPass;
1264 
1265  // Arbitrary extra information associated with this renderer
1267 
1270 
1271  double EnvironmentUp[3];
1272  double EnvironmentRight[3];
1273 
1274 private:
1278  std::array<double, 16> CompositeProjectionTransformationMatrix;
1279 
1283  double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
1284 
1288  vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
1289 
1293  std::array<double, 16> ProjectionTransformationMatrix;
1294 
1298  double LastProjectionTransformationMatrixTiledAspectRatio;
1299 
1303  vtkMTimeType LastProjectionTransformationMatrixCameraModified;
1304 
1308  std::array<double, 16> ViewTransformMatrix;
1309 
1313  vtkMTimeType LastViewTransformCameraModified;
1314 
1315  vtkRenderer(const vtkRenderer&) = delete;
1316  void operator=(const vtkRenderer&) = delete;
1317 };
1318 
1320 {
1321  return this->Lights;
1322 }
1323 
1328 {
1329  return this->Cullers;
1330 }
1331 
1332 #endif
a actor that draws 2D data
Definition: vtkActor2D.h:155
an ordered list of actors
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:161
a list of nodes that form an assembly path
a virtual camera for 3D rendering
Definition: vtkCamera.h:161
an ordered list of Cullers
a superclass for prop cullers
Definition: vtkCuller.h:41
Configuration for FXAA implementations.
abstract interface to OpenGL FBOs
a simple class to control print indentation
Definition: vtkIndent.h:119
Store vtkAlgorithm input/output information.
an ordered list of lights
a virtual light for 3D rendering
Definition: vtkLight.h:169
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:151
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:60
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.
void ViewToWorld(double &wx, double &wy, double &wz) override
These methods map from one coordinate system to another.
virtual void SetFXAAOptions(vtkFXAAOptions *)
const std::array< double, 16 > & GetViewTransformMatrix()
Gets the ActiveCamera ViewTransformMatrix, only computing it if necessary.
virtual void ClearLights(void)
Internal method temporarily removes lights before reloading them into graphics pipeline.
Definition: vtkRenderer.h:439
void AddCuller(vtkCuller *)
Add an culler to the list of cullers.
void SetPass(vtkRenderPass *p)
vtkTypeBool PreserveDepthBuffer
Definition: vtkRenderer.h:1063
vtkLight * CreatedLight
Definition: vtkRenderer.h:1020
vtkRenderPass * Pass
Definition: vtkRenderer.h:1263
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:1186
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:1039
double GetTiledAspectRatio()
Compute the aspect ratio of this renderer for the current tile.
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:1327
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 *)
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:724
virtual int UpdateLights(void)
Ask all lights to load themselves into rendering pipeline.
Definition: vtkRenderer.h:1162
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.
vtkWindow * GetVTKWindow() override
Return the vtkWindow that owns this vtkViewport.
vtkActorCollection * GetActors()
Return any actors in this renderer.
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:1268
int VisibleActorCount()
Returns the number of visible actors.
vtkTypeBool BackingStore
Definition: vtkRenderer.h:1034
vtkTexture * EnvironmentTexture
Definition: vtkRenderer.h:1269
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:1206
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:1245
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:1224
vtkTypeBool LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
Definition: vtkRenderer.h:1237
void AllocateTime()
vtkRenderWindow * RenderWindow
Definition: vtkRenderer.h:1029
int VisibleVolumeCount()
Returns the number of visible volumes.
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkTypeBool AutomaticLightCreation
Definition: vtkRenderer.h:1033
int NumberOfPropsRendered
Definition: vtkRenderer.h:1048
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
Definition: vtkRenderer.h:739
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:1031
bool TexturedBackground
Definition: vtkRenderer.h:1258
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.
vtkVolumeCollection * Volumes
Definition: vtkRenderer.h:1026
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:1217
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
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:1090
vtkPropCollection * GL2PSSpecialPropCollection
Temporary collection used by vtkRenderWindow::CaptureGL2PSSpecialProps.
Definition: vtkRenderer.h:1102
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene.
Definition: vtkRenderer.h:1175
double ClippingRangeExpansion
Specify enlargement of bounds when resetting the camera clipping range.
Definition: vtkRenderer.h:1082
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:754
unsigned char * BackingImage
Definition: vtkRenderer.h:1035
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:1256
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:1259
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:1052
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:1023
vtkCamera * GetActiveCamera()
Get the current camera.
void AddActor(vtkProp *p)
Add/Remove different types of props to the renderer.
int PropArrayCount
Definition: vtkRenderer.h:1053
virtual double GetTimeFactor()
Get the ratio between allocated time and actual render time.
double AllocatedRenderTime
Definition: vtkRenderer.h:1030
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:1076
vtkTypeBool Draw
When this flag is off, render commands are ignored.
Definition: vtkRenderer.h:1097
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:1252
virtual void DeviceRender()
Create an image.
Definition: vtkRenderer.h:414
vtkTypeBool TwoSidedLighting
Definition: vtkRenderer.h:1032
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:1260
vtkTypeBool UseDepthPeeling
If this flag is on and the GPU supports it, depth peeling is used for rendering translucent materials...
Definition: vtkRenderer.h:1200
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:1192
void WorldToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkLightCollection * Lights
Definition: vtkRenderer.h:1022
void CreateLight(void)
Create and add a light to renderer.
vtkTexture * GetLeftBackgroundTexture()
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)
vtkTimeStamp RenderTime
Definition: vtkRenderer.h:1037
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:1319
vtkTypeBool LightFollowCamera
Definition: vtkRenderer.h:1041
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:1180
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.
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.
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:1062
void SetGL2PSSpecialPropCollection(vtkPropCollection *)
Set the prop collection object used during vtkRenderWindow::CaptureGL2PSSpecialProps().
vtkActorCollection * Actors
Definition: vtkRenderer.h:1025
void SetDelegate(vtkRendererDelegate *d)
Set/Get a custom Render call.
vtkTypeBool Interactive
Definition: vtkRenderer.h:1057
vtkInformation * Information
Definition: vtkRenderer.h:1266
vtkCamera * ActiveCamera
Definition: vtkRenderer.h:1019
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:178
record modification and/or execution time
Definition: vtkTimeStamp.h:55
abstract specification for Viewports
Definition: vtkViewport.h:56
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:140
window superclass for vtkRenderWindow
Definition: vtkWindow.h:39
int vtkTypeBool
Definition: vtkABI.h:69
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:287
#define VTK_SIZEHINT(...)