VTK  9.1.0
vtkProperty.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkProperty.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================*/
31#ifndef vtkProperty_h
32#define vtkProperty_h
33
34#include "vtkObject.h"
35#include "vtkRenderingCoreModule.h" // For export macro
36#include <map> // used for ivar
37#include <string> // used for ivar
38
39// shading models
40#define VTK_FLAT 0
41#define VTK_GOURAUD 1
42#define VTK_PHONG 2
43#define VTK_PBR 3
44
45// representation models
46#define VTK_POINTS 0
47#define VTK_WIREFRAME 1
48#define VTK_SURFACE 2
49
50class vtkActor;
51class vtkInformation;
52class vtkRenderer;
54class vtkTexture;
55class vtkWindow;
57class vtkXMLMaterial;
58
59class vtkPropertyInternals;
60
61class VTKRENDERINGCORE_EXPORT vtkProperty : public vtkObject
62{
63public:
64 vtkTypeMacro(vtkProperty, vtkObject);
65 void PrintSelf(ostream& os, vtkIndent indent) override;
66
73 static vtkProperty* New();
74
79
87 virtual void Render(vtkActor*, vtkRenderer*);
88
96
103
105
108 vtkGetMacro(Lighting, bool);
109 vtkSetMacro(Lighting, bool);
110 vtkBooleanMacro(Lighting, bool);
112
114
120 vtkGetMacro(RenderPointsAsSpheres, bool);
121 vtkSetMacro(RenderPointsAsSpheres, bool);
122 vtkBooleanMacro(RenderPointsAsSpheres, bool);
124
126
133 vtkGetMacro(RenderLinesAsTubes, bool);
134 vtkSetMacro(RenderLinesAsTubes, bool);
135 vtkBooleanMacro(RenderLinesAsTubes, bool);
137
139
142 vtkSetClampMacro(Interpolation, int, VTK_FLAT, VTK_PBR);
143 vtkGetMacro(Interpolation, int);
144 void SetInterpolationToFlat() { this->SetInterpolation(VTK_FLAT); }
145 void SetInterpolationToGouraud() { this->SetInterpolation(VTK_GOURAUD); }
146 void SetInterpolationToPhong() { this->SetInterpolation(VTK_PHONG); }
147 void SetInterpolationToPBR() { this->SetInterpolation(VTK_PBR); }
148 const char* GetInterpolationAsString();
150
152
155 vtkSetClampMacro(Representation, int, VTK_POINTS, VTK_SURFACE);
156 vtkGetMacro(Representation, int);
157 void SetRepresentationToPoints() { this->SetRepresentation(VTK_POINTS); }
158 void SetRepresentationToWireframe() { this->SetRepresentation(VTK_WIREFRAME); }
159 void SetRepresentationToSurface() { this->SetRepresentation(VTK_SURFACE); }
160 const char* GetRepresentationAsString();
162
164
169 virtual void SetColor(double r, double g, double b);
170 virtual void SetColor(double a[3]);
171 double* GetColor() VTK_SIZEHINT(3);
172 void GetColor(double rgb[3]);
173 void GetColor(double& r, double& g, double& b);
175
177
188 vtkSetClampMacro(BaseIOR, double, 1.0, VTK_FLOAT_MAX);
189 vtkGetMacro(BaseIOR, double);
191
193
199 vtkSetClampMacro(Metallic, double, 0.0, 1.0);
200 vtkGetMacro(Metallic, double);
202
204
211 vtkSetClampMacro(Roughness, double, 0.0, 1.0);
212 vtkGetMacro(Roughness, double);
214
216
222 vtkSetClampMacro(Anisotropy, double, 0.0, 1.0);
223 vtkGetMacro(Anisotropy, double);
225
227
233 vtkSetClampMacro(AnisotropyRotation, double, 0.0, 1.0);
234 vtkGetMacro(AnisotropyRotation, double);
236
238
243 vtkSetClampMacro(CoatIOR, double, 1.0, VTK_FLOAT_MAX);
244 vtkGetMacro(CoatIOR, double);
246
248
254 vtkSetClampMacro(CoatRoughness, double, 0.0, 1.0);
255 vtkGetMacro(CoatRoughness, double);
257
259
265 vtkSetClampMacro(CoatStrength, double, 0.0, 1.0);
266 vtkGetMacro(CoatStrength, double);
268
270
275 vtkSetVector3Macro(CoatColor, double);
276 vtkGetVector3Macro(CoatColor, double);
278
280
286 vtkSetClampMacro(CoatNormalScale, double, 0.0, 1.0);
287 vtkGetMacro(CoatNormalScale, double);
289
291
296 vtkSetMacro(NormalScale, double);
297 vtkGetMacro(NormalScale, double);
299
301
307 vtkSetClampMacro(OcclusionStrength, double, 0.0, 1.0);
308 vtkGetMacro(OcclusionStrength, double);
310
312
318 vtkSetVector3Macro(EmissiveFactor, double);
319 vtkGetVector3Macro(EmissiveFactor, double);
321
323
329 vtkSetVector3Macro(EdgeTint, double);
330 vtkGetVector3Macro(EdgeTint, double);
332
334
337 vtkSetClampMacro(Ambient, double, 0.0, 1.0);
338 vtkGetMacro(Ambient, double);
340
342
345 vtkSetClampMacro(Diffuse, double, 0.0, 1.0);
346 vtkGetMacro(Diffuse, double);
348
350
353 vtkSetClampMacro(Specular, double, 0.0, 1.0);
354 vtkGetMacro(Specular, double);
356
358
361 vtkSetClampMacro(SpecularPower, double, 0.0, 128.0);
362 vtkGetMacro(SpecularPower, double);
364
366
370 vtkSetClampMacro(Opacity, double, 0.0, 1.0);
371 vtkGetMacro(Opacity, double);
373
375
381 vtkSetVector3Macro(AmbientColor, double);
382 vtkGetVector3Macro(AmbientColor, double);
384
386
390 vtkSetVector3Macro(DiffuseColor, double);
391 vtkGetVector3Macro(DiffuseColor, double);
393
395
398 vtkSetVector3Macro(SpecularColor, double);
399 vtkGetVector3Macro(SpecularColor, double);
401
403
408 vtkGetMacro(EdgeVisibility, vtkTypeBool);
409 vtkSetMacro(EdgeVisibility, vtkTypeBool);
410 vtkBooleanMacro(EdgeVisibility, vtkTypeBool);
412
414
417 vtkSetVector3Macro(EdgeColor, double);
418 vtkGetVector3Macro(EdgeColor, double);
420
422
427 vtkGetMacro(VertexVisibility, vtkTypeBool);
428 vtkSetMacro(VertexVisibility, vtkTypeBool);
429 vtkBooleanMacro(VertexVisibility, vtkTypeBool);
431
433
436 vtkSetVector3Macro(VertexColor, double);
437 vtkGetVector3Macro(VertexColor, double);
439
441
445 vtkSetVector4Macro(SelectionColor, double);
446 vtkGetVector4Macro(SelectionColor, double);
448
450
454 vtkSetMacro(SelectionLineWidth, float);
455 vtkGetMacro(SelectionLineWidth, float);
457
459
463 vtkSetMacro(SelectionPointSize, float);
464 vtkGetMacro(SelectionPointSize, float);
466
468
472 vtkSetClampMacro(LineWidth, float, 0, VTK_FLOAT_MAX);
473 vtkGetMacro(LineWidth, float);
475
477
482 vtkSetMacro(LineStipplePattern, int);
483 vtkGetMacro(LineStipplePattern, int);
485
487
492 vtkSetClampMacro(LineStippleRepeatFactor, int, 1, VTK_INT_MAX);
493 vtkGetMacro(LineStippleRepeatFactor, int);
495
497
501 vtkSetClampMacro(PointSize, float, 0, VTK_FLOAT_MAX);
502 vtkGetMacro(PointSize, float);
504
506
511 vtkGetMacro(BackfaceCulling, vtkTypeBool);
512 vtkSetMacro(BackfaceCulling, vtkTypeBool);
513 vtkBooleanMacro(BackfaceCulling, vtkTypeBool);
515
517
522 vtkGetMacro(FrontfaceCulling, vtkTypeBool);
523 vtkSetMacro(FrontfaceCulling, vtkTypeBool);
524 vtkBooleanMacro(FrontfaceCulling, vtkTypeBool);
526
528
531 vtkSetStringMacro(MaterialName);
532 vtkGetStringMacro(MaterialName);
534
536
540 vtkSetMacro(Shading, vtkTypeBool);
541 vtkGetMacro(Shading, vtkTypeBool);
542 vtkBooleanMacro(Shading, vtkTypeBool);
544
546
554 virtual void AddShaderVariable(const char* name, int numVars, int* x);
555 virtual void AddShaderVariable(const char* name, int numVars, float* x);
556 virtual void AddShaderVariable(const char* name, int numVars, double* x);
558
560
563 void AddShaderVariable(const char* name, int v) { this->AddShaderVariable(name, 1, &v); }
564 void AddShaderVariable(const char* name, float v) { this->AddShaderVariable(name, 1, &v); }
565 void AddShaderVariable(const char* name, double v) { this->AddShaderVariable(name, 1, &v); }
566 void AddShaderVariable(const char* name, int v1, int v2)
567 {
568 int v[2] = { v1, v2 };
569 this->AddShaderVariable(name, 2, v);
570 }
571 void AddShaderVariable(const char* name, float v1, float v2)
572 {
573 float v[2] = { v1, v2 };
574 this->AddShaderVariable(name, 2, v);
575 }
576 void AddShaderVariable(const char* name, double v1, double v2)
577 {
578 double v[2] = { v1, v2 };
579 this->AddShaderVariable(name, 2, v);
580 }
581 void AddShaderVariable(const char* name, int v1, int v2, int v3)
582 {
583 int v[3] = { v1, v2, v3 };
584 this->AddShaderVariable(name, 3, v);
585 }
586 void AddShaderVariable(const char* name, float v1, float v2, float v3)
587 {
588 float v[3] = { v1, v2, v3 };
589 this->AddShaderVariable(name, 3, v);
590 }
591 void AddShaderVariable(const char* name, double v1, double v2, double v3)
592 {
593 double v[3] = { v1, v2, v3 };
594 this->AddShaderVariable(name, 3, v);
595 }
597
599
603 vtkSetMacro(ShowTexturesOnBackface, bool);
604 vtkGetMacro(ShowTexturesOnBackface, bool);
605 vtkBooleanMacro(ShowTexturesOnBackface, bool);
607
609
622 void SetTexture(const char* name, vtkTexture* texture);
625
632 void SetBaseColorTexture(vtkTexture* texture) { this->SetTexture("albedoTex", texture); }
633
643 void SetORMTexture(vtkTexture* texture) { this->SetTexture("materialTex", texture); }
644
655 void SetAnisotropyTexture(vtkTexture* texture) { this->SetTexture("anisotropyTex", texture); }
656
665 void SetNormalTexture(vtkTexture* texture) { this->SetTexture("normalTex", texture); }
666
674 void SetEmissiveTexture(vtkTexture* texture) { this->SetTexture("emissiveTex", texture); }
675
684 void SetCoatNormalTexture(vtkTexture* texture) { this->SetTexture("coatNormalTex", texture); }
685
689 void RemoveTexture(const char* name);
690
695
700
704 std::map<std::string, vtkTexture*>& GetAllTextures() { return this->Textures; }
705
712
714
717 vtkGetObjectMacro(Information, vtkInformation);
720
722
726 static double ComputeReflectanceFromIOR(double IORTo, double IORFrom);
728
730
734 static double ComputeIORFromReflectance(double reflectance, double ior);
736
738
746
747protected:
749 ~vtkProperty() override;
750
754 static void ComputeCompositeColor(double result[3], double ambient, const double ambient_color[3],
755 double diffuse, const double diffuse_color[3], double specular, const double specular_color[3]);
756
757 double Color[3];
758 double AmbientColor[3];
759 double DiffuseColor[3];
760 double SpecularColor[3];
761 double EdgeColor[3];
762 double VertexColor[3];
763 double SelectionColor[4] = { 1.0, 0.0, 0.0, 1.0 };
764 double Ambient;
765 double Diffuse;
766 double Metallic;
767 double Roughness;
770 double BaseIOR;
771 double CoatIOR;
772 double CoatColor[3];
778 double EmissiveFactor[3];
779 double Specular;
781 double Opacity;
782 double EdgeTint[3];
785 float SelectionPointSize = 2.f;
786 float SelectionLineWidth = 2.f;
799
801
803
804 typedef std::map<std::string, vtkTexture*> MapOfTextures;
806
807 // Arbitrary extra information associated with this Property.
809
810private:
811 vtkProperty(const vtkProperty&) = delete;
812 void operator=(const vtkProperty&) = delete;
813};
814
819{
820 if (this->Interpolation == VTK_FLAT)
821 {
822 return "Flat";
823 }
824 else if (this->Interpolation == VTK_GOURAUD)
825 {
826 return "Gouraud";
827 }
828 else if (this->Interpolation == VTK_PHONG)
829 {
830 return "Phong";
831 }
832 else // if (this->Interpolation == VTK_PBR)
833 {
834 return "Physically based rendering";
835 }
836}
837
842{
843 if (this->Representation == VTK_POINTS)
844 {
845 return "Points";
846 }
847 else if (this->Representation == VTK_WIREFRAME)
848 {
849 return "Wireframe";
850 }
851 else
852 {
853 return "Surface";
854 }
855}
856
857#endif
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:46
a simple class to control print indentation
Definition: vtkIndent.h:34
Store vtkAlgorithm input/output information.
abstract base class for most VTK objects
Definition: vtkObject.h:63
represent surface properties of a geometric object
Definition: vtkProperty.h:62
MapOfTextures Textures
Definition: vtkProperty.h:805
static vtkProperty * New()
Construct object with object color, ambient color, diffuse color, specular color, and edge color whit...
double ComputeReflectanceOfBaseLayer()
For PBR, calculate the reflectance of the base layer depending on the presence of a coat layer.
std::map< std::string, vtkTexture * > MapOfTextures
Definition: vtkProperty.h:804
double CoatRoughness
Definition: vtkProperty.h:773
~vtkProperty() override
void SetRepresentationToPoints()
Control the surface geometry representation for the object.
Definition: vtkProperty.h:157
double CoatNormalScale
Definition: vtkProperty.h:775
int LineStipplePattern
Definition: vtkProperty.h:787
void SetTexture(const char *name, vtkTexture *texture)
Set/Get the texture object to control rendering texture maps.
void SetRepresentationToWireframe()
Control the surface geometry representation for the object.
Definition: vtkProperty.h:158
virtual void SetInformation(vtkInformation *)
Set/Get the information object associated with the Property.
int LineStippleRepeatFactor
Definition: vtkProperty.h:788
double AnisotropyRotation
Definition: vtkProperty.h:769
double * GetColor()
Set the color of the object.
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])
Computes composite color.
virtual void SetColor(double a[3])
Set the color of the object.
double OcclusionStrength
Definition: vtkProperty.h:777
double Diffuse
Definition: vtkProperty.h:765
void AddShaderVariable(const char *name, double v1, double v2)
Methods to provide to add shader variables from wrappers.
Definition: vtkProperty.h:576
virtual void BackfaceRender(vtkActor *, vtkRenderer *)
This method renders the property as a backface property.
Definition: vtkProperty.h:95
double Opacity
Definition: vtkProperty.h:781
void SetNormalTexture(vtkTexture *texture)
Set the normal texture.
Definition: vtkProperty.h:665
int Representation
Definition: vtkProperty.h:790
float LineWidth
Definition: vtkProperty.h:784
int GetNumberOfTextures()
Returns the number of textures in this property.
double CoatStrength
Definition: vtkProperty.h:774
void SetEmissiveTexture(vtkTexture *texture)
Set the emissive texture.
Definition: vtkProperty.h:674
void SetInterpolationToFlat()
Set the shading interpolation method for an object.
Definition: vtkProperty.h:144
void RemoveAllTextures()
Remove all the textures.
void SetBaseColorTexture(vtkTexture *texture)
Set the base color texture.
Definition: vtkProperty.h:632
double Metallic
Definition: vtkProperty.h:766
void SetCoatNormalTexture(vtkTexture *texture)
Set the coat normal texture.
Definition: vtkProperty.h:684
void SetInterpolationToGouraud()
Set the shading interpolation method for an object.
Definition: vtkProperty.h:145
vtkTypeBool BackfaceCulling
Definition: vtkProperty.h:793
void DeepCopy(vtkProperty *p)
Assign one property to another.
int Interpolation
Definition: vtkProperty.h:789
double Anisotropy
Definition: vtkProperty.h:768
vtkTexture * GetTexture(const char *name)
Set/Get the texture object to control rendering texture maps.
void AddShaderVariable(const char *name, double v)
Methods to provide to add shader variables from wrappers.
Definition: vtkProperty.h:565
void SetInterpolationToPBR()
Set the shading interpolation method for an object.
Definition: vtkProperty.h:147
virtual void Render(vtkActor *, vtkRenderer *)
This method causes the property to set up whatever is required for its instance variables.
const char * GetInterpolationAsString()
Return the method of shading as a descriptive character string.
Definition: vtkProperty.h:818
void SetRepresentationToSurface()
Control the surface geometry representation for the object.
Definition: vtkProperty.h:159
void SetInterpolationToPhong()
Set the shading interpolation method for an object.
Definition: vtkProperty.h:146
double Roughness
Definition: vtkProperty.h:767
double BaseIOR
Definition: vtkProperty.h:770
void AddShaderVariable(const char *name, double v1, double v2, double v3)
Methods to provide to add shader variables from wrappers.
Definition: vtkProperty.h:591
bool RenderPointsAsSpheres
Definition: vtkProperty.h:796
vtkTypeBool Shading
Definition: vtkProperty.h:800
float PointSize
Definition: vtkProperty.h:783
void SetORMTexture(vtkTexture *texture)
Set the ORM texture.
Definition: vtkProperty.h:643
void AddShaderVariable(const char *name, int v1, int v2, int v3)
Methods to provide to add shader variables from wrappers.
Definition: vtkProperty.h:581
virtual void SetColor(double r, double g, double b)
Set the color of the object.
vtkInformation * Information
Definition: vtkProperty.h:808
static double ComputeReflectanceFromIOR(double IORTo, double IORFrom)
For PBR, calculate the reflectance from the refractive index of ingoing and outgoing interfaces.
void AddShaderVariable(const char *name, float v1, float v2, float v3)
Methods to provide to add shader variables from wrappers.
Definition: vtkProperty.h:586
double Specular
Definition: vtkProperty.h:779
double NormalScale
Definition: vtkProperty.h:776
bool RenderLinesAsTubes
Definition: vtkProperty.h:797
virtual void ReleaseGraphicsResources(vtkWindow *win)
Release any graphics resources that are being consumed by this property.
vtkTypeBool EdgeVisibility
Definition: vtkProperty.h:791
vtkTypeBool VertexVisibility
Definition: vtkProperty.h:792
void AddShaderVariable(const char *name, int v)
Methods to provide to add shader variables from wrappers.
Definition: vtkProperty.h:563
double SpecularPower
Definition: vtkProperty.h:780
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void SetAnisotropyTexture(vtkTexture *texture)
Set the anisotropy texture.
Definition: vtkProperty.h:655
vtkTypeBool FrontfaceCulling
Definition: vtkProperty.h:794
void RemoveTexture(const char *name)
Remove a texture from the collection.
void AddShaderVariable(const char *name, float v1, float v2)
Methods to provide to add shader variables from wrappers.
Definition: vtkProperty.h:571
bool ShowTexturesOnBackface
Definition: vtkProperty.h:798
static double ComputeIORFromReflectance(double reflectance, double ior)
For PBR, calculate the refractive index from the reflectance of the interface and the refractive inde...
virtual void PostRender(vtkActor *, vtkRenderer *)
This method is called after the actor has been rendered.
double Ambient
Definition: vtkProperty.h:764
double CoatIOR
Definition: vtkProperty.h:771
void AddShaderVariable(const char *name, int v1, int v2)
Methods to provide to add shader variables from wrappers.
Definition: vtkProperty.h:566
std::map< std::string, vtkTexture * > & GetAllTextures()
Returns all the textures in this property and their names.
Definition: vtkProperty.h:704
const char * GetRepresentationAsString()
Return the method of shading as a descriptive character string.
Definition: vtkProperty.h:841
void AddShaderVariable(const char *name, float v)
Methods to provide to add shader variables from wrappers.
Definition: vtkProperty.h:564
char * MaterialName
Definition: vtkProperty.h:802
abstract specification for renderers
Definition: vtkRenderer.h:73
The ShaderProgram uses one or more Shader objects.
handles properties associated with a texture map
Definition: vtkTexture.h:66
window superclass for vtkRenderWindow
Definition: vtkWindow.h:39
Represents an XML element and those nested inside.
@ Color
Definition: vtkX3D.h:52
@ name
Definition: vtkX3D.h:225
int vtkTypeBool
Definition: vtkABI.h:69
#define VTK_POINTS
Definition: vtkProperty.h:46
#define VTK_WIREFRAME
Definition: vtkProperty.h:47
#define VTK_PHONG
Definition: vtkProperty.h:42
#define VTK_FLAT
Definition: vtkProperty.h:40
#define VTK_PBR
Definition: vtkProperty.h:43
#define VTK_SURFACE
Definition: vtkProperty.h:48
#define VTK_GOURAUD
Definition: vtkProperty.h:41
#define VTK_INT_MAX
Definition: vtkType.h:155
#define VTK_FLOAT_MAX
Definition: vtkType.h:163
#define VTK_SIZEHINT(...)