Defines a standard CG material with textures and a shader program. More...

#include <SLMaterial.h>

Inheritance diagram for SLMaterial:

Public Member Functions
	SLMaterial (SLAssetManager am, const SLchar name, const SLCol4f &amdi=SLCol4f::WHITE, const SLCol4f &spec=SLCol4f::WHITE, SLfloat shininess=100.0f, SLfloat kr=0.0, SLfloat kt=0.0f, SLfloat kn=1.0f, SLGLProgram *program=nullptr)
	Default ctor for Blinn-Phong reflection model materials without textures. More...

	SLMaterial (SLAssetManager am, const SLchar name, SLGLTexture texture1, SLGLTexture texture2=nullptr, SLGLTexture texture3=nullptr, SLGLTexture texture4=nullptr, SLGLProgram *program=nullptr)
	Ctor for textured Blinn-Phong reflection model materials. More...

	SLMaterial (SLAssetManager am, const SLchar name, SLSkybox skybox, SLCol4f diffuse, SLfloat roughness, SLfloat metalness, SLGLProgram program=nullptr)
	Ctor for PBR material with Cook-Torrance material parameters. More...

	SLMaterial (SLAssetManager am, const SLchar name, SLSkybox skybox, SLGLTexture texture1, SLGLTexture texture2=nullptr, SLGLTexture texture3=nullptr, SLGLTexture texture4=nullptr, SLGLTexture texture5=nullptr, SLGLProgram *program=nullptr)
	Ctor for PBR material with Cook-Torrance material textures. More...

	SLMaterial (SLAssetManager am, const SLchar name, SLParticleSystem ps, SLGLTexture texture, SLGLProgram program=nullptr, SLGLProgram programTF=nullptr)
	Ctor for Particle System material with one texture (Draw and update) More...

	SLMaterial (SLAssetManager am, SLGLProgram colorUniformProgram, const SLCol4f &uniformColor, const SLchar name=(const char )"Uniform color")
	Ctor for uniform color material without lighting. More...

	SLMaterial (SLAssetManager am, const SLchar name, SLGLProgram *program)
	Ctor for only a program. More...

	~SLMaterial () override

void	generateProgramPS (bool drawInstanced=false)

void	activate (SLCamera cam, SLVLight lights, SLbool supportGPUSkinning)

SLint	passToUniforms (SLGLProgram *program, SLint nextTexUnit)
	Passes all material parameters as uniforms to the passed shader program. More...

void	deleteDataGpu ()

SLbool	hasAlpha ()
	Returns true if there is any transparency in diffuse alpha or textures. More...

SLbool	has3DTexture ()
	Returns true if a material has a 3D texture. More...

SLbool	usesUVIndex (SLbyte uvIndex)
	Returns true if the specified uvIndex is used by one of the textures. More...

SLbool	needsTangents ()

SLbool	hasTextureType (SLTextureType tt)

SLbool	hasTextureTypeWithUVIndex (SLTextureType tt, SLuint texIndex, SLbyte uvIndex)

void	removeTextureType (SLTextureType tt)

void	addTexture (SLGLTexture *texture)
	Adds the passed texture to the equivalent texture type vector. More...

SLstring	texturesString ()
	Returns a unique string that represent all textures used. More...

void	assetManager (SLAssetManager *am)

void	reflectionModel (SLReflectionModel rm)

void	ambient (const SLCol4f &ambi)

void	diffuse (const SLCol4f &diff)

void	ambientDiffuse (const SLCol4f &am_di)

void	specular (const SLCol4f &spec)

void	emissive (const SLCol4f &emis)

void	transmissive (const SLCol4f &transm)

void	translucency (SLfloat transl)

void	shininess (SLfloat shin)

void	roughness (SLfloat r)

void	metalness (SLfloat m)

void	kr (SLfloat kr)

void	kt (SLfloat kt)

void	kn (SLfloat kn)

void	getsShadows (SLbool receivesShadows)

void	program (SLGLProgram *sp)

void	programTF (SLGLProgram *sp)

void	skybox (SLSkybox *sb)

void	ps (SLParticleSystem *ps)

SLAssetManager *	assetManager ()

SLReflectionModel	reflectionModel ()

SLCol4f	ambient ()

SLCol4f	diffuse ()

SLCol4f	specular ()

SLCol4f	emissive ()

SLfloat	shininess () const

SLfloat	roughness () const

SLfloat	metalness () const

SLCol4f	transmissive ()

SLfloat	translucency () const

SLfloat	kr () const

SLfloat	kt () const

SLfloat	kn () const

SLbool	getsShadows () const

SLuint	numTextures ()

SLGLProgram *	program ()

SLGLProgram *	programTF ()

SLSkybox *	skybox ()

SLParticleSystem *	ps ()

SLVNode &	nodesVisible2D ()

SLVNode &	nodesVisible3D ()

SLVGLTexture &	textures (SLTextureType type)

SLVGLTexture &	textures3d ()

Public Member Functions inherited from SLObject
	SLObject (const SLstring &Name="", const SLstring &url="")

virtual	~SLObject ()

void	name (const SLstring &Name)

void	url (const SLstring &url)

const SLstring &	name () const

const SLstring &	url () const

Static Public Attributes
static SLfloat	K
	PM: Constant of gloss calibration (slope of point light at dist 1) More...

static SLfloat	PERFECT = 1000.0f
	PM: shininess/translucency limit. More...

Protected Attributes
SLAssetManager *	_assetManager
	pointer to the asset manager (the owner) if available More...

SLReflectionModel	_reflectionModel
	reflection model (RM_BlinnPhong or RM_CookTorrance) More...

SLCol4f	_ambient
	ambient color (RGB reflection coefficients) More...

SLCol4f	_diffuse
	diffuse color (RGB reflection coefficients) More...

SLCol4f	_specular
	specular color (RGB reflection coefficients) More...

SLCol4f	_emissive
	emissive color coefficients More...

SLfloat	_shininess
	shininess exponent in Blinn-Phong model More...

SLfloat	_roughness
	roughness property (0-1) in Cook-Torrance model More...

SLfloat	_metalness
	metallic property (0-1) in Cook-Torrance model More...

SLCol4f	_transmissive
	transmissive color (RGB reflection coefficients) for path tracing More...

SLfloat	_translucency
	translucency exponent for light refraction for path tracing More...

SLfloat	_kr {}
	reflection coefficient 0.0 - 1.0 used for ray and path tracing More...

SLfloat	_kt {}
	transmission coefficient 0.0 - 1.0 used for ray and path tracing More...

SLfloat	_kn {}
	refraction index More...

SLbool	_getsShadows
	true if shadows are visible on this material More...

