SLGLProgramGenerated Class Reference

Generated Shader Program class inherited from SLGLProgram. More...

#include <SLGLProgramGenerated.h>

Inheritance diagram for SLGLProgramGenerated:

Public Member Functions
	~SLGLProgramGenerated () override=default
	SLGLProgramGenerated (SLAssetManager *am, const string &programName, SLMaterial *mat, SLVLight *lights, SLbool supportGPUSkinning)
	ctor for generated shader program More...
	SLGLProgramGenerated (SLAssetManager *am, const string &programName, SLMaterial *mat, bool isDrawProg, SLstring geomShader="")
	ctor for generated shader program PS More...
void	buildProgramCodePS (SLMaterial *mat, bool isDrawProg, bool drawInstanced=false)
void	buildProgramCode (SLMaterial *mat, SLVLight *lights, SLbool supportGPUSkinning)
void	beginShader (SLCamera *cam, SLMaterial *mat, SLVLight *lights) override
	starter for derived classes More...
void	endShader () override
Public Member Functions inherited from 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. 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)
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

Static Public Member Functions
static bool	lightsDoShadowMapping (SLVLight *lights)
	Returns true if at least one of the light does shadow mapping. More...
static void	buildProgramName (SLMaterial *mat, SLVLight *lights, SLbool supportGPUSkinning, string &programName)
	Builds unique program name that identifies shader program. More...
static void	buildProgramNamePS (SLMaterial *mat, string &programName, bool isDrawProg, bool drawInstanced)

Private Member Functions
void	buildPerPixCook (SLMaterial *mat, SLVLight *lights, SLbool supportGPUSkinning)
void	buildPerPixBlinn (SLMaterial *mat, SLVLight *lights, SLbool supportGPUSkinning)
void	buildPerPixParticle (SLMaterial *mat)
void	buildPerPixParticleInstanced (SLMaterial *mat)
void	buildPerPixParticleUpdate (SLMaterial *mat)
void	buildPerPixVideoBkgdSm (SLVLight *lights)
	Assemble shaders for video on background. More...

Static Private Member Functions
static string	fragInput_u_lightSm (SLVLight *lights)
static string	fragInput_u_shadowMaps (SLVLight *lights)
static string	fragFunctionShadowTest (SLVLight *lights)
	Adds the core shadow mapping test routine depending on the lights. More...
static string	shaderHeader (int numLights)
	Adds shader header code. More...
static string	shaderHeader ()
	Adds shader header code. More...
static void	addCodeToShader (SLGLShader *shader, const string &code, const string &name)
	Add vertex shader code to the SLGLShader instance. More...
static void	setVariable (std::string &code, const std::string &name, const std::string &value)
	Sets a variable in the shader code. More...

Static Private Attributes
static string	generatedShaderPath

Additional Inherited Members
Protected Attributes inherited from SLGLProgram
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

Generated Shader Program class inherited from SLGLProgram.

An instance of this class generates the shader code on the fly at construction time based on the information of the passed material and lights vector. The generated program depends on the following parameters:

• mat->reflectionModel (Blinn-Phong or Cook-Torrance)
• mat->textures
• light->createsShadows
• active camera for the fog and projection parameters

The shader program gets a unique name with the following pattern:

 genCook-D00-N00-E00-O01-RM00-Sky-C4s
    |    |   |   |   |   |    |   |
    |    |   |   |   |   |    |   + Directional light w. 4 shadow cascades
    |    |   |   |   |   |    + Ambient light from skybox
    |    |   |   |   |   + Roughness-metallic map with index 0 and uv 0
    |    |   |   |   + Ambient Occlusion map with index 0 and uv 1
    |    |   |   + Emissive Map with index 0 and uv 0
    |    |   + Normal Map with index 0 and uv 0
    |    + Diffuse Texture Mapping with index 0 and uv 0
    + Cook-Torrance or Blinn-Phong lighting model

The above example is for a material with 5 textures and a scene with one light. The shader program is constructed when a material is for the first time activated (SLMaterial::activate) and it's program pointer is null. The old system of custom written GLSL shader program is still valid. At the end of SLMaterial::activate the generated vertex and fragment shader get compiled, linked and activated with the OpenGL functions in SLGLShader and SLGLProgram. After successful compilation the shader get exported into the applications config directory if they not yet exist there.

Definition at line 53 of file SLGLProgramGenerated.h.

Constructor & Destructor Documentation

~SLGLProgramGenerated()

SLGLProgramGenerated::~SLGLProgramGenerated ( )

overridedefault

SLGLProgramGenerated() [1/2]

SLGLProgramGenerated::SLGLProgramGenerated ( SLAssetManager *  am, const string &  programName, SLMaterial *  mat, SLVLight *  lights, SLbool  supportGPUSkinning  )

inline

ctor for generated shader program

Definition at line 59 of file SLGLProgramGenerated.h.

      : SLGLProgram(am,
                    "",
                    "",
                    "",
                    programName)
    {
        buildProgramCode(mat, lights, supportGPUSkinning);
    }

SLGLProgramGenerated() [2/2]

SLGLProgramGenerated::SLGLProgramGenerated ( SLAssetManager *  am, const string &  programName, SLMaterial *  mat, bool  isDrawProg, SLstring  geomShader = ""  )

inline

ctor for generated shader program PS

Definition at line 74 of file SLGLProgramGenerated.h.

      : SLGLProgram(am,
                    "",
                    "",
                    geomShader,
                    programName)
    {
 
        if (geomShader != "")
        {
            buildProgramCodePS(mat, isDrawProg, false);
        }
        else
        {
            buildProgramCodePS(mat, isDrawProg, true);
        }
    }

Member Function Documentation

addCodeToShader()

void SLGLProgramGenerated::addCodeToShader ( SLGLShader *  shader, const string &  code, const string &  name  )

staticprivate

Add vertex shader code to the SLGLShader instance.

Definition at line 2944 of file SLGLProgramGenerated.cpp.

{
 
#if defined(DEBUG) && defined(_DEBUG)
    shader->code(SLGLShader::removeComments(code));
#else
    shader->code(code);
#endif
    shader->name(name);
 
#ifndef SL_EMSCRIPTEN
    // Check if generatedShaderPath folder exists
    generatedShaderPath = SLGLProgramManager::configPath + "generatedShaders/";
    if (!Utils::dirExists(SLGLProgramManager::configPath))
        SL_EXIT_MSG("SLGLProgramGenerated::addCodeToShader: SLGLProgramManager::configPath not existing");
 
    if (!Utils::dirExists(generatedShaderPath))
    {
        bool dirCreated = Utils::makeDir(generatedShaderPath); // dirCreated is still false on MacOS after creation
        if (!Utils::dirExists(generatedShaderPath))
            SL_EXIT_MSG("SLGLProgramGenerated::addCodeToShader: Failed to created SLGLProgramManager::configPath/generatedShaders");
    }
 
    shader->file(generatedShaderPath + name);
#endif
}

beginShader()

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

inlineoverridevirtual

starter for derived classes

Implements SLGLProgram.

Definition at line 112 of file SLGLProgramGenerated.h.

                                                  { beginUse(cam, mat, lights); }

buildPerPixBlinn()

void SLGLProgramGenerated::buildPerPixBlinn ( SLMaterial *  mat, SLVLight *  lights, SLbool  supportGPUSkinning  )

private

Definition at line 2069 of file SLGLProgramGenerated.cpp.

