Encapsulation of an OpenGL shader program object. More...

#include <SLGLProgram.h>

Inheritance diagram for SLGLProgram:

Public Member Functions
	SLGLProgram (SLAssetManager *am, const string &vertShaderFile, const string &fragShaderFile, const string &geomShaderFile="", const string &programName="")
	Ctor with a vertex and a fragment shader filename. More...

	~SLGLProgram () override

void	deleteDataGpu ()
	Delete all Gpu data. More...

void	addShader (SLGLShader *shader)
	SLGLProgram::addShader adds a shader to the shader list. More...

void	init (SLVLight *lights)

void	initTF (const char *writeBackAttrib[], int size)

virtual void	beginShader (SLCamera cam, SLMaterial mat, SLVLight *lights)=0
	starter for derived classes More...

virtual void	endShader ()=0

void	beginUse (SLCamera cam, SLMaterial mat, SLVLight *lights)

SLint	passLightsToUniforms (SLVLight *lights, SLuint nextTexUnit) const

void	endUse ()
	SLGLProgram::endUse stops the shader program. More...

void	useProgram ()

void	addUniform1f (SLGLUniform1f *u)
	add float uniform More...

void	addUniform1i (SLGLUniform1i *u)
	add int uniform More...

SLuint	progID () const

SLVGLShader &	shaders ()

SLint	getUniformLocation (const SLchar *name) const

SLint	uniform1f (const SLchar *name, SLfloat v0) const
	Passes the float value v0 to the uniform variable "name". More...

SLint	uniform2f (const SLchar *name, SLfloat v0, SLfloat v1) const
	Passes the float values v0 & v1 to the uniform variable "name". More...

SLint	uniform3f (const SLchar *name, SLfloat v0, SLfloat v1, SLfloat v2) const
	Passes the float values v0, v1 & v2 to the uniform variable "name". More...

SLint	uniform4f (const SLchar *name, SLfloat v0, SLfloat v1, SLfloat v2, SLfloat v3) const
	Passes the float values v0,v1,v2 & v3 to the uniform variable "name". More...

SLint	uniform1i (const SLchar *name, SLint v0) const
	Passes the int values v0 to the uniform variable "name". More...

SLint	uniform2i (const SLchar *name, SLint v0, SLint v1) const
	Passes the int values v0 & v1 to the uniform variable "name". More...

SLint	uniform3i (const SLchar *name, SLint v0, SLint v1, SLint v2) const
	Passes the int values v0, v1 & v2 to the uniform variable "name". More...

SLint	uniform4i (const SLchar *name, SLint v0, SLint v1, SLint v2, SLint v3) const
	Passes the int values v0, v1, v2 & v3 to the uniform variable "name". More...

SLint	uniform1fv (const SLchar name, SLsizei count, const SLfloat value) const
	Passes 1 float value py pointer to the uniform variable "name". More...

SLint	uniform2fv (const SLchar name, SLsizei count, const SLfloat value) const
	Passes 2 float values py pointer to the uniform variable "name". More...

SLint	uniform3fv (const SLchar name, SLsizei count, const SLfloat value) const
	Passes 3 float values py pointer to the uniform variable "name". More...

SLint	uniform4fv (const SLchar name, SLsizei count, const SLfloat value) const
	Passes 4 float values py pointer to the uniform variable "name". More...

SLint	uniform1iv (const SLchar name, SLsizei count, const SLint value) const
	Passes 1 int value py pointer to the uniform variable "name". More...

SLint	uniform2iv (const SLchar name, SLsizei count, const SLint value) const
	Passes 2 int values py pointer to the uniform variable "name". More...

SLint	uniform3iv (const SLchar name, SLsizei count, const SLint value) const
	Passes 3 int values py pointer to the uniform variable "name". More...

SLint	uniform4iv (const SLchar name, GLsizei count, const SLint value) const
	Passes 4 int values py pointer to the uniform variable "name". More...

SLint	uniformMatrix2fv (const SLchar name, SLsizei count, const SLfloat value, GLboolean transpose=false) const
	Passes a 2x2 float matrix values py pointer to the uniform variable "name". More...

void	uniformMatrix2fv (SLint loc, SLsizei count, const SLfloat *value, GLboolean transpose=false) const
	Passes a 2x2 float matrix values py pointer to the uniform at location loc. More...

SLint	uniformMatrix3fv (const SLchar name, SLsizei count, const SLfloat value, GLboolean transpose=false) const
	Passes a 3x3 float matrix values py pointer to the uniform variable "name". More...

void	uniformMatrix3fv (SLint loc, SLsizei count, const SLfloat *value, GLboolean transpose=false) const
	Passes a 3x3 float matrix values py pointer to the uniform at location loc. More...

SLint	uniformMatrix4fv (const SLchar name, SLsizei count, const SLfloat value, GLboolean transpose=false) const
	Passes a 4x4 float matrix values py pointer to the uniform variable "name". More...

void	uniformMatrix4fv (SLint loc, SLsizei count, const SLfloat *value, GLboolean transpose=false) const
	Passes a 4x4 float matrix values py pointer to the uniform at location loc. More...

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