SLGLProgram *	_program {}
	pointer to a GLSL shader program More...

SLGLProgram *	_programTF {}
	pointer to a GLSL shader program for transformFeedback More...

SLint	_numTextures
	number of textures in all _textures vectors array More...

SLSkybox *	_skybox
	pointer to the skybox More...

SLParticleSystem *	_ps
	pointer to a particle system More...

SLVGLTexture	_textures [TT_numTextureType]
	array of texture vectors one for each type More...

SLVGLTexture	_textures3d
	texture vector for diffuse 3D textures More...

SLGLTexture *	_errorTexture = nullptr
	pointer to error texture that is shown if another texture fails More...

SLstring	_compileErrorTexFilePath
	path to the error texture More...

SLVNode	_nodesVisible2D
	Vector of all visible 2D nodes of with this material. More...

SLVNode	_nodesVisible3D
	Vector of all visible 3D nodes of with this material. More...

Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...

SLstring	_url
	uniform resource locator More...

Detailed Description

Defines a standard CG material with textures and a shader program.

The SLMaterial class defines a material with either the Blinn-Phong (default) or the Cook-Torrance reflection) model.

In the Blinn-Phong reflection model the following parameters get used:
The ambient, diffuse, specular and emissive color as well as the shininess parameter as shininess exponent. Instead of the diffuse color a texture of type TT_diffuse can be used.
In the Cook-Torrance reflection model only the diffuse color and the roughness and metallic parameter are used. All parameters can be provided also as a texture of the appropriate type. This reflection model corresponds to the Physically Based Rendering (PBR) material model.
In addition it has coefficients for reflectivity (kr), transparency (kt) and refraction index (kn) that can be used in special shaders and ray tracing.
A material has an array of empty vectors of SLGLTexture pointers. One for each SLTextureType.
The shading has to be implemented in the GLSL program (SLGLProgram) with a vertex and fragment shader. If no SLGLProgram is assigned, a pair of shaders (a vertex and fragment shader) gets automatically generated according to the reflection model and the material parameters. See SLGLProgramGenerated for more details.

Remarks: It is important that during instantiation NO OpenGL functions (gl*) get called because this constructor will be most probably called in a parallel thread from within an SLScene::registerAssetsToLoad or SLScene::assemble function. All objects that get rendered have to do their OpenGL initialization when they are used the first time during rendering in the main thread. For this material it means, that OpenGL shader programs in _programs and the textures in _textures do not get built until the first frame is rendered.

Definition at line 55 of file SLMaterial.h.

Constructor & Destructor Documentation

◆ SLMaterial() [1/7]

SLMaterial::SLMaterial	(	SLAssetManager *	am,
		const SLchar *	name,
		const SLCol4f &	amdi = `SLCol4f::WHITE`,
		const SLCol4f &	spec = `SLCol4f::WHITE`,
		SLfloat	shininess = `100.0f`,
		SLfloat	kr = `0.0`,
		SLfloat	kt = `0.0f`,
		SLfloat	kn = `1.0f`,
		SLGLProgram *	program = `nullptr`
	)

explicit

Default ctor for Blinn-Phong reflection model materials without textures.

Default constructor for Blinn-Phong reflection model materials without textures. Materials can be used by multiple meshes (SLMesh). Materials can belong therefore to the global assets such as meshes, materials, textures and shader programs.

Parameters

am	Pointer to a global asset manager. If passed the asset manager is the owner of the instance and will do the deallocation. If a nullptr is passed the creator is responsible for the deallocation.
name	Name of the material
amdi	Ambient and diffuse color
spec	Specular color
shininess	Shininess exponent (the higher the sharper the gloss)
kr	Reflection coefficient used for ray tracing. (0.0-1.0)
kt	Transparency coefficient used for ray tracing. (0.0-1.0)
kn	Refraction index used for ray tracing (1.0-2.5)
program	Pointer to the shader program for the material. If none is passed a program will be generated from the passed parameters.

Definition at line 37 of file SLMaterial.cpp.

                                                 : SLObject(name)
 {
     _assetManager    = am;
     _reflectionModel = RM_BlinnPhong;
     _ambient = _diffuse = amdi;
     _specular           = spec;
     _emissive.set(0, 0, 0, 0);
     _shininess    = shininess;
     _roughness    = 0.5f;
     _metalness    = 0.0f;
     _translucency = 0.0f;
     _getsShadows  = true;
     _program      = program;
     _skybox       = nullptr;
     _numTextures  = 0;
  
     _kr = kr;
     _kt = kt;
     _kn = kn;
  
     // sync the transparency coefficient with the alpha value or vice versa
     if (_kt > 0) _diffuse.w = 1.0f - _kt;
     if (_diffuse.w > 1) _kt = 1.0f - _diffuse.w;
  
     // Add pointer to the global resource vectors for deallocation
     if (am)
         am->materials().push_back(this);
 }

◆ SLMaterial() [2/7]

SLMaterial::SLMaterial	(	SLAssetManager *	am,
		const SLchar *	name,
		SLGLTexture *	texture1,
		SLGLTexture *	texture2 = `nullptr`,
		SLGLTexture *	texture3 = `nullptr`,
		SLGLTexture *	texture4 = `nullptr`,
		SLGLProgram *	program = `nullptr`
	)

Ctor for textured Blinn-Phong reflection model materials.

Constructor for textured Blinn-Phong reflection model materials. Materials can be used by multiple meshes (SLMesh). Materials can belong therefore to the global assets such as meshes, materials, textures and shader programs.

Parameters

am	Pointer to a global asset manager. If passed the asset manager is the owner of the instance and will do the deallocation. If a nullptr is passed the creator is responsible for the deallocation.
name	Name of the material
texture1	Pointer to an SLGLTexture of a specific SLTextureType
texture2	Pointer to an SLGLTexture of a specific SLTextureType
texture3	Pointer to an SLGLTexture of a specific SLTextureType
texture4	Pointer to an SLGLTexture of a specific SLTextureType
program	Pointer to the shader program for the material. If none is passed a program will be generated from the passed parameters.

Definition at line 89 of file SLMaterial.cpp.

                                                 : SLObject(name)
 {
     _assetManager    = am;
     _reflectionModel = RM_BlinnPhong;
     _ambient.set(1, 1, 1);
     _diffuse.set(1, 1, 1);
     _specular.set(1, 1, 1);
     _emissive.set(0, 0, 0, 0);
     _shininess    = 125;
     _roughness    = 0.5f;
     _metalness    = 0.0f;
     _translucency = 0.0f;
     _getsShadows  = true;
     _kr           = 0.0f;
     _kt           = 0.0f;
     _kn           = 1.0f;
     _diffuse.w    = 1.0f - _kt;
     _skybox       = nullptr;
     _program      = program;
  
     _numTextures = 0;
     addTexture(texture1);
     addTexture(texture2);
     addTexture(texture3);
     addTexture(texture4);
  
     if (_textures[TT_roughness].size() > 0 || _textures[TT_metallic].size() > 0)
         _reflectionModel = RM_CookTorrance;
  
     // Add pointer to the global resource vectors for deallocation
     if (am)
         am->materials().push_back(this);
 }