{
    assert(mat && lights);
    assert(_shaders.size() > 1 &&
           _shaders[0]->type() == ST_vertex &&
           _shaders[1]->type() == ST_fragment);
 
    // Check what textures the material has
    bool Dm  = mat->hasTextureType(TT_diffuse);
    bool Nm  = mat->hasTextureType(TT_normal);
    bool Hm  = mat->hasTextureType(TT_height);
    bool Em  = mat->hasTextureType(TT_emissive);
    bool Om0 = mat->hasTextureTypeWithUVIndex(TT_occlusion, 0, 0);
    bool Om1 = mat->hasTextureTypeWithUVIndex(TT_occlusion, 0, 1);
    bool Sm  = lightsDoShadowMapping(lights);
    bool uv0 = mat->usesUVIndex(0);
    bool uv1 = mat->usesUVIndex(1);
 
    // Assemble vertex shader code
    string vertCode;
    vertCode += shaderHeader((int)lights->size());
 
    // Vertex shader inputs
    vertCode += vertInput_a_pn;
    if (uv0) vertCode += vertInput_a_uv0;
    if (uv1) vertCode += vertInput_a_uv1;
    if (Nm) vertCode += vertInput_a_tangent;
    if (supportGPUSkinning) vertCode += vertInput_a_skinning;
    vertCode += vertInput_u_matrices_all;
    if (Nm) vertCode += vertInput_u_lightNm;
    if (supportGPUSkinning) vertCode += vertInput_u_skinning;
 
    // Vertex shader outputs
    vertCode += vertOutput_v_P_VS;
    if (Sm) vertCode += vertOutput_v_P_WS;
    vertCode += vertOutput_v_N_VS;
    if (uv0) vertCode += vertOutput_v_uv0;
    if (uv1) vertCode += vertOutput_v_uv1;
    if (Nm) vertCode += vertOutput_v_lightVecTS;
 
    // Vertex shader main loop
    vertCode += main_Begin;
    if (supportGPUSkinning) vertCode += Nm ? vertMain_skinning_Nm : vertMain_skinning;
    vertCode += vertMain_v_P_VS;
    if (Sm) vertCode += vertMain_v_P_WS_Sm;
    vertCode += vertMain_v_N_VS;
    if (uv0) vertCode += vertMain_v_uv0;
    if (uv1) vertCode += vertMain_v_uv1;
    if (Nm) vertCode += vertMain_TBN_Nm;
    vertCode += vertMain_EndAll;
 
    // Vertex shader variables
    setVariable(vertCode, "localPosition", supportGPUSkinning ? "skinnedPosition" : "a_position");
    setVariable(vertCode, "localNormal", supportGPUSkinning ? "skinnedNormal" : "a_normal");
    if (Nm) setVariable(vertCode, "localTangent", supportGPUSkinning ? "skinnedTangent" : "a_tangent");
 
    addCodeToShader(_shaders[0], vertCode, _name + ".vert");
 
    // Assemble fragment shader code
    string fragCode;
    fragCode += shaderHeader((int)lights->size());
 
    // Fragment shader inputs
    fragCode += fragInput_v_P_VS;
    if (Sm) fragCode += fragInput_v_P_WS;
    fragCode += fragInput_v_N_VS;
    if (uv0) fragCode += fragInput_v_uv0;
    if (uv1) fragCode += fragInput_v_uv1;
    if (Nm) fragCode += fragInput_v_lightVecTS;
 
    // Fragment shader uniforms
    fragCode += fragInput_u_lightAll;
    fragCode += fragInput_u_matBlinnAll;
    if (Sm) fragCode += fragInput_u_lightSm(lights);
    if (Dm) fragCode += fragInput_u_matTexDm;
    if (Nm) fragCode += fragInput_u_matTexNm;
    if (Em) fragCode += fragInput_u_matTexEm;
    if (Om0 || Om1) fragCode += fragInput_u_matTexOm;
    if (Sm) fragCode += fragInput_u_matGetsSm;
    if (Sm) fragCode += fragInput_u_shadowMaps(lights);
    fragCode += fragInput_u_cam;
 
    // Fragment shader outputs
    fragCode += fragOutputs_o_fragColor;
 
    // Fragment shader functions
    fragCode += fragFunctionsLightingBlinnPhong;
    fragCode += fragFunctionFogBlend;
    fragCode += fragFunctionDoStereoSeparation;
    if (Sm) fragCode += fragFunctionShadowTest(lights);
    if (Sm) fragCode += fragFunctionDoColoredShadows;
 
    // Fragment shader main loop
    fragCode += main_Begin;
    fragCode += fragMain_0_Intensities;
    fragCode += Nm ? fragMain_1_EN_in_TS : fragMain_1_EN_in_VS;
    fragCode += Em ? fragMain_1_matEmis_Em : fragMain_1_matEmis;
 
    fragCode += Om0 ? fragMain_1_matOccl_Om0 : Om1 ? fragMain_1_matOccl_Om1
                                                   : fragMain_1_matOccl;
 
    fragCode += Nm && Sm ? fragMainBlinn_2_LightLoopNmSm : Nm ? fragMainBlinn_2_LightLoopNm
                                                         : Sm ? fragMainBlinn_2_LightLoopSm
                                                              : fragMainBlinn_2_LightLoop;
    fragCode += Dm ? fragMainBlinn_3_FragColorDm : fragMainBlinn_3_FragColor;
    if (Sm) fragCode += fragMain_4_ColoredShadows;
    fragCode += fragMain_5_FogGammaStereo;
 
    addCodeToShader(_shaders[1], fragCode, _name + ".frag");
}

buildPerPixCook()

void SLGLProgramGenerated::buildPerPixCook ( SLMaterial *  mat, SLVLight *  lights, SLbool  supportGPUSkinning  )

private

Definition at line 1935 of file SLGLProgramGenerated.cpp.

