vtkProperty.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 vtkProperty_h
#define vtkProperty_h
 
#include "vtkObject.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO
#include <map>                      // used for ivar
#include <string>                   // used for ivar
 
// shading models
#define VTK_FLAT 0
#define VTK_GOURAUD 1
#define VTK_PHONG 2
#define VTK_PBR 3
 
// representation models
#define VTK_POINTS 0
#define VTK_WIREFRAME 1
#define VTK_SURFACE 2
 
VTK_ABI_NAMESPACE_BEGIN
class vtkActor;
class vtkInformation;
class vtkRenderer;
class vtkShaderProgram;
class vtkTexture;
class vtkWindow;
class vtkXMLDataElement;
class vtkXMLMaterial;
 
class vtkPropertyInternals;
 
class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO 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_PBR);
  vtkGetMacro(Interpolation, int);
  void SetInterpolationToFlat() { this->SetInterpolation(VTK_FLAT); }
  void SetInterpolationToGouraud() { this->SetInterpolation(VTK_GOURAUD); }
  void SetInterpolationToPhong() { this->SetInterpolation(VTK_PHONG); }
  void SetInterpolationToPBR() { this->SetInterpolation(VTK_PBR); }
  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(BaseIOR, double, 1.0, VTK_FLOAT_MAX);
  vtkGetMacro(BaseIOR, double);
 
 
  vtkSetClampMacro(Metallic, double, 0.0, 1.0);
  vtkGetMacro(Metallic, double);
 
 
  vtkSetClampMacro(Roughness, double, 0.0, 1.0);
  vtkGetMacro(Roughness, double);
 
 
  vtkSetClampMacro(Anisotropy, double, 0.0, 1.0);
  vtkGetMacro(Anisotropy, double);
 
 
  vtkSetClampMacro(AnisotropyRotation, double, 0.0, 1.0);
  vtkGetMacro(AnisotropyRotation, double);
 
 
  vtkSetClampMacro(CoatIOR, double, 1.0, VTK_FLOAT_MAX);
  vtkGetMacro(CoatIOR, double);
 
 
  vtkSetClampMacro(CoatRoughness, double, 0.0, 1.0);
  vtkGetMacro(CoatRoughness, double);
 
 
  vtkSetClampMacro(CoatStrength, double, 0.0, 1.0);
  vtkGetMacro(CoatStrength, double);
 
 
  vtkSetVector3Macro(CoatColor, double);
  vtkGetVector3Macro(CoatColor, double);
 
 
  vtkSetClampMacro(CoatNormalScale, double, 0.0, 1.0);
  vtkGetMacro(CoatNormalScale, double);
 
 
  vtkSetMacro(NormalScale, double);
  vtkGetMacro(NormalScale, double);
 
 
  vtkSetClampMacro(OcclusionStrength, double, 0.0, 1.0);
  vtkGetMacro(OcclusionStrength, double);
 
 
  vtkSetVector3Macro(EmissiveFactor, double);
  vtkGetVector3Macro(EmissiveFactor, double);
 
 
  vtkSetVector3Macro(EdgeTint, double);
  vtkGetVector3Macro(EdgeTint, double);
 
 
  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);
 
 
  vtkSetClampMacro(EdgeOpacity, double, 0.0, 1.0);
  vtkGetMacro(EdgeOpacity, 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);
 
 
  vtkSetVector4Macro(SelectionColor, double);
  vtkGetVector4Macro(SelectionColor, double);
 
 
  vtkSetMacro(SelectionLineWidth, float);
  vtkGetMacro(SelectionLineWidth, float);
 
 
  vtkSetMacro(SelectionPointSize, float);
  vtkGetMacro(SelectionPointSize, float);
 
 
  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 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);
  }
 
 
  vtkSetMacro(ShowTexturesOnBackface, bool);
  vtkGetMacro(ShowTexturesOnBackface, bool);
  vtkBooleanMacro(ShowTexturesOnBackface, bool);
 
 
  void SetTexture(const char* name, vtkTexture* texture);
  vtkTexture* GetTexture(const char* name);
 
  void SetBaseColorTexture(vtkTexture* texture) { this->SetTexture("albedoTex", texture); }
 
  void SetORMTexture(vtkTexture* texture) { this->SetTexture("materialTex", texture); }
 
  void SetAnisotropyTexture(vtkTexture* texture) { this->SetTexture("anisotropyTex", texture); }
 
  void SetNormalTexture(vtkTexture* texture) { this->SetTexture("normalTex", texture); }
 
  void SetEmissiveTexture(vtkTexture* texture) { this->SetTexture("emissiveTex", texture); }
 
  void SetCoatNormalTexture(vtkTexture* texture) { this->SetTexture("coatNormalTex", texture); }
 
  void RemoveTexture(const char* name);
 
  void RemoveAllTextures();
 
  int GetNumberOfTextures();
 
  std::map<std::string, vtkTexture*>& GetAllTextures() { return this->Textures; }
 
  virtual void ReleaseGraphicsResources(vtkWindow* win);
 
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  vtkGetObjectMacro(Information, vtkInformation);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual void SetInformation(vtkInformation*);
 
 
  static double ComputeReflectanceFromIOR(double IORTo, double IORFrom);
 
 
  static double ComputeIORFromReflectance(double reflectance, double ior);
 
 
  double ComputeReflectanceOfBaseLayer();
 
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 SelectionColor[4] = { 1.0, 0.0, 0.0, 1.0 };
  double Ambient;
  double Diffuse;
  double Metallic;
  double Roughness;
  double Anisotropy;
  double AnisotropyRotation;
  double BaseIOR;
  double CoatIOR;
  double CoatColor[3];
  double CoatRoughness;
  double CoatStrength;
  double CoatNormalScale;
  double NormalScale;
  double OcclusionStrength;
  double EmissiveFactor[3];
  double Specular;
  double SpecularPower;
  double Opacity;
  double EdgeOpacity = 1.0;
  double EdgeTint[3];
  float PointSize;
  float LineWidth;
  float SelectionPointSize = 2.f;
  float SelectionLineWidth = 2.f;
  int LineStipplePattern;
  int LineStippleRepeatFactor;
  int Interpolation;
  int Representation;
  vtkTypeBool EdgeVisibility;
  vtkTypeBool VertexVisibility;
  vtkTypeBool BackfaceCulling;
  vtkTypeBool FrontfaceCulling;
  bool Lighting;
  bool RenderPointsAsSpheres;
  bool RenderLinesAsTubes;
  bool ShowTexturesOnBackface;
 
  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()
{
  if (this->Interpolation == VTK_FLAT)
  {
    return "Flat";
  }
  else if (this->Interpolation == VTK_GOURAUD)
  {
    return "Gouraud";
  }
  else if (this->Interpolation == VTK_PHONG)
  {
    return "Phong";
  }
  else // if (this->Interpolation == VTK_PBR)
  {
    return "Physically based rendering";
  }
}
 
inline const char* vtkProperty::GetRepresentationAsString()
{
  if (this->Representation == VTK_POINTS)
  {
    return "Points";
  }
  else if (this->Representation == VTK_WIREFRAME)
  {
    return "Wireframe";
  }
  else
  {
    return "Surface";
  }
}
 
VTK_ABI_NAMESPACE_END
#endif