nightly/html/vtkRenderer_8h_source.html

/*=========================================================================


  Program:   Visualization Toolkit

  Module:    vtkRenderer.h


  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen

  All rights reserved.

  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.


     This software is distributed WITHOUT ANY WARRANTY; without even

     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

     PURPOSE.  See the above copyright notice for more information.


=========================================================================*/

#ifndef vtkRenderer_h

#define vtkRenderer_h


#include "vtkRenderingCoreModule.h" // For export macro

#include "vtkViewport.h"


#include "vtkActorCollection.h"  // Needed for access in inline members

#include "vtkVolumeCollection.h" // Needed for access in inline members


class vtkFXAAOptions;

class vtkRenderWindow;

class vtkVolume;

class vtkCuller;

class vtkActor;

class vtkActor2D;

class vtkCamera;

class vtkFrameBufferObjectBase;

class vtkInformation;

class vtkLightCollection;

class vtkCullerCollection;

class vtkLight;

class vtkHardwareSelector;

class vtkRendererDelegate;

class vtkRenderPass;

class vtkTexture;


class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport

{

public:

  vtkTypeMacro(vtkRenderer, vtkViewport);

  void PrintSelf(ostream& os, vtkIndent indent) override;


  static vtkRenderer* New();


  void AddActor(vtkProp* p);

  void AddVolume(vtkProp* p);

  void RemoveActor(vtkProp* p);

  void RemoveVolume(vtkProp* p);


  void AddLight(vtkLight*);


  void RemoveLight(vtkLight*);


  void RemoveAllLights();


  vtkLightCollection* GetLights();


  void SetLightCollection(vtkLightCollection* lights);


  void CreateLight(void);


  virtual vtkLight* MakeLight();


  vtkGetMacro(TwoSidedLighting, vtkTypeBool);

  vtkSetMacro(TwoSidedLighting, vtkTypeBool);

  vtkBooleanMacro(TwoSidedLighting, vtkTypeBool);


  vtkSetMacro(LightFollowCamera, vtkTypeBool);