{
    assert(mat && lights);
    assert(_shaders.size() > 1 &&
           _shaders[0]->type() == ST_vertex &&
           _shaders[1]->type() == ST_fragment);
 
    // Check what textures the material has
    bool Dm   = mat->hasTextureType(TT_diffuse);
    bool Nm   = mat->hasTextureType(TT_normal);
    bool Hm   = mat->hasTextureType(TT_height);
    bool Rm   = mat->hasTextureType(TT_roughness);
    bool Mm   = mat->hasTextureType(TT_metallic);
    bool RMm  = mat->hasTextureType(TT_roughMetal);
    bool Em   = mat->hasTextureType(TT_emissive);
    bool Om0  = mat->hasTextureTypeWithUVIndex(TT_occlusion, 0, 0);
    bool Om1  = mat->hasTextureTypeWithUVIndex(TT_occlusion, 0, 1);
    bool ORMm = mat->hasTextureType(TT_occluRoughMetal);
    bool Vm   = mat->hasTextureType(TT_videoBkgd);
    bool Sm   = lightsDoShadowMapping(lights);
    bool uv0  = mat->usesUVIndex(0);
    bool uv1  = mat->usesUVIndex(1);
    bool sky  = mat->skybox() != nullptr;
 
    // Assemble vertex shader code
    string vertCode;
    vertCode += shaderHeader((int)lights->size());
 
    // Vertex shader inputs
    vertCode += vertInput_a_pn;
    if (uv0) vertCode += vertInput_a_uv0;
    if (uv1) vertCode += vertInput_a_uv1;
    if (Nm) vertCode += vertInput_a_tangent;
    if (supportGPUSkinning) vertCode += vertInput_a_skinning;
    vertCode += vertInput_u_matrices_all;
    if (Nm) vertCode += vertInput_u_lightNm;
    if (supportGPUSkinning) vertCode += vertInput_u_skinning;
 
    // Vertex shader outputs
    vertCode += vertOutput_v_P_VS;
    if (Sm) vertCode += vertOutput_v_P_WS;
    vertCode += vertOutput_v_N_VS;
    if (sky) vertCode += vertOutput_v_R_OS;
    if (uv0) vertCode += vertOutput_v_uv0;
    if (uv1) vertCode += vertOutput_v_uv1;
    if (Nm) vertCode += vertOutput_v_lightVecTS;
 
    // Vertex shader main loop
    vertCode += main_Begin;
    if (supportGPUSkinning) vertCode += Nm ? vertMain_skinning_Nm : vertMain_skinning;
    vertCode += vertMain_v_P_VS;
    if (Sm) vertCode += vertMain_v_P_WS_Sm;
    vertCode += vertMain_v_N_VS;
    if (sky) vertCode += vertMain_v_R_OS;
    if (uv0) vertCode += vertMain_v_uv0;
    if (uv1) vertCode += vertMain_v_uv1;
    if (Nm) vertCode += vertMain_TBN_Nm;
    vertCode += vertMain_EndAll;
 
    // Vertex shader variables
    setVariable(vertCode, "localPosition", supportGPUSkinning ? "skinnedPosition" : "a_position");
    setVariable(vertCode, "localNormal", supportGPUSkinning ? "skinnedNormal" : "a_normal");
    if (Nm) setVariable(vertCode, "localTangent", supportGPUSkinning ? "skinnedTangent" : "a_tangent");
 
    addCodeToShader(_shaders[0], vertCode, _name + ".vert");
 
    // Assemble fragment shader code
    string fragCode;
    fragCode += shaderHeader((int)lights->size());
 
    // Fragment shader inputs
    fragCode += fragInput_v_P_VS;
    if (Sm) fragCode += fragInput_v_P_WS;
    fragCode += fragInput_v_N_VS;
    if (sky) fragCode += fragInput_v_R_OS;
    if (uv0) fragCode += fragInput_v_uv0;
    if (uv1) fragCode += fragInput_v_uv1;
    if (Nm) fragCode += fragInput_v_lightVecTS;
 
    // Fragment shader uniforms
    fragCode += fragInput_u_lightAll;
    if (Sm) fragCode += fragInput_u_lightSm(lights);
    fragCode += Dm ? fragInput_u_matTexDm : fragInput_u_matDiff;
    fragCode += Em ? fragInput_u_matTexEm : fragInput_u_matEmis;
    if (Rm) fragCode += fragInput_u_matTexRm;
    if (Mm) fragCode += fragInput_u_matTexMm;
    if (RMm) fragCode += fragInput_u_matTexRmMm;
    if (ORMm) fragCode += fragInput_u_matTexOmRmMm;
    if (!Rm && !RMm && !ORMm) fragCode += fragInput_u_matRough;
    if (!Mm && !RMm && !ORMm) fragCode += fragInput_u_matMetal;
    if (Nm) fragCode += fragInput_u_matTexNm;
    if (Om0 || Om1) fragCode += fragInput_u_matTexOm;
    if (Sm) fragCode += fragInput_u_matGetsSm;
    if (Sm) fragCode += fragInput_u_shadowMaps(lights);
    if (sky) fragCode += fragInput_u_skyCookEnvMaps;
    fragCode += fragInput_u_cam;
 
    // Fragment shader outputs
    fragCode += fragOutputs_o_fragColor;
 
    // Fragment shader functions
    fragCode += fragFunctionsLightingCookTorrance;
    fragCode += fragFunctionFogBlend;
    fragCode += fragFunctionDoStereoSeparation;
    if (Sm) fragCode += fragFunctionShadowTest(lights);
    if (Sm) fragCode += fragFunctionDoColoredShadows;
 
    // Fragment shader main loop
    fragCode += main_Begin;
    fragCode += fragMain_0_Intensities;
    fragCode += Nm ? fragMain_1_EN_in_TS : fragMain_1_EN_in_VS;
    fragCode += Dm ? fragMainCook_1_matDiff_Dm : fragMainCook_1_matDiff;
    fragCode += Em ? fragMainCook_1_matEmis_Em : fragMainCook_1_matEmis;
    fragCode += ORMm ? fragMainCook_1_matRough_ORMm : RMm ? fragMainCook_1_matRough_RMm
                                                    : Rm  ? fragMainCook_1_matRough_Rm
                                                          : fragMainCook_1_matRough;
    fragCode += ORMm ? fragMainCook_1_matMetal_ORMm : RMm ? fragMainCook_1_matMetal_RMm
                                                    : Rm  ? fragMainCook_1_matMetal_Mm
                                                          : fragMainCook_1_matMetal;
    fragCode += ORMm ? fragMainCook_1_matOcclu_ORMm : Om0 ? fragMainCook_1_matOcclu_Om0
                                                    : Om1 ? fragMainCook_1_matOcclu_Om1
                                                          : fragMainCook_1_matOcclu_1;
    fragCode += Nm && Sm ? fragMainCook_2_LightLoopNmSm : Nm ? fragMainCook_2_LightLoopNm
                                                        : Sm ? fragMainCook_2_LightLoopSm
                                                             : fragMainCook_2_LightLoop;
    fragCode += sky ? fragMainCook_3_FragColorSky : fragMainCook_3_FragColor;
    if (Sm) fragCode += fragMain_4_ColoredShadows;
    fragCode += fragMain_5_FogGammaStereo;
 
    addCodeToShader(_shaders[1], fragCode, _name + ".frag");
}

buildPerPixParticle()

void SLGLProgramGenerated::buildPerPixParticle ( SLMaterial *  mat )

private

Definition at line 2316 of file SLGLProgramGenerated.cpp.

{
    assert(_shaders.size() > 2 &&
           _shaders[0]->type() == ST_vertex &&
           _shaders[1]->type() == ST_fragment &&
           _shaders[2]->type() == ST_geometry);
 
    // Check what textures the material has
    bool  Dm            = mat->hasTextureType(TT_diffuse);
    GLint billboardType = mat->ps()->billboardType();      // Billboard type (0 -> default; 1 -> vertical billboard, 2 -> horizontal billboard)
    bool  rot           = mat->ps()->doRotation();         // Rotation
    bool  AlOvLi        = mat->ps()->doAlphaOverLT();      // Alpha over life
    bool  Co            = mat->ps()->doColor();            // Color over life
    bool  CoOvLi        = mat->ps()->doColorOverLT();      // Color over life
    bool  AlOvLiCu      = mat->ps()->doAlphaOverLTCurve(); // Alpha over life curve
    bool  SiOvLi        = mat->ps()->doSizeOverLT();       // Size over life
    bool  SiOvLiCu      = mat->ps()->doSizeOverLTCurve();  // Size over life curve
    bool  FlBoTex       = mat->ps()->doFlipBookTexture();  // Flipbook texture
 
    //////////////////////////////
    // Assemble vertex shader code
    //////////////////////////////
 
    string vertCode;
    vertCode += shaderHeader();
 
    // Vertex shader inputs
    vertCode += vertInput_PS_a_p;
    vertCode += vertInput_PS_a_st;
    if (rot) vertCode += vertInput_PS_a_r;
    if (FlBoTex) vertCode += vertInput_PS_a_texNum;
 
    // Vertex shader uniforms
    vertCode += vertInput_PS_u_time;
    vertCode += vertInput_u_matrix_vOmv;
    if (AlOvLi && AlOvLiCu) vertCode += vertInput_PS_u_al_bernstein_alpha;
    if (SiOvLi && SiOvLiCu) vertCode += vertInput_PS_u_al_bernstein_size;
    if (Co && CoOvLi) vertCode += vertInput_PS_u_colorOvLF;
 
    // Vertex shader outputs
    vertCode += vertOutput_PS_struct_Begin;
    vertCode += vertOutput_PS_struct_t;
    if (rot) vertCode += vertOutput_PS_struct_r;
    if (SiOvLi) vertCode += vertOutput_PS_struct_s;
    if (Co && CoOvLi) vertCode += vertOutput_PS_struct_c;
    if (FlBoTex) vertCode += vertOutput_PS_struct_texNum;
    vertCode += vertOutput_PS_struct_End;
 
    // Vertex shader functions
    if (Co && CoOvLi) vertCode += vertFunction_PS_ColorOverLT;
 
    // Vertex shader main loop
    vertCode += main_Begin;
    vertCode += vertMain_PS_v_a;
    if (AlOvLi)
        vertCode += vertMain_PS_v_t_begin;
    else
        vertCode += vertMain_PS_v_t_default;
 
    if (AlOvLi) vertCode += AlOvLiCu ? vertMain_PS_v_t_curve : vertMain_PS_v_t_linear;
    if (AlOvLi) vertCode += vertMain_PS_v_t_end;
    if (rot) vertCode += vertMain_PS_v_r;
    if (SiOvLi) vertCode += vertMain_PS_v_s;
    if (SiOvLi && SiOvLiCu) vertCode += vertMain_PS_v_s_curve;
    if (Co && CoOvLi) vertCode += vertMain_PS_v_doColorOverLT;
    if (FlBoTex) vertCode += vertMain_PS_v_texNum;
    if (billboardType == BT_Vertical || billboardType == BT_Horizontal)
        vertCode += vertMain_PS_EndAll_VertBillboard;
    else
        vertCode += vertMain_PS_EndAll;
 
    addCodeToShader(_shaders[0], vertCode, _name + ".vert");
 
    ////////////////////////////////
    // Assemble geometry shader code
    ////////////////////////////////
 
    string geomCode;
    geomCode += shaderHeader();
 
    // geometry shader inputs
    geomCode += geomConfig_PS;
 
    geomCode += geomInput_PS_struct_Begin;
    geomCode += geomInput_PS_struct_t;
    if (rot) geomCode += geomInput_PS_struct_r;
    if (SiOvLi) geomCode += geomInput_PS_struct_s;
    if (Co && CoOvLi) geomCode += geomInput_PS_struct_c;
    if (FlBoTex) geomCode += geomInput_PS_struct_texNum;
    geomCode += geomInput_PS_struct_End;
 
    // geometry shader uniforms
    geomCode += geomInput_PS_u_ScaRa;
    if (Co && !CoOvLi) geomCode += geomInput_PS_u_c;
    if (FlBoTex) geomCode += geomInput_PS_u_col;
    if (FlBoTex) geomCode += geomInput_PS_u_row;
    geomCode += geomInput_u_matrix_p;
    if (billboardType == BT_Vertical)
        geomCode += geomInput_u_matrix_vertBillboard;
    else if (billboardType == BT_Horizontal)
        geomCode += vertInput_u_matrix_vOmv;
 
    // geometry shader outputs
    geomCode += geomOutput_PS_v_pC;
    geomCode += geomOutput_PS_v_tC;
 
    // geometry shader main loop
    geomCode += main_Begin;
    geomCode += geomMain_PS_v_s;
    if (SiOvLi) geomCode += geomMain_PS_v_sS;
    geomCode += geomMain_PS_v_rad;
    geomCode += geomMain_PS_v_p;
    geomCode += rot ? geomMain_PS_v_rot : geomMain_PS_v_rotIden;
    geomCode += Co && CoOvLi ? geomMain_PS_v_doColorOverLT : Co ? geomMain_PS_v_c
                                                                : geomMain_PS_v_withoutColor;
    geomCode += geomMain_PS_v_cT;
    if (billboardType == BT_Vertical)
        geomCode += FlBoTex ? geomMain_PS_Flipbook_fourCorners_vertBillboard : geomMain_PS_fourCorners_vertBillboard;
    else if (billboardType == BT_Horizontal)
        geomCode += FlBoTex ? geomMain_PS_Flipbook_fourCorners_horizBillboard : geomMain_PS_fourCorners_horizBillboard;
    else
        geomCode += FlBoTex ? geomMain_PS_Flipbook_fourCorners : geomMain_PS_fourCorners;
 
    geomCode += geomMain_PS_EndAll;
 
    addCodeToShader(_shaders[2], geomCode, _name + ".geom");
 
    ////////////////////////////////
    // Assemble fragment shader code
    ////////////////////////////////
 
    string fragCode;
    fragCode += shaderHeader();
 
    // Fragment shader inputs
    fragCode += fragInput_PS_v_pC;
    fragCode += fragInput_PS_v_tC;
 
    // Fragment shader uniforms
    if (Dm) fragCode += fragInput_u_matTexDm;
    fragCode += fragInput_PS_u_overG;
    fragCode += fragInput_PS_u_wireFrame;
 
    // Fragment shader outputs
    fragCode += fragOutputs_o_fragColor;
 
    // Fragment shader main loop
    fragCode += main_Begin;
    fragCode += Co ? fragMain_PS : fragMain_PS_withoutColor;
    fragCode += fragMain_PS_endAll;
 
    addCodeToShader(_shaders[1], fragCode, _name + ".frag");
}

