vtkRenderer.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkRenderer.h,v $

  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 "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 VTK_RENDERING_EXPORT vtkRenderer : public vtkViewport
{
public:
  vtkTypeRevisionMacro(vtkRenderer,vtkViewport);
  void PrintSelf(ostream& os, vtkIndent indent);

  static vtkRenderer *New();


  void AddActor(vtkProp *p) {this->AddProp(p);};
  void AddVolume(vtkProp *p) {this->AddProp(p);};
  void RemoveActor(vtkProp *p) {this->Actors->RemoveItem(p);this->RemoveProp(p);};
  void RemoveVolume(vtkProp *p) {this->Volumes->RemoveItem(p);this->RemoveProp(p);};

  void AddLight(vtkLight *);

  void RemoveLight(vtkLight *);

  vtkLightCollection *GetLights();
  
  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);

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


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

  virtual void StereoMidpoint() { return; };

  double GetTiledAspectRatio();
  
protected:
  vtkRenderer();
  ~vtkRenderer();

  // internal method for doing a render for picking purposes
  virtual void PickRender(vtkPropCollection *props);
  virtual void PickGeometry();
  
  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;

  // Holds the result of ComputeVisiblePropBounds so that it is visible from
  // wrapped languages
  double              ComputedVisiblePropBounds[6];

  double              NearClippingPlaneTolerance;

  int Erase;

  virtual int UpdateGeometry(void);

  virtual int UpdateCamera(void);

  virtual int UpdateLightGeometry(void);

  virtual int UpdateLights(void) {return 0;};
  
private:
  vtkRenderer(const vtkRenderer&);  // Not implemented.
  void operator=(const vtkRenderer&);  // Not implemented.
};

inline vtkLightCollection *vtkRenderer::GetLights() {
  return this->Lights;
}

inline vtkCullerCollection *vtkRenderer::GetCullers(){return this->Cullers;}


#endif

Generated on Tue Oct 5 08:39:17 2004 for VTK by Doxygen 1.3.8-20040913