vtkProp.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkProp_h
#define vtkProp_h
 
#include "vtkObject.h"
 
#include "vtkDeprecation.h"         // for deprecation macro
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO
 
#include <vector> // for method args
 
VTK_ABI_NAMESPACE_BEGIN
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 VTK_MARSHALAUTO 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();
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  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);


  VTK_DEPRECATED_IN_9_6_0("Please use GENERAL_TEXTURE_UNIT() instead.")
  static vtkInformationIntegerKey* GeneralTextureUnit() { return vtkProp::GENERAL_TEXTURE_UNIT(); }
  static vtkInformationIntegerKey* GENERAL_TEXTURE_UNIT();


  VTK_DEPRECATED_IN_9_6_0("Please use GENERAL_TEXTURE_TRANSFORM() instead.")
  static vtkInformationDoubleVectorKey* GeneralTextureTransform()
  {
    return vtkProp::GENERAL_TEXTURE_TRANSFORM();
  }
  static vtkInformationDoubleVectorKey* GENERAL_TEXTURE_TRANSFORM();

  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;
};
 
VTK_ABI_NAMESPACE_END
#endif