VTK
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 =========================================================================*/
38 #ifndef vtkRenderer_h
39 #define vtkRenderer_h
40 
41 #include "vtkRenderingCoreModule.h" // For export macro
42 #include "vtkViewport.h"
43 
44 #include "vtkVolumeCollection.h" // Needed for access in inline members
45 #include "vtkActorCollection.h" // Needed for access in inline members
46 
47 class vtkFXAAOptions;
48 class vtkRenderWindow;
49 class vtkVolume;
50 class vtkCuller;
51 class vtkActor;
52 class vtkActor2D;
53 class vtkCamera;
54 class vtkInformation;
55 class vtkLightCollection;
57 class vtkLight;
60 class vtkRenderPass;
61 class vtkTexture;
62 
63 class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
64 {
65 public:
66  vtkTypeMacro(vtkRenderer,vtkViewport);
67  void PrintSelf(ostream& os, vtkIndent indent) override;
68 
74  static vtkRenderer *New();
75 
77 
82  void AddActor(vtkProp *p);
83  void AddVolume(vtkProp *p);
84  void RemoveActor(vtkProp *p);
87 
91  void AddLight(vtkLight *);
92 
97 
102 
106  vtkLightCollection *GetLights();
107 
115 
119  void CreateLight(void);
120 
126  virtual vtkLight *MakeLight();
127 
129 
135  vtkGetMacro(TwoSidedLighting,vtkTypeBool);
136  vtkSetMacro(TwoSidedLighting,vtkTypeBool);
137  vtkBooleanMacro(TwoSidedLighting,vtkTypeBool);
139 
141 
154  vtkSetMacro(LightFollowCamera,vtkTypeBool);
155  vtkGetMacro(LightFollowCamera,vtkTypeBool);
156  vtkBooleanMacro(LightFollowCamera,vtkTypeBool);
158 
160 
168  vtkGetMacro(AutomaticLightCreation,vtkTypeBool);
169  vtkSetMacro(AutomaticLightCreation,vtkTypeBool);
170  vtkBooleanMacro(AutomaticLightCreation,vtkTypeBool);
172 
179 
184 
189 
194 
201 
207  virtual vtkCamera *MakeCamera();
208 
210 
216  vtkSetMacro(Erase, vtkTypeBool);
217  vtkGetMacro(Erase, vtkTypeBool);
218  vtkBooleanMacro(Erase, vtkTypeBool);
220 
222 
227  vtkSetMacro(Draw, vtkTypeBool);
228  vtkGetMacro(Draw, vtkTypeBool);
229  vtkBooleanMacro(Draw, vtkTypeBool);
231 
237 
244 
249 
254 
258  vtkCullerCollection *GetCullers();
259 
261 
264  vtkSetVector3Macro(Ambient,double);
265  vtkGetVectorMacro(Ambient,double,3);
267 
269 
273  vtkSetMacro(AllocatedRenderTime,double);
274  virtual double GetAllocatedRenderTime();
276 
283  virtual double GetTimeFactor();
284 
291  virtual void Render();
292 
296  virtual void DeviceRender() =0;
297 
305 
316 
321  virtual void ClearLights(void) {};
322 
326  virtual void Clear() {}
327 
332 
337 
342  void ComputeVisiblePropBounds( double bounds[6] );
343 
348 
353  virtual void ResetCameraClippingRange();
354 
356 
362  virtual void ResetCameraClippingRange( double bounds[6] );
363  virtual void ResetCameraClippingRange( double xmin, double xmax,
364  double ymin, double ymax,
365  double zmin, double zmax);
367 
369 
374  vtkSetClampMacro(NearClippingPlaneTolerance,double,0,0.99);
375  vtkGetMacro(NearClippingPlaneTolerance,double);
377 
379 
384  vtkSetClampMacro(ClippingRangeExpansion,double,0,0.99);
385  vtkGetMacro(ClippingRangeExpansion,double);
387 
394  virtual void ResetCamera();
395 
405  virtual void ResetCamera(double bounds[6]);
406 
410  virtual void ResetCamera(double xmin, double xmax, double ymin, double ymax,
411  double zmin, double zmax);
412 
414 
419  void SetRenderWindow(vtkRenderWindow *);
420  vtkRenderWindow *GetRenderWindow() {return this->RenderWindow;};
421  vtkWindow *GetVTKWindow() override;
423 
425 
431  vtkSetMacro(BackingStore,vtkTypeBool);
432  vtkGetMacro(BackingStore,vtkTypeBool);
433  vtkBooleanMacro(BackingStore,vtkTypeBool);
435 
437 
442  vtkSetMacro(Interactive,vtkTypeBool);
443  vtkGetMacro(Interactive,vtkTypeBool);
444  vtkBooleanMacro(Interactive,vtkTypeBool);
446 
448 
459  virtual void SetLayer(int layer);
460  vtkGetMacro(Layer, int);
462 
464 
474  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);
475  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);
476  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);
478 
480 
484  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);
485  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);
486  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);
488 
493  int Transparent();
494 
498  void WorldToView() override;
499 
501 
504  void ViewToWorld() override;
505  void ViewToWorld(double &wx, double &wy, double &wz) override;
507 
511  void WorldToView(double &wx, double &wy, double &wz) override;
512 
514 
517  void WorldToPose(double &wx, double &wy, double &wz) override;
518  void PoseToWorld(double &wx, double &wy, double &wz) override;
519  void ViewToPose(double &wx, double &wy, double &wz) override;
520  void PoseToView(double &wx, double &wy, double &wz) override;
522 
527  double GetZ (int x, int y);
528 
532  vtkMTimeType GetMTime() override;
533 
535 
538  vtkGetMacro( LastRenderTimeInSeconds, double );
540 
542 
548  vtkGetMacro( NumberOfPropsRendered, int );
550 
552 
559  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override
560  {
561  return this->PickProp(selectionX, selectionY, selectionX, selectionY);
562  }
563  vtkAssemblyPath* PickProp(double selectionX1, double selectionY1,
564  double selectionX2, double selectionY2) override;
566 
572  virtual void StereoMidpoint() { return; };
573 
581 
588  { return (this->ActiveCamera != nullptr); }
589 
590 
592 
602  vtkSetMacro(UseDepthPeeling,vtkTypeBool);
603  vtkGetMacro(UseDepthPeeling,vtkTypeBool);
604  vtkBooleanMacro(UseDepthPeeling,vtkTypeBool);
606 
612  vtkSetMacro(UseDepthPeelingForVolumes, bool)
613  vtkGetMacro(UseDepthPeelingForVolumes, bool)
614  vtkBooleanMacro(UseDepthPeelingForVolumes, bool)
615 
617 
626  vtkSetClampMacro(OcclusionRatio,double,0.0,0.5);
627  vtkGetMacro(OcclusionRatio,double);
629 
631 
636  vtkSetMacro(MaximumNumberOfPeels,int);
637  vtkGetMacro(MaximumNumberOfPeels,int);
639 
641 
646  vtkGetMacro(LastRenderingUsedDepthPeeling,int);
648 
650 
656  void SetDelegate(vtkRendererDelegate *d);
657  vtkGetObjectMacro(Delegate,vtkRendererDelegate);
659 
661 
666  vtkGetObjectMacro(Selector, vtkHardwareSelector);
668 
670 
675  virtual void SetLeftBackgroundTexture(vtkTexture*);
676  vtkTexture* GetLeftBackgroundTexture();
677  virtual void SetBackgroundTexture(vtkTexture*);
678  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
680 
682 
686  virtual void SetRightBackgroundTexture(vtkTexture*);
687  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);
689 
691 
695  vtkSetMacro(TexturedBackground,bool);
696  vtkGetMacro(TexturedBackground,bool);
697  vtkBooleanMacro(TexturedBackground,bool);
699 
700  // method to release graphics resources in any derived renderers.
701  virtual void ReleaseGraphicsResources(vtkWindow *);
702 
704 
707  vtkSetMacro(UseFXAA, bool)
708  vtkGetMacro(UseFXAA, bool)
709  vtkBooleanMacro(UseFXAA, bool)
711 
713 
716  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions)
717  virtual void SetFXAAOptions(vtkFXAAOptions*);
719 
721 
725  vtkSetMacro(UseShadows,vtkTypeBool);
726  vtkGetMacro(UseShadows,vtkTypeBool);
727  vtkBooleanMacro(UseShadows,vtkTypeBool);
729 
731 
735  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool)
736  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool)
737  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool)
739 
740  // Set/Get a custom render pass.
741  // Initial value is NULL.
742  void SetPass(vtkRenderPass *p);
743  vtkGetObjectMacro(Pass, vtkRenderPass);
744 
746 
749  vtkGetObjectMacro(Information, vtkInformation);
750  virtual void SetInformation(vtkInformation*);
752 
753 protected:
755  ~vtkRenderer() override;
756 
757  // internal method to expand bounding box to consider model transform
758  // matrix or model view transform matrix based on whether or not deering
759  // frustum is used.
760  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4 *matrix);
761 
762  vtkCamera *ActiveCamera;
763  vtkLight *CreatedLight;
764 
767 
770 
771  double Ambient[3];
772  vtkRenderWindow *RenderWindow;
773  double AllocatedRenderTime;
774  double TimeFactor;
775  vtkTypeBool TwoSidedLighting;
776  int AutomaticLightCreation;
777  vtkTypeBool BackingStore;
778  unsigned char *BackingImage;
779  int BackingStoreSize[2];
780  vtkTimeStamp RenderTime;
781 
782  double LastRenderTimeInSeconds;
783 
784  vtkTypeBool LightFollowCamera;
785 
786  // Allocate the time for each prop
787  void AllocateTime();
788 
789  // Internal variables indicating the number of props
790  // that have been or will be rendered in each category.
791  int NumberOfPropsRendered;
792 
793  // A temporary list of props used for culling, and traversal
794  // of all props when rendering
795  vtkProp **PropArray;
796  int PropArrayCount;
797 
798  // Indicates if the renderer should receive events from an interactor.
799  // Typically only used in conjunction with transparent renderers.
800  vtkTypeBool Interactive;
801 
802  // Shows what layer this renderer belongs to. Only of interested when
803  // there are layered renderers.
804  int Layer;
805  vtkTypeBool PreserveColorBuffer;
806  vtkTypeBool PreserveDepthBuffer;
807 
808  // Holds the result of ComputeVisiblePropBounds so that it is visible from
809  // wrapped languages
810  double ComputedVisiblePropBounds[6];
811 
819  double NearClippingPlaneTolerance;
820 
825  double ClippingRangeExpansion;
826 
833  vtkTypeBool Erase;
834 
841 
845  vtkPropCollection *GL2PSSpecialPropCollection;
846 
852  virtual int UpdateGeometry();
853 
861  virtual int UpdateTranslucentPolygonalGeometry();
862 
868  virtual int UpdateOpaquePolygonalGeometry();
869 
874  virtual int UpdateCamera(void);
875 
881  virtual int UpdateLightGeometry(void);
882 
887  virtual int UpdateLights(void) {return 0;}
888 
895 
900  bool UseFXAA;
901 
906 
912 
918 
926 
932 
943 
950 
957 
958  // HARDWARE SELECTION ----------------------------------------
959  friend class vtkHardwareSelector;
960 
965  { this->Selector = selector; this->Modified(); }
966 
967  // End Ivars for visible cell selecting.
969 
970  //---------------------------------------------------------------
971  friend class vtkRendererDelegate;
973 
977 
978  friend class vtkRenderPass;
980 
981  // Arbitrary extra information associated with this renderer
983 
984 private:
985  vtkRenderer(const vtkRenderer&) = delete;
986  void operator=(const vtkRenderer&) = delete;
987 
988 };
989 
991  return this->Lights;
992 }
993 
998 
999 #endif
vtkVolumeCollection
an ordered list of volumes
Definition: vtkVolumeCollection.h:36
vtkRenderer::PickProp
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:559
vtkRenderer::Render
virtual void Render()
CALLED BY vtkRenderWindow ONLY.
vtkRenderer::CaptureGL2PSSpecialProp
int CaptureGL2PSSpecialProp(vtkProp *)
This function is called to capture an instance of vtkProp that requires special handling during vtkRe...
vtkRenderer::SetLightCollection
void SetLightCollection(vtkLightCollection *lights)
Set the collection of lights.
vtkLight
a virtual light for 3D rendering
Definition: vtkLight.h:63
vtkRenderer::AddActor
void AddActor(vtkProp *p)
Add/Remove different types of props to the renderer.
vtkRenderer::UseShadows
vtkTypeBool UseShadows
If this flag is on and the rendering engine supports it render shadows Initial value is off.
Definition: vtkRenderer.h:911
vtkVolume
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:51
vtkRenderer::Pass
vtkRenderPass * Pass
Definition: vtkRenderer.h:979
vtkRenderer::IsActiveCameraCreated
vtkTypeBool IsActiveCameraCreated()
This method returns 1 if the ActiveCamera has already been set or automatically created by the render...
Definition: vtkRenderer.h:587
vtkRenderer::Clear
virtual void Clear()
Clear the image to the background color.
Definition: vtkRenderer.h:326
vtkRenderer::WorldToView
void WorldToView(double &wx, double &wy, double &wz) override
Convert world point coordinates to view coordinates.
vtkRenderer::RemoveVolume
void RemoveVolume(vtkProp *p)
vtkRenderer::AddVolume
void AddVolume(vtkProp *p)
vtkRenderer::ComputeVisiblePropBounds
void ComputeVisiblePropBounds(double bounds[6])
Compute the bounding box of all the visible props Used in ResetCamera() and ResetCameraClippingRange(...
vtkRenderer::MakeCamera
virtual vtkCamera * MakeCamera()
Create a new Camera sutible for use with this type of Renderer.
vtkRenderer::GetAllocatedRenderTime
virtual double GetAllocatedRenderTime()
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:36
vtkRenderer::GetMTime
vtkMTimeType GetMTime() override
Return the MTime of the renderer also considering its ivars.
vtkLightCollection
an ordered list of lights
Definition: vtkLightCollection.h:39
vtkRenderer::ClearLights
virtual void ClearLights(void)
Internal method temporarily removes lights before reloading them into graphics pipeline.
Definition: vtkRenderer.h:321
vtkObject::Modified
virtual void Modified()
Update the modification time for this object.
vtkFXAAOptions
Configuration for FXAA implementations.
Definition: vtkFXAAOptions.h:31
vtkRenderer::OcclusionRatio
double OcclusionRatio
In case of use of depth peeling technique for rendering translucent material, define the threshold un...
Definition: vtkRenderer.h:942
vtkRenderer::ViewToWorld
void ViewToWorld(double &wx, double &wy, double &wz) override
vtkRenderer::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkRenderer::VisibleVolumeCount
int VisibleVolumeCount()
Returns the number of visible volumes.
vtkRenderer::UseDepthPeelingForVolumes
bool UseDepthPeelingForVolumes
This flag is on and the GPU supports it, depth-peel volumes along with the translucent geometry.
Definition: vtkRenderer.h:931
vtkRenderer::GetActors
vtkActorCollection * GetActors()
Return any actors in this renderer.
vtkViewport::PickProp
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.
vtkViewport.h
vtkAssemblyPath
a list of nodes that form an assembly path
Definition: vtkAssemblyPath.h:45
vtkRenderer::Transparent
int Transparent()
Returns a boolean indicating if this renderer is transparent.
vtkRenderer::StereoMidpoint
virtual void StereoMidpoint()
Do anything necessary between rendering the left and right viewpoints in a stereo render.
Definition: vtkRenderer.h:572
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:38
vtkRenderer::UseFXAA
bool UseFXAA
If this flag is on and the rendering engine supports it, FXAA will be used to antialias the scene.
Definition: vtkRenderer.h:900
vtkRenderer::UseDepthPeeling
vtkTypeBool UseDepthPeeling
If this flag is on and the GPU supports it, depth peeling is used for rendering translucent materials...
Definition: vtkRenderer.h:925
vtkRenderer::SetSelector
void SetSelector(vtkHardwareSelector *selector)
Called by vtkHardwareSelector when it begins rendering for selection.
Definition: vtkRenderer.h:964
vtkRenderer::GetActiveCamera
vtkCamera * GetActiveCamera()
Get the current camera.
vtkRenderer::SetGL2PSSpecialPropCollection
void SetGL2PSSpecialPropCollection(vtkPropCollection *)
Set the prop collection object used during vtkRenderWindow::CaptureGL2PSSpecialProps().
vtkRendererDelegate
Render the props of a vtkRenderer.
Definition: vtkRendererDelegate.h:38
vtkTexture
handles properties associated with a texture map
Definition: vtkTexture.h:72
vtkRenderer::GetVolumes
vtkVolumeCollection * GetVolumes()
Return the collection of volumes.
vtkRenderer::DeviceRenderOpaqueGeometry
virtual void DeviceRenderOpaqueGeometry()
Render opaque polygonal geometry.
VTK_SIZEHINT
#define VTK_SIZEHINT(...)
Definition: vtkWrappingHints.h:42
vtkActorCollection.h
vtkRenderer::DeviceRenderTranslucentPolygonalGeometry
virtual void DeviceRenderTranslucentPolygonalGeometry()
Render translucent polygonal geometry.
vtkVolumeCollection.h
vtkRenderer::PoseToWorld
void PoseToWorld(double &wx, double &wy, double &wz) override
vtkRenderer::Cullers
vtkCullerCollection * Cullers
Definition: vtkRenderer.h:766
vtkHardwareSelector
Definition: vtkHardwareSelector.h:124
vtkRenderer::GetLights
vtkLightCollection * GetLights()
Return the collection of lights.
Definition: vtkRenderer.h:990
vtkRenderer::Delegate
vtkRendererDelegate * Delegate
Definition: vtkRenderer.h:972
vtkActor
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:52
vtkCuller
a superclass for prop cullers
Definition: vtkCuller.h:41
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:40
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:42
vtkRenderer::CreateLight
void CreateLight(void)
Create and add a light to renderer.
vtkRenderer::GetActiveCameraAndResetIfCreated
vtkCamera * GetActiveCameraAndResetIfCreated()
Get the current camera and reset it only if it gets created automatically (see GetActiveCamera).
vtkCamera
a virtual camera for 3D rendering
Definition: vtkCamera.h:51
vtkRenderer::PickProp
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.
vtkRenderer::UseHiddenLineRemoval
vtkTypeBool UseHiddenLineRemoval
When this flag is on and the rendering engine supports it, wireframe polydata will be rendered using ...
Definition: vtkRenderer.h:917
vtkCullerCollection
an ordered list of Cullers
Definition: vtkCullerCollection.h:35
vtkRenderer::GetZ
double GetZ(int x, int y)
Given a pixel location, return the Z value.
vtkRenderer::DeviceRender
virtual void DeviceRender()=0
Create an image.
vtkRenderer::FXAAOptions
vtkFXAAOptions * FXAAOptions
Holds the FXAA configuration.
Definition: vtkRenderer.h:905
vtkViewport
abstract specification for Viewports
Definition: vtkViewport.h:48
vtkRenderer::WorldToView
void WorldToView() override
Convert world point coordinates to view coordinates.
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:87
vtkRenderer::ComputeVisiblePropBounds
double * ComputeVisiblePropBounds()
Wrapper-friendly version of ComputeVisiblePropBounds.
vtkProp
abstract superclass for all actors, volumes and annotations
Definition: vtkProp.h:53
vtkRenderer::GetVTKWindow
vtkWindow * GetVTKWindow() override
Return the vtkWindow that owns this vtkViewport.
vtkRenderer::RemoveLight
void RemoveLight(vtkLight *)
Remove a light from the list of lights.
vtkRenderer::LastRenderingUsedDepthPeeling
int LastRenderingUsedDepthPeeling
Tells if the last call to DeviceRenderTranslucentPolygonalGeometry() actually used depth peeling.
Definition: vtkRenderer.h:956
vtkActor2D
a actor that draws 2D data
Definition: vtkActor2D.h:46
vtkRenderer::Selector
vtkHardwareSelector * Selector
Definition: vtkRenderer.h:968
vtkRenderer::Lights
vtkLightCollection * Lights
Definition: vtkRenderer.h:765
vtkRenderer::PoseToView
void PoseToView(double &wx, double &wy, double &wz) override
vtkRenderer::RemoveCuller
void RemoveCuller(vtkCuller *)
Remove an actor from the list of cullers.
vtkRenderer::BackgroundTexture
vtkTexture * BackgroundTexture
Definition: vtkRenderer.h:975
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:64
vtkRenderer::RemoveAllLights
void RemoveAllLights()
Remove all lights from the list of lights.
vtkRenderer::TexturedBackground
bool TexturedBackground
Definition: vtkRenderer.h:974
vtkRenderer::AddLight
void AddLight(vtkLight *)
Add a light to the list of lights.
vtkRenderer::ViewToWorld
void ViewToWorld() override
Convert view point coordinates to world coordinates.
vtkActorCollection
an ordered list of actors
Definition: vtkActorCollection.h:40
vtkRenderer::RightBackgroundTexture
vtkTexture * RightBackgroundTexture
Definition: vtkRenderer.h:976
vtkRenderer::SetActiveCamera
void SetActiveCamera(vtkCamera *)
Specify the camera to use for this renderer.
vtkRenderer::MaximumNumberOfPeels
int MaximumNumberOfPeels
In case of depth peeling, define the maximum number of peeling layers.
Definition: vtkRenderer.h:949
vtkRenderer::VisibleActorCount
int VisibleActorCount()
Returns the number of visible actors.
vtkRenderer::GetTimeFactor
virtual double GetTimeFactor()
Get the ratio between allocated time and actual render time.
vtkRenderWindow
create a window for renderers to draw into
Definition: vtkRenderWindow.h:88
vtkRenderer::MakeLight
virtual vtkLight * MakeLight()
Create a new Light sutible for use with this type of Renderer.
vtkRenderer::RemoveActor
void RemoveActor(vtkProp *p)
vtkRenderer::WorldToPose
void WorldToPose(double &wx, double &wy, double &wz) override
Convert to from pose coordinates.
vtkRenderer::New
static vtkRenderer * New()
Create a vtkRenderer with a black background, a white ambient light, two-sided lighting turned on,...
vtkRenderer::AddCuller
void AddCuller(vtkCuller *)
Add an culler to the list of cullers.
vtkPropCollection
an ordered list of Props
Definition: vtkPropCollection.h:42
vtkRenderer::GetTiledAspectRatio
double GetTiledAspectRatio()
Compute the aspect ratio of this renderer for the current tile.
vtkRenderer::GetCullers
vtkCullerCollection * GetCullers()
Return the collection of cullers.
Definition: vtkRenderer.h:997
vtkRenderer::ViewToPose
void ViewToPose(double &wx, double &wy, double &wz) override
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkRenderer::UpdateLightsGeometryToFollowCamera
virtual int UpdateLightsGeometryToFollowCamera(void)
Ask the lights in the scene that are not in world space (for instance, Headlights or CameraLights tha...
vtkRenderer::Information
vtkInformation * Information
Definition: vtkRenderer.h:982
vtkRenderer::SetLayer
virtual void SetLayer(int layer)
Set/Get the layer that this renderer belongs to.
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:302
vtkRenderPass
Perform part of the rendering of a vtkRenderer.
Definition: vtkRenderPass.h:59