  vtkGetMacro(LightFollowCamera, vtkTypeBool);

  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);


  vtkGetMacro(AutomaticLightCreation, vtkTypeBool);

  vtkSetMacro(AutomaticLightCreation, vtkTypeBool);

  vtkBooleanMacro(AutomaticLightCreation, vtkTypeBool);


  virtual vtkTypeBool UpdateLightsGeometryToFollowCamera(void);


  vtkVolumeCollection* GetVolumes();


  vtkActorCollection* GetActors();


  void SetActiveCamera(vtkCamera*);


  vtkCamera* GetActiveCamera();


  virtual vtkCamera* MakeCamera();


  vtkSetMacro(Erase, vtkTypeBool);

  vtkGetMacro(Erase, vtkTypeBool);

  vtkBooleanMacro(Erase, vtkTypeBool);


  vtkSetMacro(Draw, vtkTypeBool);

  vtkGetMacro(Draw, vtkTypeBool);

  vtkBooleanMacro(Draw, vtkTypeBool);


  int CaptureGL2PSSpecialProp(vtkProp*);


  void SetGL2PSSpecialPropCollection(vtkPropCollection*);


  void AddCuller(vtkCuller*);


  void RemoveCuller(vtkCuller*);


  vtkCullerCollection* GetCullers();


  vtkSetVector3Macro(Ambient, double);

  vtkGetVectorMacro(Ambient, double, 3);


  vtkSetMacro(AllocatedRenderTime, double);

  virtual double GetAllocatedRenderTime();


  virtual double GetTimeFactor();


  virtual void Render();


  virtual void DeviceRender(){};


  virtual void DeviceRenderOpaqueGeometry(vtkFrameBufferObjectBase* fbo = nullptr);


  virtual void DeviceRenderTranslucentPolygonalGeometry(vtkFrameBufferObjectBase* fbo = nullptr);


  virtual void ClearLights(void) {}


  virtual void Clear() {}


  int VisibleActorCount();


  int VisibleVolumeCount();


  void ComputeVisiblePropBounds(double bounds[6]);


  double* ComputeVisiblePropBounds() VTK_SIZEHINT(6);


  virtual void ResetCameraClippingRange();


  virtual void ResetCameraClippingRange(const double bounds[6]);

  virtual void ResetCameraClippingRange(

    double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);


  vtkSetClampMacro(NearClippingPlaneTolerance, double, 0, 0.99);

  vtkGetMacro(NearClippingPlaneTolerance, double);


  vtkSetClampMacro(ClippingRangeExpansion, double, 0, 0.99);

  vtkGetMacro(ClippingRangeExpansion, double);


  virtual void ResetCamera();


  virtual void ResetCamera(const double bounds[6]);


  virtual void ResetCamera(

    double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);


  void SetRenderWindow(vtkRenderWindow*);

  vtkRenderWindow* GetRenderWindow() { return this->RenderWindow; }

  vtkWindow* GetVTKWindow() override;


  vtkSetMacro(BackingStore, vtkTypeBool);

  vtkGetMacro(BackingStore, vtkTypeBool);

  vtkBooleanMacro(BackingStore, vtkTypeBool);


  vtkSetMacro(Interactive, vtkTypeBool);

  vtkGetMacro(Interactive, vtkTypeBool);

  vtkBooleanMacro(Interactive, vtkTypeBool);


  virtual void SetLayer(int layer);

  vtkGetMacro(Layer, int);


  vtkGetMacro(PreserveColorBuffer, vtkTypeBool);

  vtkSetMacro(PreserveColorBuffer, vtkTypeBool);

  vtkBooleanMacro(PreserveColorBuffer, vtkTypeBool);


  vtkSetMacro(PreserveDepthBuffer, vtkTypeBool);

  vtkGetMacro(PreserveDepthBuffer, vtkTypeBool);

  vtkBooleanMacro(PreserveDepthBuffer, vtkTypeBool);


  int Transparent();


  void WorldToView() override;


  void ViewToWorld() override;

  void ViewToWorld(double& wx, double& wy, double& wz) override;


  void WorldToView(double& wx, double& wy, double& wz) override;


  void WorldToPose(double& wx, double& wy, double& wz) override;

  void PoseToWorld(double& wx, double& wy, double& wz) override;

  void ViewToPose(double& wx, double& wy, double& wz) override;

  void PoseToView(double& wx, double& wy, double& wz) override;


  double GetZ(int x, int y);


  vtkMTimeType GetMTime() override;


  vtkGetMacro(LastRenderTimeInSeconds, double);


  vtkGetMacro(NumberOfPropsRendered, int);


  vtkAssemblyPath* PickProp(double selectionX, double selectionY) override

  {

    return this->PickProp(selectionX, selectionY, selectionX, selectionY);

  }

  vtkAssemblyPath* PickProp(

    double selectionX1, double selectionY1, double selectionX2, double selectionY2) override;


  virtual void StereoMidpoint() { return; }


  double GetTiledAspectRatio();


  vtkTypeBool IsActiveCameraCreated() { return (this->ActiveCamera != nullptr); }


  vtkSetMacro(UseDepthPeeling, vtkTypeBool);

  vtkGetMacro(UseDepthPeeling, vtkTypeBool);

  vtkBooleanMacro(UseDepthPeeling, vtkTypeBool);


  vtkSetMacro(UseDepthPeelingForVolumes, bool);

  vtkGetMacro(UseDepthPeelingForVolumes, bool);

  vtkBooleanMacro(UseDepthPeelingForVolumes, bool);


  vtkSetClampMacro(OcclusionRatio, double, 0.0, 0.5);

  vtkGetMacro(OcclusionRatio, double);


  vtkSetMacro(MaximumNumberOfPeels, int);

  vtkGetMacro(MaximumNumberOfPeels, int);


  vtkGetMacro(LastRenderingUsedDepthPeeling, vtkTypeBool);


  vtkSetMacro(UseSSAO, bool);

  vtkGetMacro(UseSSAO, bool);

  vtkBooleanMacro(UseSSAO, bool);


  vtkSetMacro(SSAORadius, double);

  vtkGetMacro(SSAORadius, double);


  vtkSetMacro(SSAOBias, double);

  vtkGetMacro(SSAOBias, double);


  vtkSetMacro(SSAOKernelSize, unsigned int);

  vtkGetMacro(SSAOKernelSize, unsigned int);


  vtkSetMacro(SSAOBlur, bool);

  vtkGetMacro(SSAOBlur, bool);

  vtkBooleanMacro(SSAOBlur, bool);


  void SetDelegate(vtkRendererDelegate* d);

  vtkGetObjectMacro(Delegate, vtkRendererDelegate);


  vtkGetObjectMacro(Selector, vtkHardwareSelector);


  virtual void SetLeftBackgroundTexture(vtkTexture*);

  vtkTexture* GetLeftBackgroundTexture();

  virtual void SetBackgroundTexture(vtkTexture*);

  vtkGetObjectMacro(BackgroundTexture, vtkTexture);


  virtual void SetRightBackgroundTexture(vtkTexture*);

  vtkGetObjectMacro(RightBackgroundTexture, vtkTexture);


  vtkSetMacro(TexturedBackground, bool);

  vtkGetMacro(TexturedBackground, bool);

  vtkBooleanMacro(TexturedBackground, bool);


  // method to release graphics resources in any derived renderers.

  virtual void ReleaseGraphicsResources(vtkWindow*);


  vtkSetMacro(UseFXAA, bool);

  vtkGetMacro(UseFXAA, bool);

  vtkBooleanMacro(UseFXAA, bool);


  vtkGetObjectMacro(FXAAOptions, vtkFXAAOptions);

  virtual void SetFXAAOptions(vtkFXAAOptions*);


  vtkSetMacro(UseShadows, vtkTypeBool);

  vtkGetMacro(UseShadows, vtkTypeBool);

  vtkBooleanMacro(UseShadows, vtkTypeBool);


  vtkSetMacro(UseHiddenLineRemoval, vtkTypeBool);

  vtkGetMacro(UseHiddenLineRemoval, vtkTypeBool);

  vtkBooleanMacro(UseHiddenLineRemoval, vtkTypeBool);


  // Set/Get a custom render pass.

  // Initial value is NULL.

  void SetPass(vtkRenderPass* p);

  vtkGetObjectMacro(Pass, vtkRenderPass);


  vtkGetObjectMacro(Information, vtkInformation);

  virtual void SetInformation(vtkInformation*);


  vtkSetMacro(UseImageBasedLighting, bool);

  vtkGetMacro(UseImageBasedLighting, bool);

  vtkBooleanMacro(UseImageBasedLighting, bool);


  vtkGetObjectMacro(EnvironmentTexture, vtkTexture);

  virtual void SetEnvironmentTexture(vtkTexture* texture, bool isSRGB = false);


  vtkGetVector3Macro(EnvironmentUp, double);

  vtkSetVector3Macro(EnvironmentUp, double);


  vtkGetVector3Macro(EnvironmentRight, double);

  vtkSetVector3Macro(EnvironmentRight, double);