Protected Attributes
SLuint	_progID
	OpenGL shader program object ID. More...

SLbool	_isLinked
	Flag if program is linked. More...

SLVGLShader	_shaders
	Vector of all shader objects. More...

SLVUniform1f	_uniforms1f
	Vector of uniform1f variables. More...

SLVUniform1i	_uniforms1i
	Vector of uniform1i variables. More...

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

SLstring	_url
	uniform resource locator More...

Detailed Description

Encapsulation of an OpenGL shader program object.

The SLGLProgram base class represents a shader program object of the OpenGL Shading Language (GLSL). Multiple SLGLShader objects can be attached and linked at run time. An SLGLProgram object can then be attached to an SLMaterial node for execution. An SLGLProgram object can hold an vector of uniform variable that can transfer variables from the CPU program to the GPU program. For more details on GLSL please refer to official GLSL documentation and to SLGLShader.
All shader files are located in the directory data/shaders. For OSX, iOS and Android applications they are copied to the appropriate file system locations.

Definition at line 55 of file SLGLProgram.h.

Constructor & Destructor Documentation

◆ SLGLProgram()

SLGLProgram::SLGLProgram	(	SLAssetManager *	am,
		const string &	vertShaderFile,
		const string &	fragShaderFile,
		const string &	geomShaderFile = `""`,
		const string &	programName = `""`
	)

Ctor with a vertex and a fragment shader filename.

Constructor for shader programs. Shader programs can be used in multiple materials and can belong therefore to the global assets such as meshes (SLMesh), materials (SLMaterial), textures (SLGLTexture) and shader programs (SLGLProgram).

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.
vertShaderFile	Name of the vertex shader file. If only a filename is passed it will be search on the SLGLProgram::defaultPath.
fragShaderFile	Name of the fragment shader file. If only a filename is passed it will be search on the SLGLProgram::defaultPath.
geomShaderFile	Name of the geometry shader file. If only a filename is passed it will be search on the SLGLProgram::defaultPath.
programName	existing program name to use

Definition at line 39 of file SLGLProgram.cpp.

                                                       : SLObject(programName)
 {
     _isLinked = false;
     _progID   = 0;
  
     // optional load vertex and/or fragment shaders
     addShader(new SLGLShader(vertShaderFile, ST_vertex));
     addShader(new SLGLShader(fragShaderFile, ST_fragment));
  
     if (!geomShaderFile.empty())
         addShader(new SLGLShader(geomShaderFile, ST_geometry));
  
     // Add pointer to the global resource vectors for deallocation
     if (am)
         am->programs().push_back(this);
 }

◆ ~SLGLProgram()

SLGLProgram::~SLGLProgram ( )

override

The destructor should be called by the owner of the shader program. If an asset manager was passed in the constructor it will do it after scene destruction. The destructor deletes all shader objects (SLGLShader) in the RAM as well as on the GPU.

Definition at line 66 of file SLGLProgram.cpp.

 {
     // SL_LOG("~SLGLProgram");
     for (auto shader : _shaders)
     {
         if (_isLinked)
         {
             glDetachShader(_progID, shader->_shaderID);
             GET_GL_ERROR;
         }
  
         // always delete shader objects before program object
         delete shader;
     }
     _isLinked = false;
  
     if (_progID > 0)
     {
         glDeleteProgram(_progID);
         GET_GL_ERROR;
     }
  
     // delete uniform variables
     for (auto uf : _uniforms1f)
         delete uf;
     for (auto ui : _uniforms1i)
         delete ui;
 }

Member Function Documentation

◆ addShader()

void SLGLProgram::addShader ( SLGLShader * shader )

SLGLProgram::addShader adds a shader to the shader list.

Definition at line 116 of file SLGLProgram.cpp.

 {
     assert(shader);
     _shaders.push_back(shader);
 }

◆ addUniform1f()

void SLGLProgram::addUniform1f ( SLGLUniform1f * u )

add float uniform

SLGLProgram::addUniform1f add a uniform variable to the list.

Definition at line 564 of file SLGLProgram.cpp.

 {
     _uniforms1f.push_back(u);
 }

◆ addUniform1i()

void SLGLProgram::addUniform1i ( SLGLUniform1i * u )

add int uniform

SLGLProgram::addUniform1f add a uniform variable to the list.

Definition at line 570 of file SLGLProgram.cpp.

 {
     _uniforms1i.push_back(u);
 }

◆ beginShader()

virtual void SLGLProgram::beginShader	(	SLCamera *	cam,
		SLMaterial *	mat,
		SLVLight *	lights
	)

pure virtual

starter for derived classes

Implemented in SLGLProgramGeneric, and SLGLProgramGenerated.

◆ beginUse()

void SLGLProgram::beginUse	(	SLCamera *	cam,
		SLMaterial *	mat,
		SLVLight *	lights
	)

SLGLProgram::beginUse starts using the shader program and transfers the the camera, lights and material parameter as uniform variables. It also passes the custom uniform variables of the _uniform1fList as well as the texture names.

