dox/Rendering/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 "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 vtkIdentColoredPainter;
class vtkHardwareSelector;
class vtkRendererDelegate;
class vtkRenderPass;
class vtkTexture;

#if !defined(VTK_LEGACY_REMOVE)
class vtkVisibleCellSelector;
#endif


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

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


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


  void SetPass(vtkRenderPass *p);
  vtkGetObjectMacro(Pass,vtkRenderPass);


  vtkGetObjectMacro(Selector, vtkHardwareSelector);


  void SetBackgroundTexture(vtkTexture*);
  vtkGetObjectMacro(BackgroundTexture, vtkTexture);


  vtkSetMacro(TexturedBackground,bool);
  vtkGetMacro(TexturedBackground,bool);
  vtkBooleanMacro(TexturedBackground,bool);

//BTX
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;
  int                PreserveDepthBuffer;

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

  double              NearClippingPlaneTolerance;

  int Erase;

  int Draw;

  virtual int UpdateGeometry(void);

  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;

#if !defined(VTK_LEGACY_REMOVE)
  // VISIBLE CELL SELECTION ----------------------------------------
  friend class vtkVisibleCellSelector;


  enum {NOT_SELECTING = 0, COLOR_BY_PROCESSOR, COLOR_BY_ACTOR,
        COLOR_BY_CELL_ID_HIGH, COLOR_BY_CELL_ID_MID, COLOR_BY_CELL_ID_LOW,
        COLOR_BY_VERTEX};

  vtkSetMacro(SelectMode, int);
  vtkSetMacro(SelectConst, unsigned int);

  void SetIdentPainter(vtkIdentColoredPainter*);

  virtual int UpdateGeometryForSelection(void);


  vtkPainter* SwapInSelectablePainter(vtkProp *,
                                              int &);


  void SwapOutSelectablePainter(vtkProp *,
                                vtkPainter*,
                                int );


  vtkProp            **PropsSelectedFrom;
  int                PropsSelectedFromCount;

  // Ivars for visible cell selecting
  int SelectMode;
  unsigned int SelectConst;
  vtkIdentColoredPainter *IdentPainter;
  // End Ivars for visible cell selecting.
#endif

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

  friend class vtkRenderPass;
  vtkRenderPass *Pass;

  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

---