protected:

  vtkRenderer();

  ~vtkRenderer() override;


  // internal method to expand bounding box to consider model transform

  // matrix or model view transform matrix based on whether or not deering

  // frustum is used. 'bounds' buffer is mutated to the expanded box.

  virtual void ExpandBounds(double bounds[6], vtkMatrix4x4* matrix);


  vtkCamera* ActiveCamera;

  vtkLight* CreatedLight;


  vtkLightCollection* Lights;

  vtkCullerCollection* Cullers;


  vtkActorCollection* Actors;

  vtkVolumeCollection* Volumes;


  double Ambient[3];

  vtkRenderWindow* RenderWindow;

  double AllocatedRenderTime;

  double TimeFactor;

  vtkTypeBool TwoSidedLighting;

  vtkTypeBool AutomaticLightCreation;

  vtkTypeBool BackingStore;

  unsigned char* BackingImage;

  int BackingStoreSize[2];

  vtkTimeStamp RenderTime;


  double LastRenderTimeInSeconds;


  vtkTypeBool LightFollowCamera;


  // Allocate the time for each prop

  void AllocateTime();


  // Internal variables indicating the number of props

  // that have been or will be rendered in each category.

  int NumberOfPropsRendered;


  // A temporary list of props used for culling, and traversal

  // of all props when rendering

  vtkProp** PropArray;

  int PropArrayCount;


  // Indicates if the renderer should receive events from an interactor.

  // Typically only used in conjunction with transparent renderers.

  vtkTypeBool Interactive;


  // Shows what layer this renderer belongs to.  Only of interested when

  // there are layered renderers.

  int Layer;

  vtkTypeBool PreserveColorBuffer;

  vtkTypeBool PreserveDepthBuffer;


  // Holds the result of ComputeVisiblePropBounds so that it is visible from

  // wrapped languages

  double ComputedVisiblePropBounds[6];


  double NearClippingPlaneTolerance;


  double ClippingRangeExpansion;


  vtkTypeBool Erase;


  vtkTypeBool Draw;


  vtkPropCollection* GL2PSSpecialPropCollection;


  virtual int UpdateGeometry(vtkFrameBufferObjectBase* fbo = nullptr);


  virtual int UpdateTranslucentPolygonalGeometry();


  virtual int UpdateOpaquePolygonalGeometry();


  virtual int UpdateCamera(void);


  virtual vtkTypeBool UpdateLightGeometry(void);


  virtual int UpdateLights(void) { return 0; }


  vtkCamera* GetActiveCameraAndResetIfCreated();


  bool UseFXAA;


  vtkFXAAOptions* FXAAOptions;


  vtkTypeBool UseShadows;


  vtkTypeBool UseHiddenLineRemoval;


  vtkTypeBool UseDepthPeeling;


  bool UseDepthPeelingForVolumes;


  double OcclusionRatio;


  int MaximumNumberOfPeels;


  bool UseSSAO = false;

  double SSAORadius = 0.5;

  double SSAOBias = 0.01;

  unsigned int SSAOKernelSize = 32;

  bool SSAOBlur = false;


  vtkTypeBool LastRenderingUsedDepthPeeling;


  // HARDWARE SELECTION ----------------------------------------

  friend class vtkHardwareSelector;


  void SetSelector(vtkHardwareSelector* selector)

  {

    this->Selector = selector;

    this->Modified();

  }


  // End Ivars for visible cell selecting.

  vtkHardwareSelector* Selector;


  //---------------------------------------------------------------

  friend class vtkRendererDelegate;

  vtkRendererDelegate* Delegate;


  bool TexturedBackground;

  vtkTexture* BackgroundTexture;

  vtkTexture* RightBackgroundTexture;


  friend class vtkRenderPass;

  vtkRenderPass* Pass;


  // Arbitrary extra information associated with this renderer

  vtkInformation* Information;


  bool UseImageBasedLighting;

  vtkTexture* EnvironmentTexture;


  double EnvironmentUp[3];

  double EnvironmentRight[3];


private:

  vtkRenderer(const vtkRenderer&) = delete;

  void operator=(const vtkRenderer&) = delete;

};


inline vtkLightCollection* vtkRenderer::GetLights()

{

  return this->Lights;

}


inline vtkCullerCollection* vtkRenderer::GetCullers()

{

  return this->Cullers;

}


#endif