buildPerPixParticleInstanced()

void SLGLProgramGenerated::buildPerPixParticleInstanced ( SLMaterial *  mat )

private

Definition at line 2182 of file SLGLProgramGenerated.cpp.

{
    assert(_shaders.size() == 2 &&
           _shaders[0]->type() == ST_vertex &&
           _shaders[1]->type() == ST_fragment);
 
    // Check what textures the material has
    bool  Dm            = mat->hasTextureType(TT_diffuse);
    GLint billboardType = mat->ps()->billboardType();      // Billboard type (0 -> default; 1 -> vertical billboard, 2 -> horizontal billboard)
    bool  rot           = mat->ps()->doRotation();         // Rotation
    bool  AlOvLi        = mat->ps()->doAlphaOverLT();      // Alpha over life
    bool  Co            = mat->ps()->doColor();            // Color over life
    bool  CoOvLi        = mat->ps()->doColorOverLT();      // Color over life
    bool  AlOvLiCu      = mat->ps()->doAlphaOverLTCurve(); // Alpha over life curve
    bool  SiOvLi        = mat->ps()->doSizeOverLT();       // Size over life
    bool  SiOvLiCu      = mat->ps()->doSizeOverLTCurve();  // Size over life curve
    bool  FlBoTex       = mat->ps()->doFlipBookTexture();  // Flipbook texture
 
    //////////////////////////////
    // Assemble vertex shader code
    //////////////////////////////
 
    string vertCode;
    vertCode += shaderHeader();
 
    // Vertex shader inputs
    vertCode += vertInput_PS_a_InstPos;    // instance position
    vertCode += vertInput_PS_a_p;          // position
    vertCode += vertInput_PS_a_st;         // start time
    if (rot) vertCode += vertInput_PS_a_r; // rotation as float
 
    if (FlBoTex)
    {
        vertCode += vertInput_PS_a_texNum; // per particle texture number
        vertCode += vertInput_PS_u_col;
        vertCode += vertInput_PS_u_row;
    }
 
    // Vertex shader uniforms
    vertCode += vertInput_PS_u_ScaRa;
    vertCode += vertInput_u_matrix_p;
    vertCode += vertInput_PS_u_time;
 
    if (billboardType == BT_Vertical)
        vertCode += vertInput_u_matrix_vertBillboard;
 
    vertCode += vertInput_u_matrix_vOmv;
 
    if (AlOvLi && AlOvLiCu) vertCode += vertInput_PS_u_al_bernstein_alpha;
    if (SiOvLi && SiOvLiCu) vertCode += vertInput_PS_u_al_bernstein_size;
 
    // Vertex shader outputs
    vertCode += vertOutput_PS_instanced_transparency;
    vertCode += vertOutput_PS_v_tC;
 
    if (CoOvLi) vertCode += vertOutput_PS_age;
 
    // Vertex shader main loop
    vertCode += main_Begin;
    vertCode += vertMain_PS_instanced_position;
    vertCode += vertMain_PS_v_a;
    if (FlBoTex)
        vertCode += vertMain_PS_v_tC_flipbook;
    else
        vertCode += vertMain_PS_v_tC;
 
    if (AlOvLi)
        vertCode += vertMain_PS_instanced_v_t_begin;
    else
        vertCode += vertMain_PS_instanced_v_t_default;
    if (AlOvLi) vertCode += AlOvLiCu ? vertMain_PS_instanced_v_t_curve : vertMain_PS_instanced_v_t_linear;
    if (AlOvLi) vertCode += vertMain_PS_v_t_end;
    vertCode += vertMain_PS_instanced_scale;
    if (SiOvLi) vertCode += vertMain_PS_instanced_v_s;
    if (SiOvLi && SiOvLiCu) vertCode += vertMain_PS_instanced_v_s_curve;
    if (SiOvLi) vertCode += vertMain_PS_instanced_v_sS;
    if (rot) vertCode += vertMain_PS_instanced_rotate;
    if (CoOvLi) vertCode += vertMain_PS_v_age;
 
    if (billboardType == BT_Vertical || billboardType == BT_Horizontal)
        vertCode += vertMain_PS_instanced_EndAll_VertBillboard;
    else
        vertCode += vertMain_PS_instanced_EndAll;
 
    addCodeToShader(_shaders[0], vertCode, _name + ".vert");
 
    ////////////////////////////////
    // Assemble fragment shader code
    ////////////////////////////////
 
    string fragCode;
    fragCode += shaderHeader();
 
    // Fragment shader inputs
    fragCode += fragInput_PS_v_tC;
    if (Co && !CoOvLi) fragCode += fragInput_PS_u_c;
    if (CoOvLi)
    {
        fragCode += fragInput_PS_u_tTL;
        fragCode += fragInput_PS_age;
        fragCode += fragInput_PS_u_colorOvLF;
    }
    fragCode += fragInput_PS_instanced_transparency;
 
    // Fragment shader uniforms
    if (Dm) fragCode += fragInput_u_matTexDm;
    fragCode += fragInput_PS_u_overG;
    fragCode += fragInput_PS_u_wireFrame;
 
    // Fragment shader outputs
    fragCode += fragOutputs_o_fragColor;
 
    if (CoOvLi) fragCode += fragFunction_PS_ColorOverLT;
 
    // Fragment shader main loop
    fragCode += main_Begin;
 
    if (Co && !CoOvLi) fragCode += fragMain_PS_instanced_c;
 
    if (CoOvLi) fragCode += fragMain_PS_instanced_v_doColorOverLT;
 
    if (Co || CoOvLi)
    {
        fragCode += fragMain_PS_instanced_transparency;
        fragCode += fragMain_instanced_PS_end;
    }
    else
        fragCode += fragMain_PS_instanced_withoutColor;
 
    fragCode += fragMain_PS_endAll;
 
    addCodeToShader(_shaders[1], fragCode, _name + ".frag");
}

