SLGLShader Class Reference

Encapsulation of an OpenGL shader object. More...

#include <SLGLShader.h>

Inheritance diagram for SLGLShader:

Public Member Functions
	SLGLShader ()
	Default constructor. More...
	SLGLShader (const SLstring &filename, SLShaderType type)
	Ctor with shader filename & shader type. More...
	~SLGLShader () override
void	load (const SLstring &filename)
	SLGLShader::load loads a shader file into string _shaderSource. More...
void	loadFromMemory (const SLstring &program)
	SLGLShader::load loads a shader file from memory into memory. More...
SLstring	typeName ()
	Returns the shader type as string. More...
SLShaderType	type ()
SLuint	shaderID () const
SLstring	code ()
void	code (SLstring strCode)
void	file (SLstring strFile)
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 SLstring	removeComments (SLstring src)
	SLGLShader::removeComments for C/C++ comments removal from shader code. More...

Protected Attributes
SLShaderType	_type
	Shader type enumeration. More...
SLuint	_shaderID
	Program Object. More...
SLstring	_code
	ASCII Source-Code. More...
SLstring	_file
	Path & filename of shader. More...
Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...
SLstring	_url
	uniform resource locator More...

Private Member Functions
SLbool	createAndCompile (SLVLight *lights)
	SLGLShader::createAndCompile creates & compiles the OpenGL shader object. More...
SLstring	preprocessIncludePragmas (SLstring inCode)
	Replaces our custom pragma include directives in GLSL code. More...
SLstring	preprocessDefinePragmas (SLstring inCode, SLVLight *lights)
	Replaces our custom pragma define directives in GLSL code. More...

Friends
class	SLGLProgram

Detailed Description

Encapsulation of an OpenGL shader object.

The SLGLShader class represents a shader object of the OpenGL Shading Language (GLSL). It can load & compile an GLSL shader file and is later on attached to an OpenGL program (SLGLProgram). Instances of SLShader are owned and deleted by their program (SLGLProgram).

Definition at line 24 of file SLGLShader.h.

Constructor & Destructor Documentation

SLGLShader() [1/2]

SLGLShader::SLGLShader

(

)

Default constructor.

Definition at line 26 of file SLGLShader.cpp.

{
    _type     = ST_none;
    _code     = "";
    _shaderID = 0;
    _file     = "";
}

SLGLShader() [2/2]

SLGLShader::SLGLShader	(	const SLstring &	filename,
		SLShaderType	shaderType
	)

Ctor with shader filename & shader type.

If the shader filename does not belong to an existing file the shader code will be generated at a later stage by SLGLProgramGenerated.

Parameters

filename	Path and filename of the shader to be loaded or generated.
shaderType	Shader type: ST_vertex, ST_fragment and ST_geometry.

Definition at line 40 of file SLGLShader.cpp.

  : SLObject(Utils::getFileName(filename), filename)
{
    _type     = shaderType;
    _code     = "";
    _shaderID = 0;
    _file     = filename;
 
    // Only load file at this moment, don't compile it.
    if (SLFileStorage::exists(filename, IOK_shader))
        load(filename);
}

~SLGLShader()

SLGLShader::~SLGLShader ( )

override

Definition at line 74 of file SLGLShader.cpp.

{
    // SL_LOG("~SLGLShader(%s)", name().c_str());
    if (_shaderID)
        glDeleteShader(_shaderID);
    GET_GL_ERROR;
}

Member Function Documentation

code() [1/2]

SLstring SLGLShader::code ( )

inline

Definition at line 42 of file SLGLShader.h.

{ return _code; }

code() [2/2]

void SLGLShader::code ( SLstring  strCode )

inline

Definition at line 45 of file SLGLShader.h.

{ _code = strCode; }

createAndCompile()

SLbool SLGLShader::createAndCompile ( SLVLight *  lights )

private

SLGLShader::createAndCompile creates & compiles the OpenGL shader object.

Returns

true if compilation was successful

Definition at line 86 of file SLGLShader.cpp.