Definition at line 334 of file SLGLProgram.cpp.

 {
     if (_progID == 0 && !_shaders.empty())
         init(lights);
  
     if (_isLinked)
     {
         SLGLState* stateGL = SLGLState::instance();
  
         stateGL->useProgram(_progID);
  
         SLint nextTexUnit = 0;
         if (lights)
             nextTexUnit = passLightsToUniforms(lights, nextTexUnit);
  
         if (mat)
             mat->passToUniforms(this, nextTexUnit);
  
         if (cam)
             cam->passToUniforms(this);
  
         for (auto* uf : _uniforms1f)
             uniform1f(uf->name(), uf->value());
  
         for (auto* ui : _uniforms1i)
             uniform1i(ui->name(), ui->value());
  
         GET_GL_ERROR;
     }
 }

◆ deleteDataGpu()

void SLGLProgram::deleteDataGpu ( )

Delete all Gpu data.

Definition at line 96 of file SLGLProgram.cpp.

 {
     if (_isLinked)
     {
         for (auto shader : _shaders)
         {
             glDetachShader(_progID, shader->_shaderID);
             GET_GL_ERROR;
         }
         _isLinked = false;
     }
  
     if (_progID > 0)
     {
         glDeleteProgram(_progID);
         GET_GL_ERROR;
     }
 }

◆ endShader()

virtual void SLGLProgram::endShader ( )

pure virtual

Implemented in SLGLProgramGeneric, and SLGLProgramGenerated.

◆ endUse()

void SLGLProgram::endUse ( )

SLGLProgram::endUse stops the shader program.

Definition at line 553 of file SLGLProgram.cpp.

 {
     SLGLState* stateGL = SLGLState::instance();
  
     // In core profile you must have an active program
     if (stateGL->glVersionNOf() > 3.0f) return;
  
     stateGL->useProgram(0);
 }

◆ getUniformLocation()

SLint SLGLProgram::getUniformLocation ( const SLchar * name ) const

Definition at line 575 of file SLGLProgram.cpp.

 {
     SLint loc = glGetUniformLocation(_progID, name);
     GET_GL_ERROR;
     return loc;
 }

◆ init()

void SLGLProgram::init ( SLVLight * lights )

SLGLProgram::init creates the OpenGL shader program object, compiles all shader objects and attaches them to the shader program. At the end all shaders are linked. If a shader fails to compile a simple texture only shader is compiled that shows an error message in the texture.

Definition at line 225 of file SLGLProgram.cpp.

 {
     // create program object if it doesn't exist
     if (!_progID)
         _progID = glCreateProgram();
  
     // if already linked, detach, recreate and compile shaders
     if (_isLinked)
     {
         for (auto* shader : _shaders)
         {
             if (_isLinked)
             {
                 glDetachShader(_progID, shader->_shaderID);
                 GET_GL_ERROR;
             }
         }
         _isLinked = false;
     }
  
     // compile all shader objects
     SLbool allSuccuessfullyCompiled = true;
     for (auto* shader : _shaders)
     {
         if (!shader->createAndCompile(lights))
         {
             allSuccuessfullyCompiled = false;
             break;
         }
         GET_GL_ERROR;
     }
  
     // try to compile alternative per vertex lighting shaders
     if (!allSuccuessfullyCompiled)
     {
         // delete all shaders and uniforms that where attached
         for (auto* sh : _shaders)
             delete sh;
         for (auto* uf : _uniforms1f)
             delete uf;
         for (auto* ui : _uniforms1i)
             delete ui;
  
         _shaders.clear();
         _uniforms1f.clear();
         _uniforms1i.clear();
     }
  
     // attach all shader objects
     if (allSuccuessfullyCompiled)
     {
         for (auto* shader : _shaders)
         {
             glAttachShader(_progID, shader->_shaderID);
             GET_GL_ERROR;
         }
     }
     else
     {
         SL_EXIT_MSG("No successfully compiled shaders attached!");
     }
  
     int linked = 0;
     glLinkProgram(_progID);
     GET_GL_ERROR;
     glGetProgramiv(_progID, GL_LINK_STATUS, &linked);
     GET_GL_ERROR;
  
     if (linked)
     {
         _isLinked = true;
  
         // if name is empty concatenate shader names
         if (_name.empty())
             for (auto* shader : _shaders)
                 _name += shader->name() + ", ";
     }
     else
     {
         SLchar log[256];
         glGetProgramInfoLog(_progID, sizeof(log), nullptr, &log[0]);
         SL_LOG("*** LINKER ERROR ***");
         SL_LOG("Source files: ");
         for (auto* shader : _shaders)
             SL_LOG("%s", shader->name().c_str());
         SL_LOG("ProgramInfoLog: %s", log);
         SL_EXIT_MSG("GLSL linker error");
     }
 }

◆ initTF()

void SLGLProgram::initTF	(	const char *	writeBackAttrib[],
		int	size
	)

SLGLProgram::initTF() initializes shader for transform feedback. Does not replace any code from the shader and assumes valid syntax for the shader used. Used for particle systems