buildPerPixParticleUpdate()

void SLGLProgramGenerated::buildPerPixParticleUpdate ( SLMaterial *  mat )

private

Definition at line 2470 of file SLGLProgramGenerated.cpp.

{
    assert(_shaders.size() > 1 &&
           _shaders[0]->type() == ST_vertex &&
           _shaders[1]->type() == ST_fragment);
 
    bool counterGap = mat->ps()->doCounterGap();      // Counter gap/lag
    bool acc        = mat->ps()->doAcc();             // Acceleration
    bool accDiffDir = mat->ps()->doAccDiffDir();      // Acceleration different direction
    bool gravity    = mat->ps()->doGravity();         // Gravity
    bool FlBoTex    = mat->ps()->doFlipBookTexture(); // Flipbook texture
    bool rot        = mat->ps()->doRotation();        // Rotation
    bool rotRange   = mat->ps()->doRotRange();        // Rotation range
    bool shape      = mat->ps()->doShape();           // Shape
 
    string vertCode;
    vertCode += shaderHeader();
 
    // Vertex shader inputs
    vertCode += vertInput_PS_a_p;
    vertCode += vertInput_PS_a_v;
    vertCode += vertInput_PS_a_st;
    if (acc || gravity) vertCode += vertInput_PS_a_initV;
    if (rot) vertCode += vertInput_PS_a_r;
    if (rot && rotRange) vertCode += vertInput_PS_a_r_angularVelo;
    if (FlBoTex) vertCode += vertInput_PS_a_texNum;
    if (shape) vertCode += vertInput_PS_a_initP;
 
    // Vertex shader uniforms
    vertCode += vertInput_PS_u_time;
    vertCode += vertInput_PS_u_deltaTime;
    vertCode += vertInput_PS_u_pgPos;
    if (rot && !rotRange) vertCode += vertInput_PS_u_angularVelo;
    if (acc) vertCode += accDiffDir ? vertInput_PS_u_a_diffDir : vertInput_PS_u_a_const;
    if (gravity) vertCode += vertInput_PS_u_g;
    if (FlBoTex) vertCode += vertInput_PS_u_col;
    if (FlBoTex) vertCode += vertInput_PS_u_row;
    if (FlBoTex) vertCode += vertInput_PS_u_condFB;
 
    // Vertex shader outputs
    vertCode += vertOutput_PS_tf_p;
    vertCode += vertOutput_PS_tf_v;
    vertCode += vertOutput_PS_tf_st;
    if (acc || gravity) vertCode += vertOutput_PS_tf_initV;
    if (rot) vertCode += vertOutput_PS_tf_r;
    if (rot && rotRange) vertCode += vertOutput_PS_tf_r_angularVelo;
    if (FlBoTex) vertCode += vertOutput_PS_tf_texNum;
    if (shape) vertCode += vertOutput_PS_tf_initP;
 
    if (rot) vertCode += vertConstant_PS_pi; // Add constant PI
 
    // Vertex shader main loop
    vertCode += main_Begin;
    vertCode += vertMain_PS_U_Begin;
    vertCode += vertMain_PS_U_v_init_p;
    vertCode += vertMain_PS_U_v_init_v;
    vertCode += vertMain_PS_U_v_init_st;
    if (acc || gravity) vertCode += vertMain_PS_U_v_init_initV;
    if (rot) vertCode += vertMain_PS_U_v_init_r;
    if (rot && rotRange) vertCode += vertMain_PS_U_v_init_r_angularVelo;
    if (FlBoTex) vertCode += vertMain_PS_U_v_init_texNum;
    if (shape) vertCode += vertMain_PS_U_v_init_initP;
    vertCode += vertMain_PS_U_bornDead;
    vertCode += shape ? vertMain_PS_U_reset_shape_p : vertMain_PS_U_reset_p;
    if (acc || gravity) vertCode += vertMain_PS_U_reset_v;
    vertCode += counterGap ? vertMain_PS_U_reset_st_counterGap : vertMain_PS_U_reset_st;
    vertCode += vertMain_PS_U_alive_p;
    if (rot) vertCode += rotRange ? vertMain_PS_U_v_rRange : vertMain_PS_U_v_rConst;
    if (FlBoTex) vertCode += vertMain_PS_U_alive_texNum;
    if (acc) vertCode += accDiffDir ? vertMain_PS_U_alive_a_diffDir : vertMain_PS_U_alive_a_const;
    if (gravity) vertCode += vertMain_PS_U_alive_g;
    vertCode += vertMain_PS_U_EndAll;
 
    addCodeToShader(_shaders[0], vertCode, _name + ".vert");
 
    // Assemble fragment shader code
    string fragCode;
    fragCode += shaderHeader();
 
    // Fragment shader inputs
    fragCode += fragOutputs_o_fragColor;
    fragCode += main_Begin;
    fragCode += fragMain_PS_TF;
 
    addCodeToShader(_shaders[1], fragCode, _name + ".frag");
}

buildPerPixVideoBkgdSm()

void SLGLProgramGenerated::buildPerPixVideoBkgdSm ( SLVLight *  lights )

private

Assemble shaders for video on background.

Definition at line 2558 of file SLGLProgramGenerated.cpp.

{
    assert(_shaders.size() > 1 &&
           _shaders[0]->type() == ST_vertex &&
           _shaders[1]->type() == ST_fragment);
 
    // Assemble vertex shader code
    string vertCode;
    vertCode += shaderHeader((int)lights->size());
    vertCode += vertInput_a_pn;
    vertCode += vertInput_u_matrices_all;
    vertCode += vertOutput_v_P_VS;
    vertCode += vertOutput_v_P_WS;
    vertCode += vertOutput_v_N_VS;
    vertCode += main_Begin;
    vertCode += vertMain_v_P_VS;
    vertCode += vertMain_v_P_WS_Sm;
    vertCode += vertMain_v_N_VS;
    vertCode += vertMain_EndAll;
 
    // Vertex shader variables
    setVariable(vertCode, "localPosition", "a_position");
    setVariable(vertCode, "localNormal", "a_normal");
 
    addCodeToShader(_shaders[0], vertCode, _name + ".vert");
 
    // Assemble fragment shader code
    string fragCode;
    fragCode += shaderHeader((int)lights->size());
    fragCode += R"(
in      vec3        v_P_VS;     // Interpol. point of illumination in view space (VS)
in      vec3        v_P_WS;     // Interpol. point of illumination in world space (WS)
in      vec3        v_N_VS;     // Interpol. normal at v_P_VS in view space
)";
    fragCode += fragInput_u_lightAll;
    fragCode += fragInput_u_lightSm(lights);
    fragCode += fragInput_u_cam;
    fragCode += fragInput_u_matAmbi;
    fragCode += fragInput_u_matTexDm;
    fragCode += fragInput_u_matGetsSm;
    fragCode += fragInput_u_shadowMaps(lights);
    fragCode += fragOutputs_o_fragColor;
    fragCode += fragFunctionFogBlend;
    fragCode += fragFunctionDoStereoSeparation;
    fragCode += fragFunctionShadowTest(lights);
    fragCode += fragFunctionDoColoredShadows;
    fragCode += main_Begin;
    fragCode += fragMainVideoBkgd;
    fragCode += fragMain_5_FogGammaStereo;
    addCodeToShader(_shaders[1], fragCode, _name + ".frag");
}

buildProgramCode()

