vtkProp.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkProp.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 vtkProp_h
#define vtkProp_h
 
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkObject.h"
#include <vector> // for method args
 
class vtkAssemblyPath;
class vtkAssemblyPaths;
class vtkHardwareSelector;
class vtkMatrix4x4;
class vtkPropCollection;
class vtkViewport;
class vtkWindow;
class vtkInformation;
class vtkInformationIntegerKey;
class vtkInformationDoubleVectorKey;
class vtkShaderProperty;
 
class VTKRENDERINGCORE_EXPORT vtkProp : public vtkObject
{
public:
  vtkTypeMacro(vtkProp, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  virtual void GetActors(vtkPropCollection *) {}
  virtual void GetActors2D(vtkPropCollection *) {}
  virtual void GetVolumes(vtkPropCollection *) {}
 
 
  vtkSetMacro(Visibility, vtkTypeBool);
  vtkGetMacro(Visibility, vtkTypeBool);
  vtkBooleanMacro(Visibility, vtkTypeBool);
 
 
  vtkSetMacro(Pickable, vtkTypeBool);
  vtkGetMacro(Pickable, vtkTypeBool);
  vtkBooleanMacro(Pickable, vtkTypeBool);
 
  virtual void Pick();
 
 
  vtkSetMacro(Dragable, vtkTypeBool);
  vtkGetMacro(Dragable, vtkTypeBool);
  vtkBooleanMacro(Dragable, vtkTypeBool);
 
  virtual vtkMTimeType GetRedrawMTime()
    { return this->GetMTime(); }
 
 
  vtkSetMacro(UseBounds, bool);
  vtkGetMacro(UseBounds, bool);
  vtkBooleanMacro(UseBounds, bool);
 
  virtual double *GetBounds() VTK_SIZEHINT(6)
    { return nullptr; }
 
  virtual void ShallowCopy(vtkProp *prop);
 
 
  virtual void InitPathTraversal();
  virtual vtkAssemblyPath *GetNextPath();
  virtual int GetNumberOfPaths()
    { return 1; }
 
  virtual void PokeMatrix(vtkMatrix4x4 *vtkNotUsed(matrix)) {}
  virtual vtkMatrix4x4 *GetMatrix()
    { return nullptr; }
 
 
  vtkGetObjectMacro(PropertyKeys,vtkInformation);
  virtual void SetPropertyKeys(vtkInformation *keys);
 
  virtual bool HasKeys(vtkInformation *requiredKeys);
 
  static vtkInformationIntegerKey *GeneralTextureUnit();
 
  static vtkInformationDoubleVectorKey *GeneralTextureTransform();
 
  virtual int RenderOpaqueGeometry(vtkViewport *)
    { return 0; }
  virtual int RenderTranslucentPolygonalGeometry(vtkViewport *)
    { return 0; }
  virtual int RenderVolumetricGeometry(vtkViewport *)
    { return 0; }
  virtual int RenderOverlay(vtkViewport *)
    { return 0; }
 
  virtual bool RenderFilteredOpaqueGeometry(vtkViewport *v,
                                            vtkInformation *requiredKeys);
 
  virtual bool RenderFilteredTranslucentPolygonalGeometry(
    vtkViewport *v,
    vtkInformation *requiredKeys);
 
  virtual bool RenderFilteredVolumetricGeometry(vtkViewport *v,
                                                vtkInformation *requiredKeys);
 
  virtual bool RenderFilteredOverlay(vtkViewport *v,
                                     vtkInformation *requiredKeys);
 
  virtual vtkTypeBool HasTranslucentPolygonalGeometry()
    { return 0; }
 
  virtual vtkTypeBool HasOpaqueGeometry()
    { return 1; }
 
  virtual void ReleaseGraphicsResources(vtkWindow *) {}
 
  virtual double GetEstimatedRenderTime( vtkViewport * )
    { return this->EstimatedRenderTime; }
  virtual double GetEstimatedRenderTime()
    { return this->EstimatedRenderTime; }
 
  virtual void SetEstimatedRenderTime(double t)
    { this->EstimatedRenderTime = t; this->SavedEstimatedRenderTime = t; }
 
  virtual void RestoreEstimatedRenderTime()
    { this->EstimatedRenderTime = this->SavedEstimatedRenderTime; }
 
 
  virtual void AddEstimatedRenderTime(double t, vtkViewport *vtkNotUsed(vp))
    { this->EstimatedRenderTime += t; }
 
 
  virtual void SetAllocatedRenderTime(double t, vtkViewport *vtkNotUsed(v))
  {
    this->AllocatedRenderTime = t;
    this->SavedEstimatedRenderTime = this->EstimatedRenderTime;
    this->EstimatedRenderTime = 0.0;
  }
 
 
  vtkGetMacro(AllocatedRenderTime, double);
 
  void SetRenderTimeMultiplier( double t )
    { this->RenderTimeMultiplier = t; }
  vtkGetMacro(RenderTimeMultiplier, double);
 
  virtual void BuildPaths(vtkAssemblyPaths *paths, vtkAssemblyPath *path);
 
  virtual bool GetSupportsSelection()
    { return false; }
 
  virtual void ProcessSelectorPixelBuffers(
    vtkHardwareSelector * /* sel */,
    std::vector<unsigned int> & /* pixeloffsets */) { };
 
 
  vtkGetMacro(NumberOfConsumers,int);
 
 
  void AddConsumer(vtkObject *c);
  void RemoveConsumer(vtkObject *c);
  vtkObject *GetConsumer(int i);
  int IsConsumer(vtkObject *c);
 
 
  virtual void SetShaderProperty(vtkShaderProperty *property);
  virtual vtkShaderProperty *GetShaderProperty();
 
  // Get if we are in the translucent polygonal geometry pass
  virtual bool IsRenderingTranslucentPolygonalGeometry() { return false; };
 
protected:
  vtkProp();
  ~vtkProp() override;
 
  vtkTypeBool Visibility;
  vtkTypeBool Pickable;
  vtkTypeBool Dragable;
  bool UseBounds;
 
  double AllocatedRenderTime;
  double EstimatedRenderTime;
  double SavedEstimatedRenderTime;
  double RenderTimeMultiplier;
 
  // how many consumers does this object have
  int NumberOfConsumers;
  vtkObject **Consumers;
 
  // support multi-part props and access to paths of prop
  // stuff that follows is used to build the assembly hierarchy
  vtkAssemblyPaths *Paths;
 
  vtkInformation *PropertyKeys;
 
  // User-defined shader replacement and uniform variables
  vtkShaderProperty *ShaderProperty;
 
private:
  vtkProp(const vtkProp&) = delete;
  void operator=(const vtkProp&) = delete;
};
 
#endif