◆ SLMaterial() [3/7]

SLMaterial::SLMaterial	(	SLAssetManager *	am,
		const SLchar *	name,
		SLSkybox *	skybox,
		SLCol4f	diffuse,
		SLfloat	roughness,
		SLfloat	metalness,
		SLGLProgram *	program = `nullptr`
	)

Ctor for PBR material with Cook-Torrance material parameters.

Constructor for Cook-Torrance shaded materials with roughness and metalness. Materials can be used by multiple meshes (SLMesh). Materials can belong therefore to the global assets such as meshes, materials, textures and shader programs.

Parameters

am	Pointer to a global asset manager. If passed the asset manager is the owner of the instance and will do the deallocation. If a nullptr is passed the creator is responsible for the deallocation.
name	Name of the material
skybox	Pointer to the skybox if available
diffuse	Diffuse reflection color
roughness	Roughness (0.0-1.0)
metalness	Metalness (0.0-1.0)
program	Pointer to the shader program for the material. If none is passed a program will be generated from the passed parameters.

Definition at line 144 of file SLMaterial.cpp.

                                                 : SLObject(name)
 {
     _assetManager = am;
     _ambient.set(0, 0, 0); // not used in Cook-Torrance
     _diffuse = diffuse;
     _specular.set(1, 1, 1);                         // not used in Cook-Torrance
     _emissive.set(0, 0, 0, 0);                      // not used in Cook-Torrance
     _shininess       = (1.0f - roughness) * 500.0f; // not used in Cook-Torrance
     _roughness       = roughness;
     _metalness       = metalness;
     _numTextures     = 0;
     _getsShadows     = true;
     _reflectionModel = RM_CookTorrance;
     _skybox          = skybox;
     _program         = program;
  
     _kr = 0.0f;
     _kt = 0.0f;
     _kn = 1.0f;
  
     // Add pointer to the global resource vectors for deallocation
     if (am)
         am->materials().push_back(this);
 }

◆ SLMaterial() [4/7]

SLMaterial::SLMaterial	(	SLAssetManager *	am,
		const SLchar *	name,
		SLSkybox *	skybox,
		SLGLTexture *	texture1,
		SLGLTexture *	texture2 = `nullptr`,
		SLGLTexture *	texture3 = `nullptr`,
		SLGLTexture *	texture4 = `nullptr`,
		SLGLTexture *	texture5 = `nullptr`,
		SLGLProgram *	program = `nullptr`
	)

Ctor for PBR material with Cook-Torrance material textures.

Constructor for Cook-Torrance shaded materials with PBR textures. Materials can be used by multiple meshes (SLMesh). Materials can belong therefore to the global assets such as meshes, materials, textures and shader programs.

Parameters

am	Pointer to a global asset manager. If passed the asset manager is the owner of the instance and will do the deallocation. If a nullptr is passed the creator is responsible for the deallocation.
name	Name of the material
skybox	Pointer to the skybox if available. If the skybox is an HDR skybox it will influence the ambient and specular reflection.
texture1	Pointer to a SLGLTexture of a specific SLTextureType. For PBR materials this can be TT_diffuse, TT_normal, TT_roughness, TT_metallic and TT_occlusion.
texture2	Pointer to a SLGLTexture of a specific SLTextureType.
texture3	Pointer to a SLGLTexture of a specific SLTextureType.
texture4	Pointer to a SLGLTexture of a specific SLTextureType.
texture5	Pointer to a SLGLTexture of a specific SLTextureType.
program	Pointer to the shader program for the material. If none is passed a program will be generated from the passed parameters.

Definition at line 195 of file SLMaterial.cpp.

                                                 : SLObject(name)
 {
     _assetManager = am;
     _ambient.set(1, 1, 1);
     _diffuse.set(1, 1, 1);
     _specular.set(1, 1, 1);
     _emissive.set(0, 0, 0, 0);
     _shininess       = 125;
     _roughness       = 0.5f;
     _metalness       = 0.0f;
     _numTextures     = 0;
     _reflectionModel = RM_CookTorrance;
     _getsShadows     = true;
     _skybox          = skybox;
     _program         = program;
  
     addTexture(texture1);
     addTexture(texture2);
     addTexture(texture3);
     addTexture(texture4);
     addTexture(texture5);
  
     _kr        = 0.0f;
     _kt        = 0.0f;
     _kn        = 1.0f;
     _diffuse.w = 1.0f - _kt;
     _program   = nullptr;
  
     // Add pointer to the global resource vectors for deallocation
     if (am)
         am->materials().push_back(this);
 }

◆ SLMaterial() [5/7]

SLMaterial::SLMaterial	(	SLAssetManager *	am,
		const SLchar *	name,
		SLParticleSystem *	ps,
		SLGLTexture *	texture,
		SLGLProgram *	program = `nullptr`,
		SLGLProgram *	programTF = `nullptr`
	)

Ctor for Particle System material with one texture (Draw and update)