void SLGLProgramGenerated::buildProgramCode	(	SLMaterial *	mat,
		SLVLight *	lights,
		SLbool	supportGPUSkinning
	)

Builds the GLSL program code for the vertex and fragment shaders. The code is only assembled but not compiled and linked. This happens within the before the first draw call from within SLMesh::draw.

Parameters

mat	Parent material pointer
lights	Pointer of vector of lights

Definition at line 1863 of file SLGLProgramGenerated.cpp.

{
    assert(mat && "No material pointer passed!");
    assert(!lights->empty() && "No lights passed!");
    assert(_shaders.size() > 1 &&
           _shaders[0]->type() == ST_vertex &&
           _shaders[1]->type() == ST_fragment);
 
    // Check what textures the material has
    bool Dm  = mat->hasTextureType(TT_diffuse);   // Texture Mapping
    bool Nm  = mat->hasTextureType(TT_normal);    // Normal Mapping
    bool Hm  = mat->hasTextureType(TT_height);    // Height Mapping
    bool Om  = mat->hasTextureType(TT_occlusion); // Ambient Occlusion Mapping
    bool Vm  = mat->hasTextureType(TT_videoBkgd); // Video Background Mapping
    bool env = mat->skybox() != nullptr;          // Environment Mapping from skybox
 
    // Check if any of the scene lights does shadow mapping
    bool Sm = lightsDoShadowMapping(lights);
 
    if (mat->reflectionModel() == RM_BlinnPhong)
    {
        buildPerPixBlinn(mat, lights, supportGPUSkinning);
    }
    else if (mat->reflectionModel() == RM_CookTorrance)
    {
        buildPerPixCook(mat, lights, supportGPUSkinning);
    }
    else if (mat->reflectionModel() == RM_Custom)
    {
        if (Vm && Sm)
            buildPerPixVideoBkgdSm(lights);
        else
            SL_EXIT_MSG("SLGLProgramGenerated::buildProgramCode: Unknown program for RM_Custom.");
    }
    else
        SL_EXIT_MSG("SLGLProgramGenerated::buildProgramCode: Unknown Lighting Model.");
}

buildProgramCodePS()

void SLGLProgramGenerated::buildProgramCodePS	(	SLMaterial *	mat,
		bool	isDrawProg,
		bool	drawInstanced = false
	)

Builds the GLSL program code for the vertex, geometry and fragment shaders (for particle system drawing). The code is only assembled but not compiled and linked. This happens within the before the first draw call from within SLMesh::draw.

Parameters

mat	Parent material pointer
isDrawProg	Flag if program is for drawing instead of update

Definition at line 1909 of file SLGLProgramGenerated.cpp.

{
    if (mat->name() == "IBLMat")
    {
        std::cout << "build program code for IBLMat" << std::endl;
    }
    assert(mat && "No material pointer passed!");
    assert(_shaders.size() > 1 &&
           _shaders[0]->type() == ST_vertex &&
           _shaders[1]->type() == ST_fragment);
 
    if (isDrawProg)
    {
        if (drawInstanced)
            buildPerPixParticleInstanced(mat);
        else
            buildPerPixParticle(mat);
    }
    else
        buildPerPixParticleUpdate(mat);
}

buildProgramName()

void SLGLProgramGenerated::buildProgramName ( SLMaterial *  mat, SLVLight *  lights, SLbool  supportGPUSkinning, string &  programName  )

static

Builds unique program name that identifies shader program.

See the class information for more insights of the generated name. This function is used in advance of the code generation to check if the program already exists in the asset manager. See SLMaterial::activate.

Parameters

mat	Parent material pointer
lights	Pointer of vector of lights
programName	Reference to program name string that gets built

The shader program gets a unique name with the following pattern:

genCook-D00-N00-E00-O01-RM00-Sky-C4s-S
   |    |   |   |   |   |    |   |   |
   |    |   |   |   |   |    |   |   + Support for GPU skinning
   |    |   |   |   |   |    |   + Directional light w. 4 shadow cascades
   |    |   |   |   |   |    + Ambient light from skybox
   |    |   |   |   |   + Roughness-metallic map with index 0 and uv 0
   |    |   |   |   + Ambient Occlusion map with index 0 and uv 1
   |    |   |   + Emissive Map with index 0 and uv 0
   |    |   + Normal Map with index 0 and uv 0
   |    + Diffuse Texture Mapping with index 0 and uv 0
   + Cook-Torrance or Blinn-Phong reflection model

Definition at line 1724 of file SLGLProgramGenerated.cpp.

{
    assert(mat && "No material pointer passed!");
    assert(lights && !lights->empty() && "No lights passed!");
 
    programName = "gen";
 
    if (mat->hasTextureType(TT_videoBkgd))
        programName += "VideoBkgdDm";
    else if (mat->reflectionModel() == RM_BlinnPhong)
        programName += "Blinn";
    else if (mat->reflectionModel() == RM_CookTorrance)
        programName += "Cook";
    else
        programName += "Custom";
 
    programName += mat->texturesString();
    programName += "-";
 
    // Add letter per light type
    for (auto light : *lights)
    {
        if (light->positionWS().w == 0.0f)
        {
            if (light->doCascadedShadows())
                programName += "C" + std::to_string(light->shadowMap()->numCascades()); // Directional light with cascaded shadowmap
            else
                programName += "D"; // Directional light
        }
        else if (light->spotCutOffDEG() < 180.0f)
            programName += "S"; // Spotlight
        else
            programName += "P"; // Pointlight
        if (light->createsShadows())
            programName += "s"; // Creates shadows
    }
 
    if (supportGPUSkinning)
        programName += "-S";
}

buildProgramNamePS()

void SLGLProgramGenerated::buildProgramNamePS ( SLMaterial *  mat, string &  programName, bool  isDrawProg, bool  drawInstanced  )

static

See the class information for more insights of the generated name. This function is used in advance of the code generation to check if the program already exists in the asset manager. See SLMaterial::activate.

Parameters

mat	Parent material pointer
programName	Reference to program name string that gets built
isDrawProg	Flag if program is for drawing instead of updating

The shader program gets a unique name with the following pattern:

genCook-D00-N00-E00-O01-RM00-Sky-C4s
   |    |   |   |   |   |    |   |
   |    |   |   |   |   |    |   + Directional light w. 4 shadow cascades
   |    |   |   |   |   |    + Ambient light from skybox
   |    |   |   |   |   + Roughness-metallic map with index 0 and uv 0
   |    |   |   |   + Ambient Occlusion map with index 0 and uv 1
   |    |   |   + Emissive Map with index 0 and uv 0
   |    |   + Normal Map with index 0 and uv 0
   |    + Diffuse Texture Mapping with index 0 and uv 0
   + Cook-Torrance or Blinn-Phong reflection model

Definition at line 1789 of file SLGLProgramGenerated.cpp.

{
    assert(mat && "No material pointer passed!");
    programName = "gen";
 
    if (mat->reflectionModel() == RM_Particle)
        programName += "Particle";
    else
        programName += "Custom";
 
    // programName += "-";
    if (isDrawProg) // Drawing program
    {
        programName += "-Draw";
 
        if (drawInstanced)
            programName += "-Inst";
 
        programName += mat->texturesString();
        GLint billboardType = mat->ps()->billboardType();      // Billboard type (0 -> default; 1 -> vertical billboard, 2 -> horizontal billboard)
        bool  AlOvLi        = mat->ps()->doAlphaOverLT();      // Alpha over life
        bool  AlOvLiCu      = mat->ps()->doAlphaOverLTCurve(); // Alpha over life curve
        bool  SiOvLi        = mat->ps()->doSizeOverLT();       // Size over life
        bool  SiOvLiCu      = mat->ps()->doSizeOverLTCurve();  // Size over life curve
        bool  Co            = mat->ps()->doColor();            // Color over life
        bool  CoOvLi        = mat->ps()->doColorOverLT();      // Color over life
        bool  FlBoTex       = mat->ps()->doFlipBookTexture();  // Flipbook texture
        bool  WS            = mat->ps()->doWorldSpace();       // World space or local space
        bool  rot           = mat->ps()->doRotation();         // Rotation
        programName += "-B" + std::to_string(billboardType);
        if (rot) programName += "-RT";
        if (AlOvLi) programName += "-AL";
        if (AlOvLi && AlOvLiCu) programName += "cu";
        if (SiOvLi) programName += "-SL";
        if (SiOvLi && SiOvLiCu) programName += "cu";
        if (Co) programName += "-CO";
        if (Co && CoOvLi) programName += "cl";
        if (FlBoTex) programName += "-FB";
        if (WS) programName += "-WS";
    }
    else // Updating program
    {
        bool counterGap = mat->ps()->doCounterGap();      // Counter gap/lag
        bool acc        = mat->ps()->doAcc();             // Acceleration
        bool accDiffDir = mat->ps()->doAccDiffDir();      // Acceleration different direction
        bool gravity    = mat->ps()->doGravity();         // Gravity
        bool FlBoTex    = mat->ps()->doFlipBookTexture(); // Flipbook texture
        bool rot        = mat->ps()->doRotation();        // Rotation
        bool rotRange   = mat->ps()->doRotRange();        // Rotation range
        bool shape      = mat->ps()->doShape();           // Shape
        programName += "-Update";
        if (counterGap) programName += "-CG";
        if (rot) programName += "-RT";
        if (rot) programName += rotRange ? "ra" : "co";
        if (acc)
        {
            programName += "-AC";
            programName += accDiffDir ? "di" : "co";
        }
        if (gravity) programName += "-GR";
        if (FlBoTex) programName += "-FB";
        if (shape) programName += "-SH";
    }
}

