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"
#include "vtkRenderingCoreModule.h" // For export macro
 
class vtkRenderer;
class vtkMapper;
class vtkAbstractVolumeMapper;
class vtkAbstractMapper3D;
class vtkImageMapper3D;
class vtkProperty;
class vtkVolumeProperty;
class vtkImageProperty;
class vtkTexture;
class vtkLODProp3DCallback;
 
struct vtkLODProp3DEntry_t
{
  vtkProp3D* Prop3D;
  int Prop3DType;
  int ID;
  double EstimatedTime;
  int State;
  double Level;
};
using vtkLODProp3DEntry = struct vtkLODProp3DEntry_t;
 
class VTKRENDERINGCORE_EXPORT vtkLODProp3D : public vtkProp3D
{
public:
  static vtkLODProp3D* New();
 
  vtkTypeMacro(vtkLODProp3D, vtkProp3D);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  double* GetBounds() VTK_SIZEHINT(6) override;
  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, vtkTypeBool, 0, 1);
  vtkGetMacro(AutomaticLODSelection, vtkTypeBool);
  vtkBooleanMacro(AutomaticLODSelection, vtkTypeBool);
 
 
  vtkSetMacro(SelectedLODID, int);
  vtkGetMacro(SelectedLODID, int);
 
  int GetLastRenderedLODID();
 
  int GetPickLODID(void);
 
 
  void GetActors(vtkPropCollection*) override;
  void GetVolumes(vtkPropCollection*) override;
 
 
  void SetSelectedPickLODID(int id);
  vtkGetMacro(SelectedPickLODID, int);
 
 
  vtkSetClampMacro(AutomaticPickLODSelection, vtkTypeBool, 0, 1);
  vtkGetMacro(AutomaticPickLODSelection, vtkTypeBool);
  vtkBooleanMacro(AutomaticPickLODSelection, vtkTypeBool);
 
  void ShallowCopy(vtkProp* prop) override;
 
 
  int RenderOpaqueGeometry(vtkViewport* viewport) override;
  int RenderTranslucentPolygonalGeometry(vtkViewport* viewport) override;
  int RenderVolumetricGeometry(vtkViewport* viewport) override;
 
  vtkTypeBool HasTranslucentPolygonalGeometry() override;
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
  void SetAllocatedRenderTime(double t, vtkViewport* vp) override;
 
  void RestoreEstimatedRenderTime() override;
 
  void AddEstimatedRenderTime(double t, vtkViewport* vp) override;
 
protected:
  vtkLODProp3D();
  ~vtkLODProp3D() override;
 
  int GetAutomaticPickPropIndex(void);
 
  // Assumes that SelectedLODIndex has already been validated:
  void UpdateKeysForSelectedProp();
 
  vtkLODProp3DEntry* LODs;
  int NumberOfEntries;
  int NumberOfLODs;
  int CurrentIndex;
 
  int GetNextEntryIndex();
  int ConvertIDToIndex(int id);
  int SelectedLODIndex;
 
  vtkTypeBool AutomaticLODSelection;
  int SelectedLODID;
  int SelectedPickLODID;
  vtkTypeBool AutomaticPickLODSelection;
  vtkLODProp3DCallback* PickCallback;
 
private:
  vtkLODProp3D(const vtkLODProp3D&) = delete;
  void operator=(const vtkLODProp3D&) = delete;
};
 
#endif