vtkRenderer.h

Go to the documentation of this file.

/*=========================================================================
 
  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
 
#include <array> // To store matrices
 
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 vtkRecti;
class vtkVector3d;
 
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);
 
  virtual void ResetCameraScreenSpace();
 
  virtual void ResetCameraScreenSpace(const double bounds[6]);
 
  using vtkViewport::DisplayToWorld;
 
  vtkVector3d DisplayToWorld(const vtkVector3d& display);
 
  void ZoomToBoxUsingViewAngle(const vtkRecti& box, const double offsetRatio = 1.0);
 
  virtual void ResetCameraScreenSpace(
    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;
 
  const std::array<double, 16>& GetCompositeProjectionTransformationMatrix();
 
  const std::array<double, 16>& GetProjectionTransformationMatrix();
 
  const std::array<double, 16>& GetViewTransformMatrix();
 
  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:
  std::array<double, 16> CompositeProjectionTransformationMatrix;
 
  double LastCompositeProjectionTransformationMatrixTiledAspectRatio;
 
  vtkMTimeType LastCompositeProjectionTransformationMatrixCameraModified;
 
  std::array<double, 16> ProjectionTransformationMatrix;
 
  double LastProjectionTransformationMatrixTiledAspectRatio;
 
  vtkMTimeType LastProjectionTransformationMatrixCameraModified;
 
  std::array<double, 16> ViewTransformMatrix;
 
  vtkMTimeType LastViewTransformCameraModified;
 
  vtkRenderer(const vtkRenderer&) = delete;
  void operator=(const vtkRenderer&) = delete;
};
 
inline vtkLightCollection* vtkRenderer::GetLights()
{
  return this->Lights;
}
 
inline vtkCullerCollection* vtkRenderer::GetCullers()
{
  return this->Cullers;
}
 
#endif