Definition at line 126 of file SLGLProgram.cpp.

 {
     // create program object if it doesn't exist
     if (!_progID)
         _progID = glCreateProgram();
  
     // if already linked, detach, recreate and compile shaders
     if (_isLinked)
     {
         for (auto* shader : _shaders)
         {
             if (_isLinked)
             {
                 glDetachShader(_progID, shader->_shaderID);
                 GET_GL_ERROR;
             }
         }
         _isLinked = false;
     }
  
     // compile all shader objects
     SLbool allSuccuessfullyCompiled = true;
     for (auto* shader : _shaders)
     {
         if (!shader->createAndCompile(nullptr))
         {
             allSuccuessfullyCompiled = false;
             break;
         }
         GET_GL_ERROR;
     }
  
     // try to compile alternative per vertex lighting shaders
     if (!allSuccuessfullyCompiled)
     {
         // delete all shaders and uniforms that where attached
         for (auto* sh : _shaders)
             delete sh;
         for (auto* uf : _uniforms1f)
             delete uf;
         for (auto* ui : _uniforms1i)
             delete ui;
  
         _shaders.clear();
         _uniforms1f.clear();
         _uniforms1i.clear();
     }
  
     // attach all shader objects
     if (allSuccuessfullyCompiled)
     {
         for (auto* shader : _shaders)
         {
             glAttachShader(_progID, shader->_shaderID);
             GET_GL_ERROR;
         }
     }
     else
     {
         SL_EXIT_MSG("No successfully compiled shaders attached!");
     }
  
     int linked = 0;
     glTransformFeedbackVaryings(_progID,
                                 size,
                                 writeBackAttrib,
                                 GL_INTERLEAVED_ATTRIBS);
     glLinkProgram(_progID);
     GET_GL_ERROR;
     glGetProgramiv(_progID, GL_LINK_STATUS, &linked);
     GET_GL_ERROR;
  
     if (linked)
     {
         _isLinked = true;
  
         // if name is empty concatenate shader names
         if (_name.empty())
             for (auto* shader : _shaders)
                 _name += shader->name() + ", ";
     }
     else
     {
         SLchar log[256];
         glGetProgramInfoLog(_progID, sizeof(log), nullptr, &log[0]);
         SL_LOG("*** LINKER ERROR ***");
         SL_LOG("Source files: ");
         for (auto* shader : _shaders)
             SL_LOG("%s", shader->name().c_str());
         SL_LOG("ProgramInfoLog: %s", log);
         SL_EXIT_MSG("GLSL linker error");
     }
 }

◆ passLightsToUniforms()

SLint SLGLProgram::passLightsToUniforms	(	SLVLight *	lights,
		SLuint	nextTexUnit
	)		const

< flag if light is on

< position of light in world space

< position of light in view space

< ambient light intensity (Ia)

< diffuse light intensity (Id)

< specular light intensity (Is)

< spot direction in world space

< spot direction in view space

< spot cutoff angle 1-180 degrees

< cosine of spot cutoff angle

< spot exponent

< att. factor (const,linear,quadratic)

< flag if att. must be calculated

< flag if light creates shadows

< flag if percentage-closer filtering is enabled

< radius of area to sample

< shadow mapping min. bias at 0 deg.

< shadow mapping max. bias at 90 deg.

< flag if light has a cube shadow map

< projection matrix of the light

< pointers to depth-buffers for shadow mapping

< number of cascades for cascaded shadow mapping