Constructor for textured particle system materials (Draw=. Materials can be used by multiple meshes (SLMesh). Materials can belong therefore to the global assets such as meshes, materials, textures and shader programs.

Parameters

am	Pointer to a global asset manager. If passed the asset manager is the owner of the instance and will do the deallocation. If a nullptr is passed the creator is responsible for the deallocation.
name	Name of the material
texture	Pointer to an SLGLTexture of a specific SLTextureType
ps	Pointer to the particle system for the material.
program	Pointer to the shader program for the material. If none is passed a program will be generated from the passed parameters.
programTF	Pointer to the shader program for Transform Feedback

Definition at line 250 of file SLMaterial.cpp.

                                                     : SLObject(name)
 {
     _assetManager    = am;
     _reflectionModel = RM_Particle;
     _getsShadows     = true; // Later for Particle System maybe
     _skybox          = nullptr;
     _ps              = ps;
     _program         = program;
     _programTF       = programTF;
  
     _numTextures = 0;
     addTexture(texture);
  
     // Add pointer to the global resource vectors for deallocation
     if (am)
         am->materials().push_back(this);
 }

◆ SLMaterial() [6/7]

SLMaterial::SLMaterial	(	SLAssetManager *	am,
		SLGLProgram *	colorUniformProgram,
		const SLCol4f &	uniformColor,
		const SLchar *	name = `(const char*)"Uniform color"`
	)

explicit

Ctor for uniform color material without lighting.

Constructor for uniform color material without lighting Materials can be used by multiple meshes (SLMesh). Materials can belong therefore to the global assets such as meshes, materials, textures and shader programs.

Parameters

am	Pointer to a global asset manager. If passed the asset manager is the owner of the instance and will do the deallocation. If a nullptr is passed the creator is responsible for the deallocation.
colorUniformProgram	Pointer to shader program for uniform coloring.
uniformColor	Color to apply
name	Name of the material

Definition at line 319 of file SLMaterial.cpp.

                                              : SLObject(name)
 {
     _assetManager    = am;
     _reflectionModel = RM_Custom;
     _ambient.set(0, 0, 0);
     _diffuse = uniformColor;
     _specular.set(0, 0, 0);
     _emissive.set(0, 0, 0, 0);
     _shininess    = 125;
     _roughness    = 0.5f;
     _metalness    = 0.0f;
     _translucency = 0.0f;
     _program      = colorUniformProgram;
     _skybox       = nullptr;
     _kr           = 0.0f;
     _kt           = 0.0f;
     _kn           = 1.0f;
     _getsShadows  = true;
     _numTextures  = 0;
  
     // Add pointer to the global resource vectors for deallocation
     if (am)
         am->materials().push_back(this);
 }

◆ SLMaterial() [7/7]

SLMaterial::SLMaterial	(	SLAssetManager *	am,
		const SLchar *	name,
		SLGLProgram *	shaderProg
	)

Ctor for only a program.

Constructor for materials with only a shader program. Materials can be used by multiple meshes (SLMesh). Materials can belong therefore to the global assets such as meshes, materials, textures and shader programs.

Parameters

am	Pointer to a global asset manager. If passed the asset manager is the owner of the instance and will do the deallocation. If a nullptr is passed the creator is responsible for the deallocation.
name	Name of the material
shaderProg	Pointer to the shader program for the material

Definition at line 283 of file SLMaterial.cpp.

                                                    : SLObject(name)
 {
     _assetManager    = am;
     _program         = shaderProg;
     _skybox          = nullptr;
     _reflectionModel = RM_BlinnPhong;
     _ambient.set(1, 1, 1);
     _diffuse.set(1, 1, 1);
     _specular.set(1, 1, 1);
     _emissive.set(0, 0, 0, 0);
     _shininess    = 125.0f;
     _roughness    = 0.0f;
     _metalness    = 0.0f;
     _translucency = 0.0f;
     _getsShadows  = true;
     _numTextures  = 0;
  
     // Add pointer to the global resource vectors for deallocation
     if (am)
         am->materials().push_back(this);
 }

◆ ~SLMaterial()

SLMaterial::~SLMaterial ( )

override

The destructor should be called by the owner of the material. If an asset manager was passed in the constructor it will do it after scene destruction. The textures (SLGLTexture) and the shader program (SLGLProgram) that the material uses will not be deallocated.

Definition at line 367 of file SLMaterial.cpp.

 {
     if (_errorTexture)
     {
         delete _errorTexture;
         _errorTexture = nullptr;
     }
 }

Member Function Documentation

◆ activate()

void SLMaterial::activate	(	SLCamera *	cam,
		SLVLight *	lights,
		SLbool	supportGPUSkinning
	)

SLMaterial::activate activates this material for rendering if it is not yet the active one and set as SLGLState::currentMaterial. If this material has not yet a shader program assigned (SLMaterial::_program) a suitable program will be generated with an instance of SLGLProgramGenerated. At the end the shader program will begin its usage with SLGLProgram::beginUse.

Parameters

cam	Pointer to the active camera
lights	Pointer to the scene vector of lights
supportsSkinning	flag if skinning in shader should be supported

Definition at line 507 of file SLMaterial.cpp.

 {
     SLGLState* stateGL = SLGLState::instance();
  
     if (stateGL->currentMaterial() == this &&
         stateGL->currentMaterial()->program())
         return;
  
     // Deactivate shader program of the current active material
     if (stateGL->currentMaterial() && stateGL->currentMaterial()->program())
         stateGL->currentMaterial()->program()->endShader();
  
     // Set this material as the current material
     stateGL->currentMaterial(this);
  
     // If no shader program is attached add a generated shader program
     // A 3D object can be stored without material or shader program information.
     if (!_program)
     {
         // Check first the asset manager if the requested program type already exists
         string programName;
         SLGLProgramGenerated::buildProgramName(this,
                                                lights,
                                                supportGPUSkinning,
                                                programName);
         _program = _assetManager->getProgramByName(programName);
  
         // If the program was not found by name generate a new one
         if (!_program)
             _program = new SLGLProgramGenerated(_assetManager,
                                                 programName,
                                                 this,
                                                 lights,
                                                 supportGPUSkinning);
     }
  
     // Check if shader had a compile error and the error texture should be shown
     if (_program && _program->name().find("ErrorTex") != string::npos)
     {
         for (int i = 0; i < TT_numTextureType; i++)
             _textures[i].clear();
         if (!_errorTexture && !_compileErrorTexFilePath.empty())
             _errorTexture = new SLGLTexture(nullptr, _compileErrorTexFilePath);
         _textures[TT_diffuse].push_back(_errorTexture);
     }
  
     // Activate the shader program now
     _program->beginUse(cam, this, lights);
 }

◆ addTexture()

void SLMaterial::addTexture ( SLGLTexture * texture )

Adds the passed texture to the equivalent texture type vector.

Definition at line 348 of file SLMaterial.cpp.

 {
     if (!texture)
         return;
  
     if (texture->target() == GL_TEXTURE_3D)
         _textures3d.push_back(texture);
  
     _textures[texture->texType()].push_back(texture);
  
     _numTextures++;
 }

◆ ambient() [1/2]

SLCol4f SLMaterial::ambient ( )

inline

Definition at line 213 of file SLMaterial.h.

213 { return _ambient; }

◆ ambient() [2/2]

void SLMaterial::ambient ( const SLCol4f & ambi )

inline

Definition at line 170 of file SLMaterial.h.

170 { _ambient = ambi; }

◆ ambientDiffuse()

void SLMaterial::ambientDiffuse ( const SLCol4f & am_di )

inline

Definition at line 172 of file SLMaterial.h.

172 { _ambient = _diffuse = am_di; }

◆ assetManager() [1/2]

SLAssetManager* SLMaterial::assetManager ( )

inline

Definition at line 211 of file SLMaterial.h.

211 { return _assetManager; }

◆ assetManager() [2/2]

void SLMaterial::assetManager ( SLAssetManager * am )

inline

Definition at line 168 of file SLMaterial.h.

168 { _assetManager = am; }

◆ deleteDataGpu()

void SLMaterial::deleteDataGpu ( )

Definition at line 376 of file SLMaterial.cpp.

 {
     if (_program)
     {
         _assetManager->removeProgram(_program);
         _program->deleteDataGpu();
         delete _program;
         _program = nullptr;
     }
 }

◆ diffuse() [1/2]

SLCol4f SLMaterial::diffuse ( )

inline

Definition at line 214 of file SLMaterial.h.

214 { return _diffuse; }

◆ diffuse() [2/2]

void SLMaterial::diffuse ( const SLCol4f & diff )

inline

Definition at line 171 of file SLMaterial.h.

171 { _diffuse = diff; }

◆ emissive() [1/2]

SLCol4f SLMaterial::emissive ( )

inline

Definition at line 216 of file SLMaterial.h.

216 { return _emissive; }

◆ emissive() [2/2]

void SLMaterial::emissive ( const SLCol4f & emis )

inline

Definition at line 174 of file SLMaterial.h.

174 { _emissive = emis; }

◆ generateProgramPS()

void SLMaterial::generateProgramPS ( bool drawInstanced = false )

If this material has not yet a shader program assigned (SLMaterial::_program) a suitable program will be generated with an instance of SLGLProgramGenerated.

Definition at line 391 of file SLMaterial.cpp.

 {
     // If no shader program is attached add a generated shader program
     // A 3D object can be stored without material or shader program information.
     if (!_program)
     {
         /////////////////////////////
         // Generate draw program
         /////////////////////////////
  
         // Check first the asset manager if the requested program type already exists
         string programNameDraw;
         SLGLProgramGenerated::buildProgramNamePS(this,
                                                  programNameDraw,
                                                  true,
                                                  drawInstanced);
         _program = _assetManager->getProgramByName(programNameDraw);
  
         // If the program was not found by name generate a new one
         if (!_program)
         {
             std::string geom = "";
             if (!drawInstanced)
                 geom = "Geom";
  
             _program = new SLGLProgramGenerated(_assetManager,
                                                 programNameDraw,
                                                 this,
                                                 true,
                                                 geom);
         }
     }
  
     if (!_programTF)
     {
         /////////////////////////////
         // Generate update program
         /////////////////////////////
  
         // Check first the asset manager if the requested programTF type already exists
         string programNameUpdate;
         SLGLProgramGenerated::buildProgramNamePS(this, programNameUpdate, false, drawInstanced);
         _programTF = _assetManager->getProgramByName(programNameUpdate);
         if (!_programTF)
         {
             _programTF = new SLGLProgramGenerated(_assetManager,
                                                   programNameUpdate,
                                                   this,
                                                   false);
  
             int                 countString = 3;
             vector<const char*> outputNames; // For transform feedback
             outputNames.push_back("tf_position");
             outputNames.push_back("tf_velocity");
             outputNames.push_back("tf_startTime");
             if (_ps->doAcc() || _ps->doGravity())
             {
                 outputNames.push_back("tf_initialVelocity");
                 countString++;
             }
             if (_ps->doRotation())
             {
                 outputNames.push_back("tf_rotation");
                 countString++;
             }
             if (_ps->doRotation() && _ps->doRotRange())
             {
                 outputNames.push_back("tf_angularVelo");
                 countString++;
             }
             if (_ps->doFlipBookTexture())
             {
                 outputNames.push_back("tf_texNum");
                 countString++;
             }
             if (_ps->doShape())
             {
                 outputNames.push_back("tf_initialPosition");
                 countString++;
             }
             _programTF->initTF(&outputNames[0], countString);
         }
     }
  
     // Check if shader had a compile error and the error texture should be shown
     if (_program && _program->name().find("ErrorTex") != string::npos)
     {
         for (int i = 0; i < TT_numTextureType; i++)
             _textures[i].clear();
         if (!_errorTexture && !_compileErrorTexFilePath.empty())
             _errorTexture = new SLGLTexture(nullptr,
                                             _compileErrorTexFilePath);
         _textures[TT_diffuse].push_back(_errorTexture);
     }
  
     if (_programTF && _programTF->name().find("ErrorTex") != string::npos)
     {
         for (int i = 0; i < TT_numTextureType; i++)
             _textures[i].clear();
         if (!_errorTexture && !_compileErrorTexFilePath.empty())
             _errorTexture = new SLGLTexture(nullptr,
                                             _compileErrorTexFilePath);
         _textures[TT_diffuse].push_back(_errorTexture);
     }
 }

◆ getsShadows() [1/2]

SLbool SLMaterial::getsShadows ( ) const

inline

Definition at line 225 of file SLMaterial.h.

225 { return _getsShadows; }

◆ getsShadows() [2/2]

void SLMaterial::getsShadows ( SLbool receivesShadows )

inline

Definition at line 204 of file SLMaterial.h.

204 { _getsShadows = receivesShadows; }

◆ has3DTexture()

SLbool SLMaterial::has3DTexture ( )

inline

Returns true if a material has a 3D texture.

Definition at line 139 of file SLMaterial.h.

     {
         return !_textures3d.empty();
     }

◆ hasAlpha()

SLbool SLMaterial::hasAlpha ( )

inline

Returns true if there is any transparency in diffuse alpha or textures.

Definition at line 125 of file SLMaterial.h.

     {
         if (_diffuse.a < 1.0)
             return true;
  
         for (int i = 0; i < _textures[TT_diffuse].size(); i++)
         {
             if (_textures[TT_diffuse][i]->hasAlpha())
                 return true;
         }
         return false;
     }

◆ hasTextureType()

SLbool SLMaterial::hasTextureType ( SLTextureType tt )

inline

Definition at line 149 of file SLMaterial.h.

     {
         return !_textures[tt].empty();
     }

◆ hasTextureTypeWithUVIndex()

SLbool SLMaterial::hasTextureTypeWithUVIndex	(	SLTextureType	tt,
		SLuint	texIndex,
		SLbyte	uvIndex
	)

inline

Definition at line 153 of file SLMaterial.h.

     {
         return (_textures[tt].size() > texIndex &&
                 _textures[tt][texIndex]->uvIndex() == uvIndex);
     }

◆ kn() [1/2]

SLfloat SLMaterial::kn ( ) const

inline

Definition at line 224 of file SLMaterial.h.

224 { return _kn; }

◆ kn() [2/2]

void SLMaterial::kn ( SLfloat kn )

inline

Definition at line 199 of file SLMaterial.h.

     {
         assert(kn >= 0.0f);
         _kn = kn;
     }

◆ kr() [1/2]

SLfloat SLMaterial::kr ( ) const

inline

Definition at line 222 of file SLMaterial.h.

222 { return _kr; }

◆ kr() [2/2]

void SLMaterial::kr ( SLfloat kr )

inline

Definition at line 184 of file SLMaterial.h.

     {
         if (kr < 0.0f) kr = 0.0f;
         if (kr > 1.0f) kr = 1.0f;
         _kr = kr;
     }

◆ kt() [1/2]

SLfloat SLMaterial::kt ( ) const

inline

Definition at line 223 of file SLMaterial.h.

223 { return _kt; }

◆ kt() [2/2]

void SLMaterial::kt ( SLfloat kt )

inline

Definition at line 190 of file SLMaterial.h.

     {
         if (kt < 0.0f) kt = 0.0f;
         if (kt > 1.0f) kt = 1.0f;
         _kt         = kt;
         _ambient.w  = 1.0f - kt;
         _diffuse.w  = 1.0f - kt;
         _specular.w = 1.0f - kt;
     }

◆ metalness() [1/2]

SLfloat SLMaterial::metalness ( ) const

inline

Definition at line 219 of file SLMaterial.h.

219 { return _metalness; }

◆ metalness() [2/2]

void SLMaterial::metalness ( SLfloat m )

inline

Definition at line 183 of file SLMaterial.h.

183 { _metalness = Utils::clamp(m, 0.0f, 1.0f); }

Utils::clamp

T clamp(T a, T min, T max)

Definition: Utils.h:253

◆ needsTangents()

SLbool SLMaterial::needsTangents ( )

inline

Definition at line 144 of file SLMaterial.h.

     {
         return !_textures[TT_normal].empty() &&
                _textures[TT_normal][0]->target() == GL_TEXTURE_2D;
     }

◆ nodesVisible2D()

SLVNode& SLMaterial::nodesVisible2D ( )

inline

Definition at line 231 of file SLMaterial.h.

231 { return _nodesVisible2D; }

SLMaterial::_nodesVisible2D

SLVNode _nodesVisible2D

Vector of all visible 2D nodes of with this material.

Definition: SLMaterial.h:269

◆ nodesVisible3D()

SLVNode& SLMaterial::nodesVisible3D ( )

inline

Definition at line 232 of file SLMaterial.h.

232 { return _nodesVisible3D; }

SLMaterial::_nodesVisible3D

SLVNode _nodesVisible3D

Vector of all visible 3D nodes of with this material.

Definition: SLMaterial.h:270

◆ numTextures()

SLuint SLMaterial::numTextures ( )

inline

Definition at line 226 of file SLMaterial.h.

226 { return _numTextures; }

◆ passToUniforms()

SLint SLMaterial::passToUniforms	(	SLGLProgram *	program,
		SLint	nextTexUnit
	)

Passes all material parameters as uniforms to the passed shader program.

Definition at line 560 of file SLMaterial.cpp.

 {
     assert(program && "SLMaterial::passToUniforms: No shader program set!");
  
     program->uniform4fv("u_matAmbi", 1, (SLfloat*)&_ambient);
     program->uniform4fv("u_matDiff", 1, (SLfloat*)&_diffuse);
     program->uniform4fv("u_matSpec", 1, (SLfloat*)&_specular);
     program->uniform4fv("u_matEmis", 1, (SLfloat*)&_emissive);
     program->uniform1f("u_matShin", _shininess);
     program->uniform1f("u_matRough", _roughness);
     program->uniform1f("u_matMetal", _metalness);
     program->uniform1f("u_matKr", _kr);
     program->uniform1f("u_matKt", _kt);
     program->uniform1f("u_matKn", _kn);
     program->uniform1i("u_matGetsShadows", _getsShadows);
     program->uniform1i("u_matHasTexture", _numTextures > 0 ? 1 : 0);
  
     // pass textures unit id to the sampler uniform
     for (SLuint i = 0; i < TT_numTextureType; i++)
     {
         int texNb = 0;
         for (SLGLTexture* texture : _textures[i])
         {
             SLchar name[100];
             texture->bindActive(nextTexUnit);
             switch (i)
             {
                 case TT_diffuse:
                 {
                     snprintf(name, sizeof(name), "u_matTextureDiffuse%d", texNb);
                     break;
                 }
                 case TT_specular:
                 {
                     snprintf(name, sizeof(name), "u_matTextureSpecular%d", texNb);
                     break;
                 }
                 case TT_normal:
                 {
                     snprintf(name, sizeof(name), "u_matTextureNormal%d", texNb);
                     break;
                 }
                 case TT_height:
                 {
                     snprintf(name, sizeof(name), "u_matTextureHeight%d", texNb);
                     break;
                 }
                 case TT_occlusion:
                 {
                     snprintf(name, sizeof(name), "u_matTextureOcclusion%d", texNb);
                     break;
                 }
                 case TT_roughness:
                 {
                     snprintf(name, sizeof(name), "u_matTextureRoughness%d", texNb);
                     break;
                 }
                 case TT_metallic:
                 {
                     snprintf(name, sizeof(name), "u_matTextureMetallic%d", texNb);
                     break;
                 }
                 case TT_roughMetal:
                 {
                     snprintf(name, sizeof(name), "u_matTextureRoughMetal%d", texNb);
                     break;
                 }
                 case TT_occluRoughMetal:
                 {
                     snprintf(name, sizeof(name), "u_matTextureOccluRoughMetal%d", texNb);
                     break;
                 }
                 case TT_emissive:
                 {
                     snprintf(name, sizeof(name), "u_matTextureEmissive%d", texNb);
                     break;
                 }
                 case TT_environmentCubemap:
                 {
                     snprintf(name, sizeof(name), "u_matTextureEnvCubemap%d", texNb);
                     break;
                 }
                 case TT_font:
                 {
                     snprintf(name, sizeof(name), "u_matTextureFont%d", texNb);
                     break;
                 }
                 default:
                 {
                     snprintf(name, sizeof(name), "u_matTextureDiffuse%d", texNb);
                     break;
                 }
             }
  
             if (program->uniform1i(name, nextTexUnit) < 0)
                 Utils::log("Material",
                            "texture name %s not found for program: %s",
                            name,
                            program->name().c_str());
  
             texNb++;
             nextTexUnit++;
         }
     }
  
     // Pass environment mapping uniforms from the skybox
     if (_skybox &&
         _skybox->irradianceCubemap() &&
         _skybox->roughnessCubemap() &&
         _skybox->brdfLutTexture())
     {
         if (program->uniform1i("u_skyIrradianceCubemap", nextTexUnit) >= 0)
             _skybox->irradianceCubemap()->bindActive(nextTexUnit++);
  
         if (program->uniform1i("u_skyRoughnessCubemap", nextTexUnit) >= 0)
             _skybox->roughnessCubemap()->bindActive(nextTexUnit++);
  
         if (program->uniform1i("u_skyBrdfLutTexture", nextTexUnit) >= 0)
             _skybox->brdfLutTexture()->bindActive(nextTexUnit++);
  
         program->uniform1f("u_skyExposure", _skybox->exposure());
     }
  
     return nextTexUnit;
 }

◆ program() [1/2]

SLGLProgram* SLMaterial::program ( )

inline

Definition at line 227 of file SLMaterial.h.

227 { return _program; }

◆ program() [2/2]

void SLMaterial::program ( SLGLProgram * sp )

inline

Definition at line 205 of file SLMaterial.h.

205 { _program = sp; }

◆ programTF() [1/2]

SLGLProgram* SLMaterial::programTF ( )

inline

Definition at line 228 of file SLMaterial.h.

228 { return _programTF; }

◆ programTF() [2/2]

void SLMaterial::programTF ( SLGLProgram * sp )

inline

Definition at line 206 of file SLMaterial.h.

206 { _programTF = sp; }

◆ ps() [1/2]

SLParticleSystem* SLMaterial::ps ( )

inline

Definition at line 230 of file SLMaterial.h.

230 { return _ps; }

◆ ps() [2/2]

void SLMaterial::ps ( SLParticleSystem * ps )

inline

Definition at line 208 of file SLMaterial.h.

208 { _ps = ps; }

◆ reflectionModel() [1/2]

SLReflectionModel SLMaterial::reflectionModel ( )

inline

Definition at line 212 of file SLMaterial.h.

212 { return _reflectionModel; }

◆ reflectionModel() [2/2]

void SLMaterial::reflectionModel ( SLReflectionModel rm )

inline

Definition at line 169 of file SLMaterial.h.

169 { _reflectionModel = rm; }

◆ removeTextureType()

void SLMaterial::removeTextureType ( SLTextureType tt )

inline

Definition at line 159 of file SLMaterial.h.

     {
         _numTextures -= (SLint)_textures[tt].size();
         _textures[tt].clear();
     }

◆ roughness() [1/2]

SLfloat SLMaterial::roughness ( ) const

inline

Definition at line 218 of file SLMaterial.h.

218 { return _roughness; }

◆ roughness() [2/2]

void SLMaterial::roughness ( SLfloat r )

inline

Definition at line 182 of file SLMaterial.h.

182 { _roughness = Utils::clamp(r, 0.0f, 1.0f); }

◆ shininess() [1/2]

SLfloat SLMaterial::shininess ( ) const

inline

Definition at line 217 of file SLMaterial.h.

217 { return _shininess; }

◆ shininess() [2/2]

void SLMaterial::shininess ( SLfloat shin )

inline

Definition at line 177 of file SLMaterial.h.

     {
         if (shin < 0.0f) shin = 0.0;
         _shininess = shin;
     }

◆ skybox() [1/2]

SLSkybox* SLMaterial::skybox ( )

inline

Definition at line 229 of file SLMaterial.h.

229 { return _skybox; }

◆ skybox() [2/2]

void SLMaterial::skybox ( SLSkybox * sb )

inline

Definition at line 207 of file SLMaterial.h.

207 { _skybox = sb; }

◆ specular() [1/2]

SLCol4f SLMaterial::specular ( )

inline

Definition at line 215 of file SLMaterial.h.

215 { return _specular; }

◆ specular() [2/2]

void SLMaterial::specular ( const SLCol4f & spec )

inline

Definition at line 173 of file SLMaterial.h.

173 { _specular = spec; }

◆ textures()

SLVGLTexture& SLMaterial::textures ( SLTextureType type )

inline

Definition at line 233 of file SLMaterial.h.

233 { return _textures[type]; }

◆ textures3d()

SLVGLTexture& SLMaterial::textures3d ( )

inline

Definition at line 234 of file SLMaterial.h.

234 { return _textures3d; }

◆ texturesString()

SLstring SLMaterial::texturesString ( )

Returns a unique string that represent all textures used.

Definition at line 687 of file SLMaterial.cpp.

 {
     SLstring texStr;
     for (SLuint iTT = 0; iTT < TT_numTextureType; ++iTT)
     {
         for (SLuint iT = 0; iT < _textures[iTT].size(); ++iT)
         {
             texStr += "-" +
                       _textures[iTT][iT]->typeShortName() +
                       std::to_string(iT) +
                       std::to_string(_textures[iTT][iT]->uvIndex());
         }
     }
     if (_skybox)
         texStr += "-Sky";
  
     return texStr;
 }

◆ translucency() [1/2]

SLfloat SLMaterial::translucency ( ) const

inline

Definition at line 221 of file SLMaterial.h.

221 { return _translucency; }

◆ translucency() [2/2]

void SLMaterial::translucency ( SLfloat transl )

inline

Definition at line 176 of file SLMaterial.h.

176 { _translucency = transl; }

◆ transmissive() [1/2]

SLCol4f SLMaterial::transmissive ( )

inline

Definition at line 220 of file SLMaterial.h.

220 { return _transmissive; }

SLMaterial::_transmissive

SLCol4f _transmissive

transmissive color (RGB reflection coefficients) for path tracing

Definition: SLMaterial.h:250

◆ transmissive() [2/2]

void SLMaterial::transmissive ( const SLCol4f & transm )

inline

Definition at line 175 of file SLMaterial.h.

175 { _transmissive = transm; }

◆ usesUVIndex()

SLbool SLMaterial::usesUVIndex ( SLbyte uvIndex )

Returns true if the specified uvIndex is used by one of the textures.

Definition at line 707 of file SLMaterial.cpp.

 {
     for (SLuint iTT = 0; iTT < TT_numTextureType; ++iTT)
     {
         for (SLuint iT = 0; iT < _textures[iTT].size(); ++iT)
         {
             if (_textures[iTT][iT]->uvIndex() == uvIndex)
                 return true;
         }
     }
     return false;
 }

Member Data Documentation

◆ _ambient

SLCol4f SLMaterial::_ambient

protected

ambient color (RGB reflection coefficients)

Definition at line 243 of file SLMaterial.h.

◆ _assetManager

SLAssetManager* SLMaterial::_assetManager

protected

pointer to the asset manager (the owner) if available

Definition at line 241 of file SLMaterial.h.

◆ _compileErrorTexFilePath

SLstring SLMaterial::_compileErrorTexFilePath

protected

path to the error texture

Definition at line 267 of file SLMaterial.h.

◆ _diffuse

SLCol4f SLMaterial::_diffuse

protected

diffuse color (RGB reflection coefficients)

Definition at line 244 of file SLMaterial.h.

◆ _emissive

SLCol4f SLMaterial::_emissive

protected

emissive color coefficients

Definition at line 246 of file SLMaterial.h.

◆ _errorTexture

SLGLTexture* SLMaterial::_errorTexture = nullptr

protected

pointer to error texture that is shown if another texture fails

Definition at line 266 of file SLMaterial.h.

◆ _getsShadows

SLbool SLMaterial::_getsShadows

protected

true if shadows are visible on this material

Definition at line 255 of file SLMaterial.h.

◆ _kn

SLfloat SLMaterial::_kn {}

protected

refraction index

Definition at line 254 of file SLMaterial.h.

◆ _kr

SLfloat SLMaterial::_kr {}

protected

reflection coefficient 0.0 - 1.0 used for ray and path tracing

Definition at line 252 of file SLMaterial.h.

◆ _kt

SLfloat SLMaterial::_kt {}

protected

transmission coefficient 0.0 - 1.0 used for ray and path tracing

Definition at line 253 of file SLMaterial.h.

◆ _metalness

SLfloat SLMaterial::_metalness

protected

metallic property (0-1) in Cook-Torrance model

Definition at line 249 of file SLMaterial.h.

◆ _nodesVisible2D

SLVNode SLMaterial::_nodesVisible2D

protected

Vector of all visible 2D nodes of with this material.

Definition at line 269 of file SLMaterial.h.

◆ _nodesVisible3D

SLVNode SLMaterial::_nodesVisible3D

protected

Vector of all visible 3D nodes of with this material.

Definition at line 270 of file SLMaterial.h.

◆ _numTextures

SLint SLMaterial::_numTextures

protected

number of textures in all _textures vectors array

Definition at line 258 of file SLMaterial.h.

◆ _program

SLGLProgram* SLMaterial::_program {}

protected

pointer to a GLSL shader program

Definition at line 256 of file SLMaterial.h.

◆ _programTF

SLGLProgram* SLMaterial::_programTF {}

protected

pointer to a GLSL shader program for transformFeedback

Definition at line 257 of file SLMaterial.h.

◆ _ps

SLParticleSystem* SLMaterial::_ps

protected

pointer to a particle system

Definition at line 262 of file SLMaterial.h.

◆ _reflectionModel

SLReflectionModel SLMaterial::_reflectionModel

protected

reflection model (RM_BlinnPhong or RM_CookTorrance)

Definition at line 242 of file SLMaterial.h.

◆ _roughness

SLfloat SLMaterial::_roughness

protected

roughness property (0-1) in Cook-Torrance model

Definition at line 248 of file SLMaterial.h.

◆ _shininess

SLfloat SLMaterial::_shininess

protected

shininess exponent in Blinn-Phong model

Definition at line 247 of file SLMaterial.h.

◆ _skybox

SLSkybox* SLMaterial::_skybox

protected

pointer to the skybox

Definition at line 259 of file SLMaterial.h.

◆ _specular

SLCol4f SLMaterial::_specular

protected

specular color (RGB reflection coefficients)

Definition at line 245 of file SLMaterial.h.

◆ _textures

SLVGLTexture SLMaterial::_textures[TT_numTextureType]

protected

array of texture vectors one for each type

Definition at line 264 of file SLMaterial.h.

◆ _textures3d

SLVGLTexture SLMaterial::_textures3d

protected

texture vector for diffuse 3D textures

Definition at line 265 of file SLMaterial.h.

◆ _translucency

SLfloat SLMaterial::_translucency

protected

translucency exponent for light refraction for path tracing

Definition at line 251 of file SLMaterial.h.

◆ _transmissive

SLCol4f SLMaterial::_transmissive

protected

transmissive color (RGB reflection coefficients) for path tracing

Definition at line 250 of file SLMaterial.h.

◆ K

SLfloat SLMaterial::K

static

PM: Constant of gloss calibration (slope of point light at dist 1)

Definition at line 237 of file SLMaterial.h.

◆ PERFECT

SLfloat SLMaterial::PERFECT = 1000.0f

static

PM: shininess/translucency limit.

Definition at line 238 of file SLMaterial.h.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Attributes

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SLMaterial() [1/7]

◆ SLMaterial() [2/7]

◆ SLMaterial() [3/7]

◆ SLMaterial() [4/7]

◆ SLMaterial() [5/7]

◆ SLMaterial() [6/7]

◆ SLMaterial() [7/7]

◆ ~SLMaterial()

Member Function Documentation

◆ activate()

◆ addTexture()

◆ ambient() [1/2]

◆ ambient() [2/2]

◆ ambientDiffuse()

◆ assetManager() [1/2]

◆ assetManager() [2/2]

◆ deleteDataGpu()

◆ diffuse() [1/2]

◆ diffuse() [2/2]

◆ emissive() [1/2]

◆ emissive() [2/2]

◆ generateProgramPS()

◆ getsShadows() [1/2]

◆ getsShadows() [2/2]

◆ has3DTexture()

◆ hasAlpha()

◆ hasTextureType()

◆ hasTextureTypeWithUVIndex()

◆ kn() [1/2]

◆ kn() [2/2]

◆ kr() [1/2]

◆ kr() [2/2]

◆ kt() [1/2]

◆ kt() [2/2]

◆ metalness() [1/2]

◆ metalness() [2/2]

◆ needsTangents()

◆ nodesVisible2D()

◆ nodesVisible3D()

◆ numTextures()

◆ passToUniforms()

◆ program() [1/2]

◆ program() [2/2]

◆ programTF() [1/2]

◆ programTF() [2/2]

◆ ps() [1/2]

◆ ps() [2/2]

◆ reflectionModel() [1/2]

◆ reflectionModel() [2/2]

◆ removeTextureType()

◆ roughness() [1/2]

◆ roughness() [2/2]

◆ shininess() [1/2]

◆ shininess() [2/2]

◆ skybox() [1/2]

◆ skybox() [2/2]

◆ specular() [1/2]

◆ specular() [2/2]

◆ textures()

◆ textures3d()

◆ texturesString()

◆ translucency() [1/2]

◆ translucency() [2/2]

◆ transmissive() [1/2]

◆ transmissive() [2/2]

◆ usesUVIndex()

Member Data Documentation

◆ _ambient

◆ _assetManager

◆ _compileErrorTexFilePath

◆ _diffuse

◆ _emissive

◆ _errorTexture

◆ _getsShadows

◆ _kn