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 "vtkVolumeCollection.h" // Needed for access in inline members
#include "vtkActorCollection.h" // Needed for access in inline members

class vtkFXAAOptions;
class vtkRenderWindow;
class vtkVolume;
class vtkCuller;
class vtkActor;
class vtkActor2D;
class vtkCamera;
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 int 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() =0;

  virtual void DeviceRenderOpaqueGeometry();

  virtual void DeviceRenderTranslucentPolygonalGeometry();

  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( 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(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,int);


  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*);

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.
  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;
  int                 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();

  virtual int UpdateTranslucentPolygonalGeometry();

  virtual int UpdateOpaquePolygonalGeometry();

  virtual int UpdateCamera(void);

  virtual int 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;

  int 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;

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