{
    // delete if object already exits
    if (_shaderID)
        glDeleteShader(_shaderID);
 
    if (_code.empty())
    {
        SL_WARN_MSG("SLGLShader::createAndCompile: Nothing to compile!");
        std::cout << "file: " << _file << std::endl;
        return false;
    }
 
    switch (_type)
    {
        case ST_vertex:
            _shaderID = glCreateShader(GL_VERTEX_SHADER);
            break;
        case ST_geometry:
            /*
             * 0x8DD9 == GL_GEOMETRY_SHADER would be defined in <GLES3/gl32.h>
             * So far this header is not included by default in Android SDK and therefore
             * it is not guaranteed that an Android device hat OpenGL ES 3.2 and this header.
             * The app knows the OpenGL version when it is running. App that are below OpenGL ES 3.2
             * should not try to create geometry shaders as used for particles.
             */
            _shaderID = glCreateShader(0x8DD9);
            break;
        case ST_fragment:
            _shaderID = glCreateShader(GL_FRAGMENT_SHADER);
            break;
        default:
            SL_EXIT_MSG("SLGLShader::load: Unknown shader type.");
    }
    GET_GL_ERROR;
 
    // Build version string as the first statement
    SLGLState* state      = SLGLState::instance();
    SLstring   verGLSL    = state->glSLVersionNO();
    SLstring   srcVersion = "#version " + verGLSL;
    if (state->glIsES3()) srcVersion += " es";
    srcVersion += "\n";
 
    _code = preprocessDefinePragmas(_code, lights);
 
    // Concatenate final code string
    _code = srcVersion + _code;
 
    const char* src = _code.c_str();
    glShaderSource(_shaderID, 1, &src, nullptr);
    GET_GL_ERROR;
 
    glCompileShader(_shaderID);
    GET_GL_ERROR;
 
    // Check compiler log
    SLint compileSuccess = 0;
    glGetShaderiv(_shaderID, GL_COMPILE_STATUS, &compileSuccess);
    GET_GL_ERROR;
    if (compileSuccess == GL_FALSE)
    {
        GLchar log[1024];
        if (Utils::onlyErrorLogs) Utils::onlyErrorLogs = false;
        glGetShaderInfoLog(_shaderID, sizeof(log), nullptr, &log[0]);
        SL_LOG("*** COMPILER ERROR ***");
        SL_LOG("Source file: %s\n", _file.c_str());
        SL_LOG("%s---", log);
        SLVstring lines   = Utils::getStringLines(_code);
        SLint     lineNum = 1;
        for (string& line : lines)
            SL_LOG("%4d: %s", lineNum++, line.c_str());
        SL_LOG("\n");
        return false;
    }
 
#ifndef SL_EMSCRIPTEN
    // Write generated shader out
    if (!_file.empty())
    {
#    if defined(DEBUG) || defined(_DEBUG)
        string filename = Utils::getFileName(_file);
        string path     = Utils::getDirName(_file);
        if (Utils::dirExists(path))
        {
            if (Utils::containsString(path, "generatedShaders"))
            {
                SLFileStorage::writeString(_file, IOK_shader, _code);
                SL_LOG("Exported Shader  : %s", filename.c_str());
            }
        }
        else
            SL_WARN_MSG("**** No path to write shader ***");
#    else
        if (!SLFileStorage::exists(_file, IOK_shader))
        {
            string filename = Utils::getFileName(_file);
            string path     = Utils::getDirName(_file);
            if (Utils::dirExists(path))
            {
                SLFileStorage::writeString(_file, IOK_shader, _code);
                SL_LOG("Exported Shader  : %s", filename.c_str());
            }
            else
                SL_WARN_MSG("**** No path to write shader ***");
        }
#    endif
    }
    else
        SL_WARN_MSG("**** No shader path and filename for shader ***");
#endif
 
    return true;
}

file()

void SLGLShader::file ( SLstring  strFile )

inline

Definition at line 46 of file SLGLShader.h.

{ _file = strFile; }

load()

void SLGLShader::load

(

const SLstring &

filename

)

SLGLShader::load loads a shader file into string _shaderSource.

Definition at line 54 of file SLGLShader.cpp.

{
    SLIOBuffer buffer = SLFileStorage::readIntoBuffer(filename, IOK_shader);
    _code             = SLstring(buffer.data, buffer.data + buffer.size);
    buffer.deallocate();
 
    // Expand include pragmas. This has to be done here because we are not
    // allowed to perform I/O later on when compiling the shader.
    _code = preprocessIncludePragmas(_code);
 
    // remove comments because some stupid ARM compiler can't handle GLSL comments
    _code = removeComments(_code);
}

loadFromMemory()

void SLGLShader::loadFromMemory

(

const SLstring &

program

)

SLGLShader::load loads a shader file from memory into memory.

Definition at line 69 of file SLGLShader.cpp.

{
    _code = shaderSource;
}

preprocessDefinePragmas()

SLstring SLGLShader::preprocessDefinePragmas ( SLstring  inCode, SLVLight *  lights  )

private

Replaces our custom pragma define directives in GLSL code.

Definition at line 304 of file SLGLShader.cpp.