Definition at line 367 of file SLGLProgram.cpp.

 {
     SLGLState* stateGL = SLGLState::instance();
  
     // Pass global lighting value
     uniform1f("u_oneOverGamma", SLLight::oneOverGamma());
     uniform4fv("u_globalAmbi", 1, (const SLfloat*)&SLLight::globalAmbient);
  
     if (!lights->empty())
     {
         SLMat4f viewRotMat(stateGL->viewMatrix);
         viewRotMat.translation(0, 0, 0); // delete translation part, only rotation needed
  
         // lighting parameter arrays
         SLint            lightIsOn[SL_MAX_LIGHTS];              //!< flag if light is on
         SLVec4f          lightPosWS[SL_MAX_LIGHTS];             //!< position of light in world space
         SLVec4f          lightPosVS[SL_MAX_LIGHTS];             //!< position of light in view space
         SLVec4f          lightAmbient[SL_MAX_LIGHTS];           //!< ambient light intensity (Ia)
         SLVec4f          lightDiffuse[SL_MAX_LIGHTS];           //!< diffuse light intensity (Id)
         SLVec4f          lightSpecular[SL_MAX_LIGHTS];          //!< specular light intensity (Is)
         SLVec3f          lightSpotDirWS[SL_MAX_LIGHTS];         //!< spot direction in world space
         SLVec3f          lightSpotDirVS[SL_MAX_LIGHTS];         //!< spot direction in view space
         SLfloat          lightSpotCutoff[SL_MAX_LIGHTS];        //!< spot cutoff angle 1-180 degrees
         SLfloat          lightSpotCosCut[SL_MAX_LIGHTS];        //!< cosine of spot cutoff angle
         SLfloat          lightSpotExp[SL_MAX_LIGHTS];           //!< spot exponent
         SLVec3f          lightAtt[SL_MAX_LIGHTS];               //!< att. factor (const,linear,quadratic)
         SLint            lightDoAtt[SL_MAX_LIGHTS];             //!< flag if att. must be calculated
         SLint            lightCreatesShadows[SL_MAX_LIGHTS];    //!< flag if light creates shadows
         SLint            lightDoSmoothShadows[SL_MAX_LIGHTS];   //!< flag if percentage-closer filtering is enabled
         SLuint           lightSmoothShadowLevel[SL_MAX_LIGHTS]; //!< radius of area to sample
         SLfloat          lightShadowMinBias[SL_MAX_LIGHTS];     //!< shadow mapping min. bias at 0 deg.
         SLfloat          lightShadowMaxBias[SL_MAX_LIGHTS];     //!< shadow mapping max. bias at 90 deg.
         SLint            lightUsesCubemap[SL_MAX_LIGHTS];       //!< flag if light has a cube shadow map
         SLMat4f          lightSpace[SL_MAX_LIGHTS * 6];         //!< projection matrix of the light
         SLGLDepthBuffer* lightShadowMap[SL_MAX_LIGHTS * 6];     //!< pointers to depth-buffers for shadow mapping
         SLint            lightNumCascades[SL_MAX_LIGHTS];       //!< number of cascades for cascaded shadow mapping
  
         // Init to defaults
         for (SLint i = 0; i < SL_MAX_LIGHTS; ++i)
         {
             lightIsOn[i]       = 0;
             lightPosWS[i]      = SLVec4f(0, 0, 1, 1);
             lightPosVS[i]      = SLVec4f(0, 0, 1, 1);
             lightAmbient[i]    = SLCol4f::BLACK;
             lightDiffuse[i]    = SLCol4f::BLACK;
             lightSpecular[i]   = SLCol4f::BLACK;
             lightSpotDirWS[i]  = SLVec3f(0, 0, -1);
             lightSpotDirVS[i]  = SLVec3f(0, 0, -1);
             lightSpotCutoff[i] = 180.0f;
             lightSpotCosCut[i] = cos(Utils::DEG2RAD * lightSpotCutoff[i]);
             lightSpotExp[i]    = 1.0f;
             lightAtt[i].set(1.0f, 0.0f, 0.0f);
             lightDoAtt[i] = 0;
             for (SLint ii = 0; ii < 6; ++ii)
             {
                 lightSpace[i * 6 + ii]     = SLMat4f();
                 lightShadowMap[i * 6 + ii] = nullptr;
             }
             lightCreatesShadows[i]    = 0;
             lightDoSmoothShadows[i]   = 0;
             lightSmoothShadowLevel[i] = 1;
             lightShadowMinBias[i]     = 0.001f;
             lightShadowMaxBias[i]     = 0.008f;
             lightUsesCubemap[i]       = 0;
             lightNumCascades[i]       = 0;
         }
  
         // Fill up light property vectors
         for (SLuint i = 0; i < lights->size(); ++i)
         {
             SLLight*     light     = lights->at(i);
             SLShadowMap* shadowMap = light->shadowMap();
  
             lightIsOn[i]              = light->isOn();
             lightPosWS[i]             = light->positionWS();
             lightPosVS[i]             = stateGL->viewMatrix * light->positionWS();
             lightAmbient[i]           = light->ambient();
             lightDiffuse[i]           = light->diffuse();
             lightSpecular[i]          = light->specular();
             lightSpotDirWS[i]         = light->spotDirWS();
             lightSpotDirVS[i]         = stateGL->viewMatrix.mat3() * light->spotDirWS();
             lightSpotCutoff[i]        = light->spotCutOffDEG();
             lightSpotCosCut[i]        = light->spotCosCut();
             lightSpotExp[i]           = light->spotExponent();
             lightAtt[i]               = SLVec3f(light->kc(), light->kl(), light->kq());
             lightDoAtt[i]             = light->isAttenuated();
             lightCreatesShadows[i]    = light->createsShadows();
             lightDoSmoothShadows[i]   = light->doSoftShadows();
             lightSmoothShadowLevel[i] = light->softShadowLevel();
             lightShadowMinBias[i]     = light->shadowMinBias();
             lightShadowMaxBias[i]     = light->shadowMaxBias();
             lightUsesCubemap[i]       = shadowMap && shadowMap->useCubemap() ? 1 : 0;
             lightNumCascades[i]       = shadowMap ? shadowMap->numCascades() : 0;
  
             if (shadowMap)
             {
                 int cascades = (int)shadowMap->depthBuffers().size();
  
                 for (SLint ls = 0; ls < 6; ++ls)
                 {
                     lightShadowMap[i * 6 + ls] = cascades > ls ? shadowMap->depthBuffers()[ls] : nullptr;
                     lightSpace[i * 6 + ls]     = shadowMap->lightSpace()[ls];
                 }
             }
         }
  
         // Pass vectors as uniform vectors
         auto  nL = (SLint)lights->size();
         SLint loc;
         loc = uniform1iv("u_lightIsOn", nL, (SLint*)&lightIsOn);
         loc = uniform4fv("u_lightPosWS", nL, (SLfloat*)&lightPosWS);
         loc = uniform4fv("u_lightPosVS", nL, (SLfloat*)&lightPosVS);
         loc = uniform4fv("u_lightAmbi", nL, (SLfloat*)&lightAmbient);
         loc = uniform4fv("u_lightDiff", nL, (SLfloat*)&lightDiffuse);
         loc = uniform4fv("u_lightSpec", nL, (SLfloat*)&lightSpecular);
         loc = uniform3fv("u_lightSpotDir", nL, (SLfloat*)&lightSpotDirVS);
         loc = uniform1fv("u_lightSpotDeg", nL, (SLfloat*)&lightSpotCutoff);
         loc = uniform1fv("u_lightSpotCos", nL, (SLfloat*)&lightSpotCosCut);
         loc = uniform1fv("u_lightSpotExp", nL, (SLfloat*)&lightSpotExp);
         loc = uniform3fv("u_lightAtt", nL, (SLfloat*)&lightAtt);
         loc = uniform1iv("u_lightDoAtt", nL, (SLint*)&lightDoAtt);
         loc = uniform1iv("u_lightCreatesShadows", nL, (SLint*)&lightCreatesShadows);
         loc = uniform1iv("u_lightDoSmoothShadows", nL, (SLint*)&lightDoSmoothShadows);
         loc = uniform1iv("u_lightSmoothShadowLevel", nL, (SLint*)&lightSmoothShadowLevel);
         loc = uniform1iv("u_lightUsesCubemap", nL, (SLint*)&lightUsesCubemap);
         loc = uniform1fv("u_lightShadowMinBias", nL, (SLfloat*)&lightShadowMinBias);
         loc = uniform1fv("u_lightShadowMaxBias", nL, (SLfloat*)&lightShadowMaxBias);
         loc = uniform1iv("u_lightNumCascades", nL, (SLint*)&lightNumCascades);
  
         for (int i = 0; i < SL_MAX_LIGHTS; ++i)
         {
             if (lightCreatesShadows[i])
             {
                 if (lightNumCascades[i])
                 {
                     SLstring uniformSm;
  
                     uniformSm = ("u_cascadesFactor_" + std::to_string(i));
                     loc       = uniform1f(uniformSm.c_str(), lights->at(i)->shadowMap()->cascadesFactor());
                     uniformSm = ("u_lightSpace_" + std::to_string(i));
                     loc       = uniformMatrix4fv(uniformSm.c_str(), lightNumCascades[i], (SLfloat*)(lightSpace + (i * 6)));
                     for (int j = 0; j < lightNumCascades[i]; j++)
                     {
                         uniformSm = "u_cascadedShadowMap_" + std::to_string(i) + "_" + std::to_string(j);
                         if ((loc = getUniformLocation(uniformSm.c_str())) >= 0)
                         {
                             lightShadowMap[i * 6 + j]->bindActive(nextTexUnit);
                             glUniform1i(loc, nextTexUnit);
                             nextTexUnit++;
                         }
                     }
                 }
                 else
                 {
                     SLstring uniformSm;
  
                     if (lightUsesCubemap[i])
                     {
                         uniformSm = ("u_lightSpace_" + std::to_string(i));
                         loc       = uniformMatrix4fv(uniformSm.c_str(), 6, (SLfloat*)(lightSpace + (i * 6)));
                         uniformSm = "u_shadowMapCube_" + std::to_string(i);
                     }
                     else
                     {
                         uniformSm = ("u_lightSpace_" + std::to_string(i));
                         loc       = uniformMatrix4fv(uniformSm.c_str(), 1, (SLfloat*)(lightSpace + (i * 6)));
                         uniformSm = "u_shadowMap_" + std::to_string(i);
                     }
  
                     if ((loc = getUniformLocation(uniformSm.c_str())) >= 0)
                     {
                         lightShadowMap[i * 6]->bindActive(nextTexUnit);
                         glUniform1i(loc, nextTexUnit);
                         nextTexUnit++;
                     }
                 }
             }
         }
  
         loc = uniform1i("u_lightsDoColoredShadows", (SLint)SLLight::doColoredShadows);
     }
     return nextTexUnit;
 }

