dox/Rendering/vtkLODProp3D.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkLODProp3D.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 __vtkLODProp3D_h
#define __vtkLODProp3D_h

#include "vtkProp3D.h"

class vtkRenderer;
class vtkMapper;
class vtkAbstractVolumeMapper;
class vtkAbstractMapper3D;
class vtkImageMapper3D;
class vtkProperty;
class vtkVolumeProperty;
class vtkImageProperty;
class vtkTexture;
class vtkLODProp3DCallback;

typedef struct
{
  vtkProp3D   *Prop3D;
  int         Prop3DType;
  int         ID;
  double       EstimatedTime;
  int         State;
  double       Level;
} vtkLODProp3DEntry;

class VTK_RENDERING_EXPORT vtkLODProp3D : public vtkProp3D
{
public:
  static vtkLODProp3D *New();

  vtkTypeMacro(vtkLODProp3D,vtkProp3D);
  void PrintSelf(ostream& os, vtkIndent indent);


  double *GetBounds();
  void GetBounds(double bounds[6]) { this->vtkProp3D::GetBounds( bounds ); };


  int AddLOD( vtkMapper *m, vtkProperty *p, vtkProperty *back, 
              vtkTexture *t, double time );
  int AddLOD( vtkMapper *m, vtkProperty *p, vtkTexture *t, double time );
  int AddLOD( vtkMapper *m, vtkProperty *p, vtkProperty *back, double time );
  int AddLOD( vtkMapper *m, vtkProperty *p, double time );
  int AddLOD( vtkMapper *m, vtkTexture *t, double time );
  int AddLOD( vtkMapper *m, double time );
  int AddLOD( vtkAbstractVolumeMapper *m, vtkVolumeProperty *p, double time );
  int AddLOD( vtkAbstractVolumeMapper *m, double time );
  int AddLOD( vtkImageMapper3D *m, vtkImageProperty *p, double time );
  int AddLOD( vtkImageMapper3D *m, double time );


  vtkGetMacro(NumberOfLODs, int);
 

  vtkGetMacro(CurrentIndex, int);

  void RemoveLOD( int id );


  void SetLODProperty( int id, vtkProperty  *p );
  void GetLODProperty( int id, vtkProperty  **p );
  void SetLODProperty( int id, vtkVolumeProperty  *p );
  void GetLODProperty( int id, vtkVolumeProperty  **p );
  void SetLODProperty( int id, vtkImageProperty  *p );
  void GetLODProperty( int id, vtkImageProperty  **p );


  void SetLODMapper( int id, vtkMapper  *m );
  void GetLODMapper( int id, vtkMapper  **m );
  void SetLODMapper( int id, vtkAbstractVolumeMapper  *m );
  void GetLODMapper( int id, vtkAbstractVolumeMapper  **m );
  void SetLODMapper( int id, vtkImageMapper3D  *m );
  void GetLODMapper( int id, vtkImageMapper3D  **m );

  vtkAbstractMapper3D *GetLODMapper(int id);


  void SetLODBackfaceProperty( int id, vtkProperty *t );
  void GetLODBackfaceProperty( int id, vtkProperty **t );


  void SetLODTexture( int id, vtkTexture *t );
  void GetLODTexture( int id, vtkTexture **t );


  void EnableLOD( int id );
  void DisableLOD( int id );
  int IsLODEnabled( int id );


  void SetLODLevel( int id, double level );
  double GetLODLevel( int id );
  double GetLODIndexLevel( int index );


  double GetLODEstimatedRenderTime( int id );
  double GetLODIndexEstimatedRenderTime( int index );


  vtkSetClampMacro( AutomaticLODSelection, int, 0, 1 );
  vtkGetMacro( AutomaticLODSelection, int );
  vtkBooleanMacro( AutomaticLODSelection, int );


  vtkSetMacro( SelectedLODID, int );
  vtkGetMacro( SelectedLODID, int );

  int GetLastRenderedLODID();

  int GetPickLODID(void);


  virtual void GetActors(vtkPropCollection *);
  virtual void GetVolumes(vtkPropCollection *);
  

  void SetSelectedPickLODID(int id);
  vtkGetMacro( SelectedPickLODID, int );


  vtkSetClampMacro( AutomaticPickLODSelection, int, 0, 1 );
  vtkGetMacro( AutomaticPickLODSelection, int );
  vtkBooleanMacro( AutomaticPickLODSelection, int );

  void ShallowCopy(vtkProp *prop);

//BTX


  int RenderOpaqueGeometry(vtkViewport *viewport);
  virtual int RenderTranslucentPolygonalGeometry( vtkViewport *ren);
  virtual int RenderVolumetricGeometry( vtkViewport *ren);
  
  virtual int HasTranslucentPolygonalGeometry();
  
  void ReleaseGraphicsResources(vtkWindow *);

  void SetAllocatedRenderTime( double t, vtkViewport *vp );

  void RestoreEstimatedRenderTime( );
  
  virtual void AddEstimatedRenderTime( double t, vtkViewport *vp );

//ETX

protected:
  vtkLODProp3D();
  ~vtkLODProp3D();

  int GetAutomaticPickPropIndex(void);

  vtkLODProp3DEntry *LODs;
  int               NumberOfEntries;
  int               NumberOfLODs;
  int               CurrentIndex;

  int               GetNextEntryIndex();
  int               ConvertIDToIndex( int id );
  int               SelectedLODIndex;

  int               AutomaticLODSelection;
  int               SelectedLODID;
  int               SelectedPickLODID;
  int               AutomaticPickLODSelection;
  vtkLODProp3DCallback *PickCallback;

private:
  vtkLODProp3D(const vtkLODProp3D&);  // Not implemented.
  void operator=(const vtkLODProp3D&);  // Not implemented.
};

#endif