endShader()

void SLGLProgramGenerated::endShader ( )

inlineoverridevirtual

Implements SLGLProgram.

Definition at line 115 of file SLGLProgramGenerated.h.

{ endUse(); }

fragFunctionShadowTest()

string SLGLProgramGenerated::fragFunctionShadowTest ( SLVLight *  lights )

staticprivate

Adds the core shadow mapping test routine depending on the lights.

Definition at line 2686 of file SLGLProgramGenerated.cpp.

{
    bool doCascadedSM = false;
    for (SLLight* light : *lights)
    {
        if (light->doCascadedShadows())
        {
            doCascadedSM = true;
            break;
        }
    }
 
    string shadowTestCode = R"(
//-----------------------------------------------------------------------------
int vectorToFace(vec3 vec) // Vector to process
{
    vec3 absVec = abs(vec);
    if (absVec.x > absVec.y && absVec.x > absVec.z)
        return vec.x > 0.0 ? 0 : 1;
    else if (absVec.y > absVec.x && absVec.y > absVec.z)
        return vec.y > 0.0 ? 2 : 3;
    else
        return vec.z > 0.0 ? 4 : 5;
}
//-----------------------------------------------------------------------------
int getCascadesDepthIndex(in int i, int numCascades)
{
    float factor;
)";
 
    for (SLuint i = 0; i < lights->size(); ++i)
    {
        SLShadowMap* shadowMap = lights->at(i)->shadowMap();
        if (shadowMap && shadowMap->useCascaded())
        {
            shadowTestCode += "    if (i == " + std::to_string(i) + ")\n";
            shadowTestCode += "    {\n";
            shadowTestCode += "        factor = u_cascadesFactor_" + std::to_string(i) + ";\n";
            shadowTestCode += "    }\n";
        }
    }
 
    shadowTestCode += R"(
    float fi = u_camClipNear;
    float ni;
 
    for (int i = 0; i < numCascades-1; i++)
    {
        ni = fi;
        fi = factor * u_camClipNear * pow((u_camClipFar/(factor*u_camClipNear)), float(i+1)/float(numCascades));
        if (-v_P_VS.z < fi)
            return i;
    }
    return numCascades-1;
}
//-----------------------------------------------------------------------------
float shadowTest(in int i, in vec3 N, in vec3 lightDir)
{
    if (u_lightCreatesShadows[i])
    {
        // Calculate position in light space
        mat4 lightSpace;
        vec3 lightToFragment = v_P_WS - u_lightPosWS[i].xyz;
)";
 
    if (doCascadedSM > 0)
    {
        shadowTestCode += R"(
        int index = 0;
 
        if (u_lightNumCascades[i] > 0)
        {
            index = getCascadesDepthIndex(i, u_lightNumCascades[i]);
        )";
        for (SLuint i = 0; i < lights->size(); ++i)
        {
            SLShadowMap* shadowMap = lights->at(i)->shadowMap();
            if (shadowMap && shadowMap->useCascaded())
                shadowTestCode += "    if (i == " + std::to_string(i) + ") { lightSpace = u_lightSpace_" + std::to_string(i) + "[index]; }\n";
        }
        shadowTestCode += R"(
        }
        else if (u_lightUsesCubemap[i])
        {)";
        for (SLuint i = 0; i < lights->size(); ++i)
        {
            SLShadowMap* shadowMap = lights->at(i)->shadowMap();
            if (shadowMap && shadowMap->useCubemap())
                shadowTestCode += "    if (i == " + std::to_string(i) + ") { lightSpace = u_lightSpace_" + std::to_string(i) + "[vectorToFace(lightToFragment)]; }\n";
        }
        shadowTestCode += R"(
        }
        else
        {
        )";
        for (SLuint i = 0; i < lights->size(); ++i)
        {
            SLShadowMap* shadowMap = lights->at(i)->shadowMap();
            if (shadowMap && !shadowMap->useCubemap() && !shadowMap->useCascaded())
                shadowTestCode += "if (i == " + std::to_string(i) + ") { lightSpace = u_lightSpace_" + std::to_string(i) + "}\n";
        }
        shadowTestCode += R"(
        }
        )";
    }
    else
    {
        shadowTestCode += R"(
        if (u_lightUsesCubemap[i])
        {
)";
        for (SLuint i = 0; i < lights->size(); ++i)
        {
            SLShadowMap* shadowMap = lights->at(i)->shadowMap();
            if (shadowMap && shadowMap->useCubemap())
                shadowTestCode += "            if (i == " + std::to_string(i) + ") lightSpace = u_lightSpace_" + std::to_string(i) + "[vectorToFace(lightToFragment)];\n";
        }
        shadowTestCode += R"(
        }
        else
        {
)";
        for (SLuint i = 0; i < lights->size(); ++i)
        {
            SLShadowMap* shadowMap = lights->at(i)->shadowMap();
            if (shadowMap && !shadowMap->useCubemap() && !shadowMap->useCascaded())
                shadowTestCode += "            if (i == " + std::to_string(i) + ") lightSpace = u_lightSpace_" + std::to_string(i) + ";\n";
        }
        shadowTestCode += R"(
        }
        )";
    }
 
    shadowTestCode += R"(
        vec4 lightSpacePosition = lightSpace * vec4(v_P_WS, 1.0);
 
        // Normalize lightSpacePosition
        vec3 projCoords = lightSpacePosition.xyz / lightSpacePosition.w;
 
        // Convert to texture coordinates
        projCoords = projCoords * 0.5 + 0.5;
 
        float currentDepth = projCoords.z;
 
        // Look up depth from shadow map
        float shadow = 0.0;
        float closestDepth;
 
        // calculate bias between min. and max. bias depending on the angle between N and lightDir
        float bias = max(u_lightShadowMaxBias[i] * (1.0 - dot(N, lightDir)), u_lightShadowMinBias[i]);
 
        // Use percentage-closer filtering (PCF) for softer shadows (if enabled)
        if (u_lightDoSmoothShadows[i])
        {
            int level = u_lightSmoothShadowLevel[i];
            vec2 texelSize;
)";
 
    for (SLuint i = 0; i < lights->size(); ++i)
    {
        SLShadowMap* shadowMap = lights->at(i)->shadowMap();
        if (!shadowMap->useCascaded() && !shadowMap->useCubemap())
            shadowTestCode += "            if (i == " + to_string(i) + ") { texelSize = 1.0 / vec2(textureSize(u_shadowMap_" + to_string(i) + ", 0)); }\n";
        else if (shadowMap->useCascaded())
        {
            shadowTestCode += "            if (i == " + to_string(i) + ")\n            {\n";
            for (int j = 0; j < shadowMap->depthBuffers().size(); j++)
                shadowTestCode += "                if (index == " + to_string(j) + ") { texelSize = 1.0 / vec2(textureSize(u_cascadedShadowMap_" + to_string(i) + "_" + to_string(j) + ", 0)); }\n";
 
            shadowTestCode += "            }\n";
        }
    }
    shadowTestCode += R"(
            for (int x = -level; x <= level; ++x)
            {
                for (int y = -level; y <= level; ++y)
                {
    )";
    for (SLuint i = 0; i < lights->size(); ++i)
    {
        SLShadowMap* shadowMap = lights->at(i)->shadowMap();
        if (!shadowMap->useCascaded() && !shadowMap->useCubemap())
            shadowTestCode += "                 if (i == " + to_string(i) + ") { closestDepth = texture(u_shadowMap_" + to_string(i) + ", projCoords.xy + vec2(x, y) * texelSize).r; }\n";
        else if (shadowMap->useCascaded())
        {
            shadowTestCode += "                if (i == " + to_string(i) + ")\n                    {\n";
            for (int j = 0; j < shadowMap->depthBuffers().size(); j++)
                shadowTestCode += "                        if (index == " + to_string(j) + ") { closestDepth = texture(u_cascadedShadowMap_" + to_string(i) + "_" + to_string(j) + ", projCoords.xy + vec2(x, y) * texelSize).r; }\n";
            shadowTestCode += "                    }\n";
        }
    }
 
    shadowTestCode += R"(
                    shadow += currentDepth - bias > closestDepth ? 1.0 : 0.0;
                }
            }
            shadow /= pow(1.0 + 2.0 * float(level), 2.0);
        }
        else
        {
            if (u_lightUsesCubemap[i])
            {
)";
    for (SLuint i = 0; i < lights->size(); ++i)
    {
        SLShadowMap* shadowMap = lights->at(i)->shadowMap();
        if (shadowMap->useCubemap())
            shadowTestCode += "                if (i == " + to_string(i) + ") closestDepth = texture(u_shadowMapCube_" + to_string(i) + ", lightToFragment).r;\n";
    }
    shadowTestCode += R"(
            }
            else if (u_lightNumCascades[i] > 0)
            {
)";
    for (SLuint i = 0; i < lights->size(); ++i)
    {
        SLLight*     light     = lights->at(i);
        SLShadowMap* shadowMap = lights->at(i)->shadowMap();
        if (light->doCascadedShadows())
        {
            shadowTestCode += "                if (i == " + to_string(i) + ")\n                {\n";
            for (int j = 0; j < shadowMap->depthBuffers().size(); j++)
                shadowTestCode += "                    if (index == " + to_string(j) + ") { closestDepth = texture(u_cascadedShadowMap_" + to_string(i) + "_" + to_string(j) + ", projCoords.xy).r; }\n";
            shadowTestCode += "                }";
        }
    }
 
    shadowTestCode += R"(
            }
            else
            {
)";
 
    for (SLuint i = 0; i < lights->size(); ++i)
    {
        SLShadowMap* shadowMap = lights->at(i)->shadowMap();
        if (!shadowMap->useCubemap() && !shadowMap->useCascaded())
            shadowTestCode += "                if (i == " + to_string(i) + ") closestDepth = texture(u_shadowMap_" + to_string(i) + ", projCoords.xy).r;\n";
    }
 
    shadowTestCode += R"(
            }
 
            // The fragment is in shadow if the light doesn't "see" it
            if (currentDepth > closestDepth + bias)
                shadow = 1.0;
        }
 
        return shadow;
    }
 
    return 0.0;
})";
 
    return shadowTestCode;
}

