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 "vtkRenderingCoreModule.h" // For export macro
#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 VTKRENDERINGCORE_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