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 vtkRenderWindow;
class vtkVolume;
class vtkCuller;
class vtkActor;
class vtkActor2D;
class vtkCamera;
class vtkLightCollection;
class vtkCullerCollection;
class vtkLight;
class vtkPainter;
class vtkHardwareSelector;
class vtkRendererDelegate;
class vtkTexture;
 
class VTKRENDERINGCORE_EXPORT vtkRenderer : public vtkViewport
{
public:
  vtkTypeMacro(vtkRenderer,vtkViewport);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  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,int);
  vtkSetMacro(TwoSidedLighting,int);
  vtkBooleanMacro(TwoSidedLighting,int);
 
 
  vtkSetMacro(LightFollowCamera,int);
  vtkGetMacro(LightFollowCamera,int);
  vtkBooleanMacro(LightFollowCamera,int);
 
 
  vtkGetMacro(AutomaticLightCreation,int);
  vtkSetMacro(AutomaticLightCreation,int);
  vtkBooleanMacro(AutomaticLightCreation,int);
 
  virtual int UpdateLightsGeometryToFollowCamera(void);
 
  vtkVolumeCollection *GetVolumes();
 
  vtkActorCollection *GetActors();
 
  void SetActiveCamera(vtkCamera *);
 
  vtkCamera *GetActiveCamera();
 
  virtual vtkCamera *MakeCamera();
 
 
  vtkSetMacro(Erase, int);
  vtkGetMacro(Erase, int);
  vtkBooleanMacro(Erase, int);
 
 
  vtkSetMacro(Draw, int);
  vtkGetMacro(Draw, int);
  vtkBooleanMacro(Draw, int);
 
  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 DeviceRenderTranslucentPolygonalGeometry();
 
  virtual void Clear() {}
 
  int VisibleActorCount();
 
  int VisibleVolumeCount();
 
  void ComputeVisiblePropBounds( double bounds[6] );
 
  double *ComputeVisiblePropBounds();
 
  void ResetCameraClippingRange();
 
 
  void ResetCameraClippingRange( double bounds[6] );
  void ResetCameraClippingRange( double xmin, double xmax,
                                 double ymin, double ymax,
                                 double zmin, double zmax);
 
 
  vtkSetClampMacro(NearClippingPlaneTolerance,double,0,0.99);
  vtkGetMacro(NearClippingPlaneTolerance,double);
 
  void ResetCamera();
 
  void ResetCamera(double bounds[6]);
 
 
  void ResetCamera(double xmin, double xmax, double ymin, double ymax,
                   double zmin, double zmax);
 
 
  void SetRenderWindow(vtkRenderWindow *);
  vtkRenderWindow *GetRenderWindow() {return this->RenderWindow;};
  virtual vtkWindow *GetVTKWindow();
 
 
  vtkSetMacro(BackingStore,int);
  vtkGetMacro(BackingStore,int);
  vtkBooleanMacro(BackingStore,int);
 
 
  vtkSetMacro(Interactive,int);
  vtkGetMacro(Interactive,int);
  vtkBooleanMacro(Interactive,int);
 
 
  virtual void SetLayer(int layer);
  vtkGetMacro(Layer, int);
 
 
  vtkGetMacro(PreserveColorBuffer, int);
  vtkSetMacro(PreserveColorBuffer, int);
  vtkBooleanMacro(PreserveColorBuffer, int);
 
 
  vtkSetMacro(PreserveDepthBuffer, int);
  vtkGetMacro(PreserveDepthBuffer, int);
  vtkBooleanMacro(PreserveDepthBuffer, int);
 
  int  Transparent();
 
  void WorldToView();
 
 
  void ViewToWorld();
  virtual void ViewToWorld(double &wx, double &wy, double &wz);
 
  virtual void WorldToView(double &wx, double &wy, double &wz);
 
  double GetZ (int x, int y);
 
  unsigned long GetMTime();
 
 
  vtkGetMacro( LastRenderTimeInSeconds, double );
 
 
  vtkGetMacro( NumberOfPropsRendered, int );
 
 
  vtkAssemblyPath* PickProp(double selectionX, double selectionY)
    {
    return this->PickProp(selectionX, selectionY, selectionX, selectionY);
    }
  vtkAssemblyPath* PickProp(double selectionX1, double selectionY1,
                            double selectionX2, double selectionY2);
 
  virtual void StereoMidpoint() { return; };
 
  double GetTiledAspectRatio();
 
 
  int IsActiveCameraCreated()
    { return (this->ActiveCamera != NULL); }
 
 
 
  vtkSetMacro(UseDepthPeeling,int);
  vtkGetMacro(UseDepthPeeling,int);
  vtkBooleanMacro(UseDepthPeeling,int);
 
 
  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 SetBackgroundTexture(vtkTexture*);
  vtkGetObjectMacro(BackgroundTexture, vtkTexture);
 
 
  vtkSetMacro(TexturedBackground,bool);
  vtkGetMacro(TexturedBackground,bool);
  vtkBooleanMacro(TexturedBackground,bool);
 
  // method to release graphics resources in any derived renderers.
  virtual void ReleaseGraphicsResources(vtkWindow *) { }
 
//BTX
protected:
  vtkRenderer();
  ~vtkRenderer();
 
  // internal method for doing a render for picking purposes
  virtual void PickRender(vtkPropCollection *props);
  virtual void PickGeometry();
 
  // 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;
  int                TwoSidedLighting;
  int                AutomaticLightCreation;
  int                BackingStore;
  unsigned char      *BackingImage;
  int                BackingStoreSize[2];
  vtkTimeStamp       RenderTime;
 
  double              LastRenderTimeInSeconds;
 
  int                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;
 
  // A temporary list used for picking
  vtkAssemblyPath    **PathArray;
  int                PathArrayCount;
 
  // Indicates if the renderer should receive events from an interactor.
  // Typically only used in conjunction with transparent renderers.
  int                Interactive;
 
  // Shows what layer this renderer belongs to.  Only of interested when
  // there are layered renderers.
  int                Layer;
  int                PreserveColorBuffer;
  int                PreserveDepthBuffer;
 
  // Holds the result of ComputeVisiblePropBounds so that it is visible from
  // wrapped languages
  double              ComputedVisiblePropBounds[6];
 
  double              NearClippingPlaneTolerance;
 
  int Erase;
 
  int Draw;
 
  vtkPropCollection *GL2PSSpecialPropCollection;
 
  // Friend class to allow render passes to access functions.
  friend class vtkRenderPass;
 
  virtual int UpdateGeometry();
 
  virtual int UpdateTranslucentPolygonalGeometry();
 
  virtual int UpdateCamera(void);
 
  virtual int UpdateLightGeometry(void);
 
  virtual int UpdateLights(void) {return 0;}
 
  vtkCamera *GetActiveCameraAndResetIfCreated();
 
  int UseDepthPeeling;
 
  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;
 
private:
  vtkRenderer(const vtkRenderer&);  // Not implemented.
  void operator=(const vtkRenderer&);  // Not implemented.
//ETX
};
 
inline vtkLightCollection *vtkRenderer::GetLights() {
  return this->Lights;
}
 
inline vtkCullerCollection *vtkRenderer::GetCullers(){return this->Cullers;}
 
#endif