◆ progID()

SLuint SLGLProgram::progID ( ) const

inline

Definition at line 88 of file SLGLProgram.h.

88 { return _progID; }

◆ shaders()

SLVGLShader& SLGLProgram::shaders ( )

inline

Definition at line 89 of file SLGLProgram.h.

89 { return _shaders; }

◆ uniform1f()

SLint SLGLProgram::uniform1f	(	const SLchar *	name,
		SLfloat	v0
	)		const

Passes the float value v0 to the uniform variable "name".

Definition at line 583 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform1f(loc, v0);
     return loc;
 }

◆ uniform1fv()

SLint SLGLProgram::uniform1fv	(	const SLchar *	name,
		SLsizei	count,
		const SLfloat *	value
	)		const

Passes 1 float value py pointer to the uniform variable "name".

Definition at line 666 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform1fv(loc, count, value);
     return loc;
 }

◆ uniform1i()

SLint SLGLProgram::uniform1i	(	const SLchar *	name,
		SLint	v0
	)		const

Passes the int values v0 to the uniform variable "name".

Definition at line 624 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform1i(loc, v0);
     return loc;
 }

◆ uniform1iv()

SLint SLGLProgram::uniform1iv	(	const SLchar *	name,
		SLsizei	count,
		const SLint *	value
	)		const