{
    // Check first if #pragma exists at all
    size_t pragmaStart = inCode.find("#pragma");
    if (pragmaStart == string::npos)
        return inCode;
 
    SLVstring codeLines = Utils::getStringLines(inCode);
 
    string outCode;
 
    for (string& line : codeLines)
    {
        pragmaStart = line.find("#pragma");
        if (pragmaStart == string::npos)
            outCode += line + '\n';
        else
        {
            SLVstring pragmaParts;
            Utils::splitString(line, ' ', pragmaParts);
 
            for (auto& part : pragmaParts)
                part = Utils::trimString(part);
 
            if (pragmaParts[1] == "define") //............................
            {
                if (pragmaParts[2] == "NUM_LIGHTS")
                {
                    outCode += "#define NUM_LIGHTS " +
                               std::to_string(lights->size()) + "\n";
                }
                else
                    outCode += line + '\n';
            } //...............................................................
            else
                outCode += line + '\n';
        }
    }
    return outCode;
}

preprocessIncludePragmas()

SLstring SLGLShader::preprocessIncludePragmas ( SLstring  inCode )

private

Replaces our custom pragma include directives in GLSL code.

Definition at line 254 of file SLGLShader.cpp.

{
    // Check first if #pragma exists at all
    size_t pragmaStart = inCode.find("#pragma");
    if (pragmaStart == string::npos)
        return inCode;
 
    SLVstring codeLines = Utils::getStringLines(inCode);
 
    string outCode;
 
    for (string& line : codeLines)
    {
        pragmaStart = line.find("#pragma");
        if (pragmaStart == string::npos)
            outCode += line + '\n';
        else
        {
            SLVstring pragmaParts;
            Utils::splitString(line, ' ', pragmaParts);
 
            for (auto& part : pragmaParts)
                part = Utils::trimString(part);
 
            if (pragmaParts[1] == "include") //................................
            {
                string filename = Utils::trimString(pragmaParts[2], "\"");
                string path     = Utils::getPath(_file);
                string pathFile = path + filename;
                if (SLFileStorage::exists(pathFile, IOK_shader))
                {
                    string includeCode = SLFileStorage::readIntoString(pathFile, IOK_shader);
                    includeCode        = removeComments(includeCode);
                    outCode += includeCode + '\n';
                }
                else
                {
                    SL_LOG("SLGLShader::preprocessPragmas: File doesn't exist: %s",
                           pathFile.c_str());
                    outCode += line + '\n';
                }
            }
            else
                outCode += line + '\n';
        }
    }
    return outCode;
}

removeComments()

SLstring SLGLShader::removeComments ( SLstring  src )

static

SLGLShader::removeComments for C/C++ comments removal from shader code.

Definition at line 201 of file SLGLShader.cpp.

{
    SLstring dst;
    SLuint   len    = (SLuint)src.length();
    SLuint   i      = 0;
    SLint    column = 0;
 
    while (i < len)
    {
        if (src[i] == '/' && src[i + 1] == '/')
        {
            if (column > 0)
                dst += '\n';
            while (i < len && src[i] != '\n')
                i++;
            i++;
        }
        else if (src[i] == '/' && src[i + 1] == '*')
        {
            while (i < len && !(src[i] == '*' && src[i + 1] == '/'))
            {
                if (src[i] == '\n') dst += '\n';
                i++;
            }
            i += 2;
        }
        else
        {
            if (src[i] == '\n')
                column = 0;
            else
                column++;
 
            dst += src[i++];
        }
    }
    return dst;
}

shaderID()

SLuint SLGLShader::shaderID ( ) const

inline

Definition at line 41 of file SLGLShader.h.

{ return _shaderID; }

type()

SLShaderType SLGLShader::type ( )

inline

Definition at line 40 of file SLGLShader.h.

{ return _type; }

typeName()

SLstring SLGLShader::typeName

(

)

Returns the shader type as string.

Definition at line 241 of file SLGLShader.cpp.

{
    switch (_type)
    {
        case ST_vertex: return "Vertex";
        case ST_fragment: return "Fragment";
        case ST_geometry: return "Geometry";
        case ST_tesselation: return "Tesselation";
        default: return "Unknown";
    }
}

Friends And Related Function Documentation

SLGLProgram

friend class SLGLProgram

friend

Definition at line 26 of file SLGLShader.h.

Member Data Documentation

_code

SLstring SLGLShader::_code

protected

ASCII Source-Code.

Definition at line 56 of file SLGLShader.h.

_file

SLstring SLGLShader::_file

protected

Path & filename of shader.

Definition at line 57 of file SLGLShader.h.

_shaderID

SLuint SLGLShader::_shaderID

protected

Program Object.

Definition at line 55 of file SLGLShader.h.

_type

SLShaderType SLGLShader::_type

protected

Shader type enumeration.

Definition at line 54 of file SLGLShader.h.

---

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

• SLGLShader.h
• SLGLShader.cpp