fragInput_u_lightSm()

string SLGLProgramGenerated::fragInput_u_lightSm ( SLVLight *  lights )

staticprivate

Definition at line 2623 of file SLGLProgramGenerated.cpp.

{
    string u_lightSm = R"(
uniform vec4        u_lightPosWS[NUM_LIGHTS];               // position of light in world space
uniform bool        u_lightCreatesShadows[NUM_LIGHTS];      // flag if light creates shadows
uniform int         u_lightNumCascades[NUM_LIGHTS];         // number of cascades for cascaded shadowmap
uniform bool        u_lightDoSmoothShadows[NUM_LIGHTS];     // flag if percentage-closer filtering is enabled
uniform int         u_lightSmoothShadowLevel[NUM_LIGHTS];   // radius of area to sample for PCF
uniform float       u_lightShadowMinBias[NUM_LIGHTS];       // min. shadow bias value at 0° to N
uniform float       u_lightShadowMaxBias[NUM_LIGHTS];       // min. shadow bias value at 90° to N
uniform bool        u_lightUsesCubemap[NUM_LIGHTS];         // flag if light has a cube shadow map
uniform bool        u_lightsDoColoredShadows;               // flag if shadows should be colored
)";
    for (SLuint i = 0; i < lights->size(); ++i)
    {
        SLLight* light = lights->at(i);
        if (light->createsShadows())
        {
            SLShadowMap* shadowMap = light->shadowMap();
 
            if (shadowMap->useCubemap())
            {
                u_lightSm += "uniform mat4        u_lightSpace_" + std::to_string(i) + "[6];\n";
            }
            else if (light->doCascadedShadows())
            {
                u_lightSm += "uniform mat4        u_lightSpace_" + std::to_string(i) + "[" + std::to_string(shadowMap->numCascades()) + "];\n";
            }
            else
            {
                u_lightSm += "uniform mat4        u_lightSpace_" + std::to_string(i) + ";\n";
            }
        }
    }
    return u_lightSm;
}

fragInput_u_shadowMaps()

string SLGLProgramGenerated::fragInput_u_shadowMaps ( SLVLight *  lights )

staticprivate

Definition at line 2660 of file SLGLProgramGenerated.cpp.

{
    string smDecl = "\n";
    for (SLuint i = 0; i < lights->size(); ++i)
    {
        SLLight* light = lights->at(i);
        if (light->createsShadows())
        {
            SLShadowMap* shadowMap = light->shadowMap();
            if (shadowMap->useCubemap())
                smDecl += "uniform samplerCube u_shadowMapCube_" + to_string(i) + ";\n";
            else if (light->doCascadedShadows())
            {
                for (int j = 0; j < light->shadowMap()->depthBuffers().size(); j++)
                    smDecl += "uniform sampler2D   u_cascadedShadowMap_" + to_string(i) + "_" + std::to_string(j) + ";\n";
 
                smDecl += "uniform float       u_cascadesFactor_" + to_string(i) + ";\n";
            }
            else
                smDecl += "uniform sampler2D   u_shadowMap_" + to_string(i) + ";\n";
        }
    }
    return smDecl;
}

lightsDoShadowMapping()

bool SLGLProgramGenerated::lightsDoShadowMapping ( SLVLight *  lights )

static

Returns true if at least one of the light does shadow mapping.

Definition at line 2613 of file SLGLProgramGenerated.cpp.

{
    for (auto light : *lights)
    {
        if (light->createsShadows())
            return true;
    }
    return false;
}

setVariable()

void SLGLProgramGenerated::setVariable ( std::string &  code, const std::string &  name, const std::string &  value  )

staticprivate

Sets a variable in the shader code.

A variable is specified in templates like this: ${variableName}.

Definition at line 2976 of file SLGLProgramGenerated.cpp.

{
    std::string placeholder = "${" + name + "}";
 
    std::string::size_type pos = 0;
    while ((pos = code.find(placeholder)) != std::string::npos)
    {
        code.replace(pos, placeholder.size(), value);
        pos += value.size();
    }
}

shaderHeader() [1/2]

string SLGLProgramGenerated::shaderHeader ( )

staticprivate

Adds shader header code.

Definition at line 3001 of file SLGLProgramGenerated.cpp.

{
    string header = "\nprecision highp float;\n";
    return header;
}

shaderHeader() [2/2]

string SLGLProgramGenerated::shaderHeader ( int  numLights )

staticprivate

Adds shader header code.

Definition at line 2991 of file SLGLProgramGenerated.cpp.

{
    string header = "\nprecision highp float;\n";
    header += "\n#define NUM_LIGHTS " + to_string(numLights) + "\n";
    return header;
}

Member Data Documentation

generatedShaderPath

string SLGLProgramGenerated::generatedShaderPath

staticprivate

Definition at line 140 of file SLGLProgramGenerated.h.

---

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

• SLGLProgramGenerated.h
• SLGLProgramGenerated.cpp