Passes 1 int value py pointer to the uniform variable "name".

Definition at line 707 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform1iv(loc, count, value);
     return loc;
 }

◆ uniform2f()

SLint SLGLProgram::uniform2f	(	const SLchar *	name,
		SLfloat	v0,
		SLfloat	v1
	)		const

Passes the float values v0 & v1 to the uniform variable "name".

Definition at line 591 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform2f(loc, v0, v1);
     return loc;
 }

◆ uniform2fv()

SLint SLGLProgram::uniform2fv	(	const SLchar *	name,
		SLsizei	count,
		const SLfloat *	value
	)		const

Passes 2 float values py pointer to the uniform variable "name".

Definition at line 676 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform2fv(loc, count, value);
     return loc;
 }

◆ uniform2i()

SLint SLGLProgram::uniform2i	(	const SLchar *	name,
		SLint	v0,
		SLint	v1
	)		const

Passes the int values v0 & v1 to the uniform variable "name".

Definition at line 632 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform2i(loc, v0, v1);
     return loc;
 }

◆ uniform2iv()

SLint SLGLProgram::uniform2iv	(	const SLchar *	name,
		SLsizei	count,
		const SLint *	value
	)		const

Passes 2 int values py pointer to the uniform variable "name".

Definition at line 717 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform2iv(loc, count, value);
     return loc;
 }

◆ uniform3f()

SLint SLGLProgram::uniform3f	(	const SLchar *	name,
		SLfloat	v0,
		SLfloat	v1,
		SLfloat	v2
	)		const

Passes the float values v0, v1 & v2 to the uniform variable "name".

Definition at line 601 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform3f(loc, v0, v1, v2);
     return loc;
 }

◆ uniform3fv()

SLint SLGLProgram::uniform3fv	(	const SLchar *	name,
		SLsizei	count,
		const SLfloat *	value
	)		const

Passes 3 float values py pointer to the uniform variable "name".

Definition at line 686 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc == -1) return false;
     glUniform3fv(loc, count, value);
     return loc;
 }

◆ uniform3i()

SLint SLGLProgram::uniform3i	(	const SLchar *	name,
		SLint	v0,
		SLint	v1,
		SLint	v2
	)		const

Passes the int values v0, v1 & v2 to the uniform variable "name".

Definition at line 642 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform3i(loc, v0, v1, v2);
     return loc;
 }

◆ uniform3iv()

SLint SLGLProgram::uniform3iv	(	const SLchar *	name,
		SLsizei	count,
		const SLint *	value
	)		const

Passes 3 int values py pointer to the uniform variable "name".

Definition at line 727 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform3iv(loc, count, value);
     return loc;
 }

◆ uniform4f()

SLint SLGLProgram::uniform4f	(	const SLchar *	name,
		SLfloat	v0,
		SLfloat	v1,
		SLfloat	v2,
		SLfloat	v3
	)		const

Passes the float values v0,v1,v2 & v3 to the uniform variable "name".

Definition at line 612 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform4f(loc, v0, v1, v2, v3);
     return loc;
 }

◆ uniform4fv()

SLint SLGLProgram::uniform4fv	(	const SLchar *	name,
		SLsizei	count,
		const SLfloat *	value
	)		const

Passes 4 float values py pointer to the uniform variable "name".

Definition at line 697 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform4fv(loc, count, value);
     return loc;
 }

◆ uniform4i()

SLint SLGLProgram::uniform4i	(	const SLchar *	name,
		SLint	v0,
		SLint	v1,
		SLint	v2,
		SLint	v3
	)		const

Passes the int values v0, v1, v2 & v3 to the uniform variable "name".

Definition at line 653 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc == -1) return false;
     glUniform4i(loc, v0, v1, v2, v3);
     return loc;
 }

◆ uniform4iv()

SLint SLGLProgram::uniform4iv	(	const SLchar *	name,
		GLsizei	count,
		const SLint *	value
	)		const

Passes 4 int values py pointer to the uniform variable "name".

Definition at line 737 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniform4iv(loc, count, value);
     return loc;
 }

◆ uniformMatrix2fv() [1/2]

SLint SLGLProgram::uniformMatrix2fv	(	const SLchar *	name,
		SLsizei	count,
		const SLfloat *	value,
		GLboolean	transpose = `false`
	)		const

