vtkProperty.h

Go to the documentation of this file.

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

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

#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkObject.h"
#include <map> // used for ivar

// shading models
#define VTK_FLAT    0
#define VTK_GOURAUD 1
#define VTK_PHONG   2

// representation models
#define VTK_POINTS    0
#define VTK_WIREFRAME 1
#define VTK_SURFACE   2

class vtkActor;
class vtkInformation;
class vtkRenderer;
class vtkShaderProgram;
class vtkShaderDeviceAdapter2;
class vtkTexture;
class vtkWindow;
class vtkXMLDataElement;
class vtkXMLMaterial;

class vtkPropertyInternals;

class VTKRENDERINGCORE_EXPORT vtkProperty : public vtkObject
{
public:
  vtkTypeMacro(vtkProperty,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkProperty *New();

  void DeepCopy(vtkProperty *p);

  virtual void Render(vtkActor *, vtkRenderer *);

  virtual void BackfaceRender(vtkActor *, vtkRenderer *) {}

  virtual void PostRender(vtkActor*, vtkRenderer*);


  vtkGetMacro(Lighting, bool);
  vtkSetMacro(Lighting, bool);
  vtkBooleanMacro(Lighting, bool);


  vtkGetMacro(RenderPointsAsSpheres, bool);
  vtkSetMacro(RenderPointsAsSpheres, bool);
  vtkBooleanMacro(RenderPointsAsSpheres, bool);


  vtkGetMacro(RenderLinesAsTubes, bool);
  vtkSetMacro(RenderLinesAsTubes, bool);
  vtkBooleanMacro(RenderLinesAsTubes, bool);


  vtkSetClampMacro(Interpolation, int, VTK_FLAT, VTK_PHONG);
  vtkGetMacro(Interpolation,int);
  void SetInterpolationToFlat()
    { this->SetInterpolation(VTK_FLAT); }
  void SetInterpolationToGouraud()
    { this->SetInterpolation(VTK_GOURAUD); }
  void SetInterpolationToPhong()
    { this->SetInterpolation(VTK_PHONG); }
  const char *GetInterpolationAsString();


  vtkSetClampMacro(Representation,int, VTK_POINTS, VTK_SURFACE);
  vtkGetMacro(Representation,int);
  void SetRepresentationToPoints()
    { this->SetRepresentation(VTK_POINTS); }
  void SetRepresentationToWireframe()
    { this->SetRepresentation(VTK_WIREFRAME); }
  void SetRepresentationToSurface()
    { this->SetRepresentation(VTK_SURFACE); }
  const char *GetRepresentationAsString();


  virtual void SetColor(double r, double g, double b);
  virtual void SetColor(double a[3]);
  double *GetColor() VTK_SIZEHINT(3);
  void GetColor(double rgb[3]);
  void GetColor(double &r, double &g, double &b);


  vtkSetClampMacro(Ambient, double, 0.0, 1.0);
  vtkGetMacro(Ambient, double);


  vtkSetClampMacro(Diffuse, double, 0.0, 1.0);
  vtkGetMacro(Diffuse, double);


  vtkSetClampMacro(Specular, double, 0.0, 1.0);
  vtkGetMacro(Specular, double);


  vtkSetClampMacro(SpecularPower, double, 0.0, 128.0);
  vtkGetMacro(SpecularPower, double);


  vtkSetClampMacro(Opacity, double, 0.0, 1.0);
  vtkGetMacro(Opacity, double);


  vtkSetVector3Macro(AmbientColor, double);
  vtkGetVector3Macro(AmbientColor, double);


  vtkSetVector3Macro(DiffuseColor, double);
  vtkGetVector3Macro(DiffuseColor, double);


  vtkSetVector3Macro(SpecularColor, double);
  vtkGetVector3Macro(SpecularColor, double);


  vtkGetMacro(EdgeVisibility, vtkTypeBool);
  vtkSetMacro(EdgeVisibility, vtkTypeBool);
  vtkBooleanMacro(EdgeVisibility, vtkTypeBool);


  vtkSetVector3Macro(EdgeColor, double);
  vtkGetVector3Macro(EdgeColor, double);


  vtkGetMacro(VertexVisibility, vtkTypeBool);
  vtkSetMacro(VertexVisibility, vtkTypeBool);
  vtkBooleanMacro(VertexVisibility, vtkTypeBool);


  vtkSetVector3Macro(VertexColor, double);
  vtkGetVector3Macro(VertexColor, double);


  vtkSetClampMacro(LineWidth, float, 0, VTK_FLOAT_MAX);
  vtkGetMacro(LineWidth, float);


  vtkSetMacro(LineStipplePattern, int);
  vtkGetMacro(LineStipplePattern, int);


  vtkSetClampMacro(LineStippleRepeatFactor, int, 1, VTK_INT_MAX);
  vtkGetMacro(LineStippleRepeatFactor, int);


  vtkSetClampMacro(PointSize, float, 0, VTK_FLOAT_MAX);
  vtkGetMacro(PointSize, float);


  vtkGetMacro(BackfaceCulling, vtkTypeBool);
  vtkSetMacro(BackfaceCulling, vtkTypeBool);
  vtkBooleanMacro(BackfaceCulling, vtkTypeBool);


  vtkGetMacro(FrontfaceCulling, vtkTypeBool);
  vtkSetMacro(FrontfaceCulling, vtkTypeBool);
  vtkBooleanMacro(FrontfaceCulling, vtkTypeBool);


  vtkSetStringMacro(MaterialName);
  vtkGetStringMacro(MaterialName);


  vtkSetMacro(Shading, vtkTypeBool);
  vtkGetMacro(Shading, vtkTypeBool);
  vtkBooleanMacro(Shading, vtkTypeBool);

  virtual vtkShaderDeviceAdapter2* GetShaderDeviceAdapter2()
    { return nullptr; }


  virtual void AddShaderVariable(const char *name, int numVars, int *x);
  virtual void AddShaderVariable(const char *name, int numVars, float *x);
  virtual void AddShaderVariable(const char *name, int numVars, double *x);


  void AddShaderVariable(const char* name, int v)
    { this->AddShaderVariable(name, 1, &v); }
  void AddShaderVariable(const char* name, float v)
    { this->AddShaderVariable(name, 1, &v); }
  void AddShaderVariable(const char* name, double v)
    { this->AddShaderVariable(name, 1, &v); }
  void AddShaderVariable(const char* name, int v1, int v2)
  {
    int v[2] = {v1, v2};
    this->AddShaderVariable(name, 2, v);
  }
  void AddShaderVariable(const char* name, float v1, float v2)
  {
    float v[2] = {v1, v2};
    this->AddShaderVariable(name, 2, v);
  }
  void AddShaderVariable(const char* name, double v1, double v2)
  {
    double v[2] = {v1, v2};
    this->AddShaderVariable(name, 2, v);
  }
  void AddShaderVariable(const char* name, int v1, int v2, int v3)
  {
    int v[3] = {v1, v2, v3};
    this->AddShaderVariable(name, 3, v);
  }
  void AddShaderVariable(const char* name, float v1, float v2, float v3)
  {
    float v[3] = {v1, v2, v3};
    this->AddShaderVariable(name, 3, v);
  }
  void AddShaderVariable(const char* name, double v1, double v2, double v3)
  {
    double v[3] = {v1, v2, v3};
    this->AddShaderVariable(name, 3, v);
  }


  void SetTexture(const char* name, vtkTexture* texture);
  vtkTexture* GetTexture(const char* name);


  VTK_LEGACY(void SetTexture(int unit, vtkTexture* texture));
  VTK_LEGACY(vtkTexture* GetTexture(int unit));
  VTK_LEGACY(void RemoveTexture(int unit));

  void RemoveTexture(const char* name);

  void RemoveAllTextures();

  int GetNumberOfTextures();

  std::map<std::string, vtkTexture *> &GetAllTextures() {
    return this->Textures; }

  virtual void ReleaseGraphicsResources(vtkWindow *win);


#ifndef VTK_LEGACY_REMOVE
  // deprecated. Textures should use names not units
  enum VTKTextureUnit
  {
    VTK_TEXTURE_UNIT_0 = 0,
    VTK_TEXTURE_UNIT_1,
    VTK_TEXTURE_UNIT_2,
    VTK_TEXTURE_UNIT_3,
    VTK_TEXTURE_UNIT_4,
    VTK_TEXTURE_UNIT_5,
    VTK_TEXTURE_UNIT_6,
    VTK_TEXTURE_UNIT_7
  };
#endif


  vtkGetObjectMacro(Information, vtkInformation);
  virtual void SetInformation(vtkInformation*);

protected:
  vtkProperty();
  ~vtkProperty() override;

  static void ComputeCompositeColor(double result[3],
    double ambient, const double ambient_color[3],
    double diffuse, const double diffuse_color[3],
    double specular, const double specular_color[3]);

  double Color[3];
  double AmbientColor[3];
  double DiffuseColor[3];
  double SpecularColor[3];
  double EdgeColor[3];
  double VertexColor[3];
  double Ambient;
  double Diffuse;
  double Specular;
  double SpecularPower;
  double Opacity;
  float PointSize;
  float LineWidth;
  int LineStipplePattern;
  int LineStippleRepeatFactor;
  int Interpolation;
  int Representation;
  vtkTypeBool EdgeVisibility;
  vtkTypeBool VertexVisibility;
  vtkTypeBool BackfaceCulling;
  vtkTypeBool FrontfaceCulling;
  bool Lighting;
  bool RenderPointsAsSpheres;
  bool RenderLinesAsTubes;

  vtkTypeBool Shading;

  char* MaterialName;

  typedef std::map<std::string, vtkTexture*> MapOfTextures;
  MapOfTextures Textures;

  // Arbitrary extra information associated with this Property.
  vtkInformation* Information;

private:
  vtkProperty(const vtkProperty&) = delete;
  void operator=(const vtkProperty&) = delete;
};


inline const char *vtkProperty::GetInterpolationAsString(void)
{
  if (this->Interpolation == VTK_FLAT)
  {
    return "Flat";
  }
  else if (this->Interpolation == VTK_GOURAUD)
  {
    return "Gouraud";
  }
  else
  {
    return "Phong";
  }
}


inline const char *vtkProperty::GetRepresentationAsString(void)
{
  if (this->Representation == VTK_POINTS)
  {
    return "Points";
  }
  else if (this->Representation == VTK_WIREFRAME)
  {
    return "Wireframe";
  }
  else
  {
    return "Surface";
  }
}

#endif