Passes a 2x2 float matrix values py pointer to the uniform variable "name".

Definition at line 747 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniformMatrix2fv(loc, count, transpose, value);
     return loc;
 }

◆ uniformMatrix2fv() [2/2]

void SLGLProgram::uniformMatrix2fv	(	SLint	loc,
		SLsizei	count,
		const SLfloat *	value,
		GLboolean	transpose = `false`
	)		const

Passes a 2x2 float matrix values py pointer to the uniform at location loc.

Definition at line 758 of file SLGLProgram.cpp.

 {
     glUniformMatrix2fv(loc, count, transpose, value);
 }

◆ uniformMatrix3fv() [1/2]

SLint SLGLProgram::uniformMatrix3fv	(	const SLchar *	name,
		SLsizei	count,
		const SLfloat *	value,
		GLboolean	transpose = `false`
	)		const

Passes a 3x3 float matrix values py pointer to the uniform variable "name".

Definition at line 767 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniformMatrix3fv(loc, count, transpose, value);
     return loc;
 }

◆ uniformMatrix3fv() [2/2]

void SLGLProgram::uniformMatrix3fv	(	SLint	loc,
		SLsizei	count,
		const SLfloat *	value,
		GLboolean	transpose = `false`
	)		const

Passes a 3x3 float matrix values py pointer to the uniform at location loc.

Definition at line 778 of file SLGLProgram.cpp.

 {
     glUniformMatrix3fv(loc, count, transpose, value);
 }

◆ uniformMatrix4fv() [1/2]

SLint SLGLProgram::uniformMatrix4fv	(	const SLchar *	name,
		SLsizei	count,
		const SLfloat *	value,
		GLboolean	transpose = `false`
	)		const

Passes a 4x4 float matrix values py pointer to the uniform variable "name".

Definition at line 787 of file SLGLProgram.cpp.

 {
     SLint loc = getUniformLocation(name);
     if (loc >= 0) glUniformMatrix4fv(loc, count, transpose, value);
     return loc;
 }

◆ uniformMatrix4fv() [2/2]

void SLGLProgram::uniformMatrix4fv	(	SLint	loc,
		SLsizei	count,
		const SLfloat *	value,
		GLboolean	transpose = `false`
	)		const

Passes a 4x4 float matrix values py pointer to the uniform at location loc.

Definition at line 798 of file SLGLProgram.cpp.

 {
     glUniformMatrix4fv(loc, count, transpose, value);
 }

◆ useProgram()

void SLGLProgram::useProgram ( )

SLGLProgram::useProgram inits the first time the program and then uses it. Call this initialization if you pass your own custom uniform variables.

Definition at line 318 of file SLGLProgram.cpp.

 {
     if (_progID == 0 && !_shaders.empty())
         init(nullptr);
  
     if (_isLinked)
     {
         SLGLState::instance()->useProgram(_progID);
         GET_GL_ERROR;
     }
 }

Member Data Documentation

◆ _isLinked

SLbool SLGLProgram::_isLinked

protected

Flag if program is linked.

Definition at line 142 of file SLGLProgram.h.

◆ _progID

SLuint SLGLProgram::_progID

protected

OpenGL shader program object ID.

Definition at line 141 of file SLGLProgram.h.

◆ _shaders

SLVGLShader SLGLProgram::_shaders

protected

Vector of all shader objects.

Definition at line 143 of file SLGLProgram.h.

◆ _uniforms1f

SLVUniform1f SLGLProgram::_uniforms1f

protected

Vector of uniform1f variables.

Definition at line 144 of file SLGLProgram.h.

◆ _uniforms1i

SLVUniform1i SLGLProgram::_uniforms1i

protected

Vector of uniform1i variables.

Definition at line 145 of file SLGLProgram.h.

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

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SLGLProgram()

◆ ~SLGLProgram()

Member Function Documentation

◆ addShader()

◆ addUniform1f()

◆ addUniform1i()

◆ beginShader()

◆ beginUse()

◆ deleteDataGpu()

◆ endShader()

◆ endUse()

◆ getUniformLocation()

◆ init()

◆ initTF()

◆ passLightsToUniforms()

◆ progID()

◆ shaders()

◆ uniform1f()

◆ uniform1fv()

◆ uniform1i()

◆ uniform1iv()

◆ uniform2f()

◆ uniform2fv()

◆ uniform2i()

◆ uniform2iv()

◆ uniform3f()

◆ uniform3fv()

◆ uniform3i()

◆ uniform3iv()

◆ uniform4f()

◆ uniform4fv()

◆ uniform4i()

◆ uniform4iv()

◆ uniformMatrix2fv() [1/2]

◆ uniformMatrix2fv() [2/2]

◆ uniformMatrix3fv() [1/2]

◆ uniformMatrix3fv() [2/2]

◆ uniformMatrix4fv() [1/2]

◆ uniformMatrix4fv() [2/2]

◆ useProgram()

Member Data Documentation

◆ _isLinked

◆ _progID

◆ _shaders

◆ _uniforms1f

◆ _uniforms1i