Beatmup::GL::AbstractProgram Class Reference

Basic GLSL program. More...

#include <program.h>

Inheritance diagram for Beatmup::GL::AbstractProgram:

Public Member Functions
	AbstractProgram (const GraphicPipeline &gpu)
	~AbstractProgram ()
void	enable (const GraphicPipeline &gpu)
Chunk *	getBinary () const
void	loadBinary (const Chunk &binary)
handle_t	findUniformLocation (const char *name)
	Retrieves uniform variable location by its name. More...
handle_t	findAttribLocation (const char *name)
	Retrieves attribute location by its name. More...
handle_t	getUniformLocation (const std::string &name)
	Retrieves uniform variable location by its name. More...
handle_t	getAttribLocation (const std::string &name)
	Retrieves attribute location by its name. More...
void	setInteger (const std::string &name, const int value, bool safe=false)
	Assigns a value to a specific integer variable in the program. More...
void	setUnsignedInteger (const std::string &name, const unsigned int value, bool safe=false)
void	setFloat (const std::string &name, const float value, bool safe=false)
	Assigns a value to a specific floating point variable in the program. More...
void	setVector2 (const std::string &name, const float x, const float y)
void	setVector3 (const std::string &name, const float x, const float y, const float z)
void	setVector4 (const std::string &name, const float x, const float y, const float z, const float w)
void	setVector4 (const std::string &name, const color4i &color, const float outRange=1.0f)
void	setMatrix2 (const std::string &name, const Matrix2 &mat)
void	setMatrix3 (const std::string &name, const Matrix2 &mat, const Point &pos)
void	setMatrix3 (const std::string &name, const AffineMapping &mapping)
void	setIntegerArray (const std::string &name, const int *values, const int length)
void	setIntegerArray (const std::string &name, const int firstValue, const int length)
void	setFloatArray (const std::string &name, const float *values, const int length)
void	setVec2Array (const std::string &name, const float *xy, const int length)
void	setVec4Array (const std::string &name, const float *xyzw, const int length)
void	bindSampler (GraphicPipeline &gpu, GL::TextureHandler &image, const char *uniformId, TextureParam param)
void	bindImage (GraphicPipeline &gpu, GL::TextureHandler &image, const char *uniformId, bool read, bool write)
void	bindAtomicCounter (GraphicPipeline &gpu, AtomicCounter &counter, int unit)
Public Member Functions inherited from Beatmup::GL::RecycleBin::Item
	Item ()
virtual	~Item ()

Protected Member Functions
handle_t	getHandle () const
void	assertLinked () const
void	clearCaches ()

Private Member Functions
	AbstractProgram (const AbstractProgram &)=delete
	disabling copying constructor More...

Private Attributes
std::map< std::string, handle_t >	uniformsCache
std::map< std::string, handle_t >	attribsCache
handle_t	handle

Detailed Description

Basic GLSL program.

Shaders are controlled by the user.

Definition at line 135 of file program.h.

Constructor & Destructor Documentation

AbstractProgram() [1/2]

Beatmup::GL::AbstractProgram::AbstractProgram ( const AbstractProgram &  )

privatedelete

disabling copying constructor

AbstractProgram() [2/2]

AbstractProgram::AbstractProgram

(

const GraphicPipeline &

gpu

)

Definition at line 216 of file program.cpp.

                                                           {
    handle = glCreateProgram();
}

~AbstractProgram()

AbstractProgram::~AbstractProgram

(

)

Definition at line 221 of file program.cpp.

                                  {
    glDeleteProgram(handle);
}

Member Function Documentation

getHandle()

handle_t Beatmup::GL::AbstractProgram::getHandle ( ) const

inlineprotected

Definition at line 142 of file program.h.

{ return handle; }

assertLinked()

void AbstractProgram::assertLinked ( ) const

protected

Definition at line 226 of file program.cpp.

                                         {
    GLint status;
    glGetProgramiv(handle, GL_LINK_STATUS, &status);
    if (status == GL_TRUE)
        return;
    GLint logLength;
    glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &logLength);
    if (logLength > 0) {
        GLchar* log = (GLchar*)malloc(logLength);
        glGetProgramInfoLog(handle, logLength, &logLength, log);
        throw GL::GLException((char*)log);
        free(log);
    }
    else
        throw GL::GLException("Program linking failed (no log).");
}

clearCaches()

void AbstractProgram::clearCaches ( )

protected

Definition at line 244 of file program.cpp.

                                  {
    uniformsCache.clear();
    attribsCache.clear();
}

enable()

void AbstractProgram::enable

(

const GraphicPipeline &

gpu

)

Definition at line 250 of file program.cpp.

                                                       {
    glUseProgram(handle);
    GL::GLException::check("enabling a program");
}

getBinary()

Chunk * AbstractProgram::getBinary

(

)

const

Definition at line 257 of file program.cpp.

                                        {
    GLsizei length;
    glGetProgramiv(handle, GL_PROGRAM_BINARY_LENGTH, &length);
    GL::GLException::check("querying program size");
 
    // setting up a chunk: first sizeof(GLenum) bytes store the binary format
    Chunk* result = new Chunk(sizeof(GLenum) + (size_t)length);
    glGetProgramBinary(handle, length, nullptr, result->ptr<GLenum>(0), result->ptr<GLenum>(1));
    GL::GLException::check("getting binary");
    return result;
}

loadBinary()

void AbstractProgram::loadBinary

(

const Chunk &

binary

)

Definition at line 270 of file program.cpp.

                                                    {
    // convention: first sizeof(GLenum) bytes store the binary format
    glProgramBinary(handle, binary.at<GLenum>(0), binary.ptr<GLenum>(1), binary.size() - sizeof(GLenum));
    GL::GLException::check("loading program binary");
}

findUniformLocation()

GL::handle_t AbstractProgram::findUniformLocation

(

const char *

name

)

Retrieves uniform variable location by its name.

May be slow.

Parameters

[in]

name

The variable name

Definition at line 278 of file program.cpp.

                                                                {
    return glGetUniformLocation(handle, name);
}

findAttribLocation()

GL::handle_t AbstractProgram::findAttribLocation

(

const char *

name

)

Retrieves attribute location by its name.

May be slow.

Parameters

[in]

name

The attribute name

Definition at line 283 of file program.cpp.

                                                               {
    return glGetAttribLocation(handle, name);
}

getUniformLocation()

GL::handle_t AbstractProgram::getUniformLocation

(

const std::string &

name

)

Retrieves uniform variable location by its name.

Uses chache. Faster when called more than once.

Parameters

[in]

name

The variable name

Definition at line 288 of file program.cpp.

                                                                    {
    auto it = uniformsCache.find(name);
    if (it != uniformsCache.end())
        return it->second;
    handle_t location = glGetUniformLocation(handle, name.c_str());
    uniformsCache[name] = location;
    return location;
}

getAttribLocation()

GL::handle_t AbstractProgram::getAttribLocation

(

const std::string &

name

)

Retrieves attribute location by its name.

Uses chache. Faster when called more than once.

Parameters

[in]

name

The attribute name

Definition at line 298 of file program.cpp.

                                                                   {
    auto it = attribsCache.find(name);
    if (it != attribsCache.end())
        return it->second;
    handle_t location = glGetAttribLocation(handle, name.c_str());
    attribsCache[name] = location;
    return location;
}

setInteger()

void AbstractProgram::setInteger	(	const std::string &	name,
		const int	value,
		bool	safe = false
	)

Assigns a value to a specific integer variable in the program.

Parameters

name	the variable name
value	the value to assign
safe	if true check if the target variable exists before assigning

Definition at line 308 of file program.cpp.

                                                                                  {
    if (safe) {
        GLint location = getUniformLocation(name);
        if (location == -1)
            return;
        glUniform1i(location, (GLint)value);
    }
    else
        glUniform1i(getUniformLocation(name), (GLint)value);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting integer in program");
#endif
}

setUnsignedInteger()

void AbstractProgram::setUnsignedInteger	(	const std::string &	name,
		const unsigned int	value,
		bool	safe = false
	)

Definition at line 323 of file program.cpp.

                                                                                                   {
    if (safe) {
        GLint location = getUniformLocation(name);
        if (location == -1)
            return;
#ifdef BEATMUP_OPENGLVERSION_GLES20
        glUniform1i(location, (GLint)value);
#else
        glUniform1ui(location, (GLuint)value);
#endif
    }
    else {
#ifdef BEATMUP_OPENGLVERSION_GLES20
        glUniform1i(getUniformLocation(name), (GLint)value);
#else
        glUniform1ui(getUniformLocation(name), (GLuint)value);
#endif
    }
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting integer in program");
#endif
}

setFloat()

void AbstractProgram::setFloat	(	const std::string &	name,
		const float	value,
		bool	safe = false
	)

Assigns a value to a specific floating point variable in the program.

Parameters

name	the variable name
value	the value to assign
safe	if true check if the target variable exists before assigning

Definition at line 347 of file program.cpp.

                                                                                  {
    if (safe) {
        GLint location = getUniformLocation(name);
        if (location == -1)
            return;
        glUniform1f(location, (GLfloat)value);
    }
    else
        glUniform1f(getUniformLocation(name), (GLfloat)value);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting float in program");
#endif
}

setVector2()

void AbstractProgram::setVector2	(	const std::string &	name,
		const float	x,
		const float	y
	)

Definition at line 362 of file program.cpp.

                                                                                    {
    glUniform2f(getUniformLocation(name), x, y);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting vector 2 in program");
#endif
}

setVector3()

void AbstractProgram::setVector3	(	const std::string &	name,
		const float	x,
		const float	y,
		const float	z
	)

Definition at line 370 of file program.cpp.

                                                                                                   {
    glUniform3f(getUniformLocation(name), x, y, z);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting vector 3 in program");
#endif
}

setVector4() [1/2]

void AbstractProgram::setVector4	(	const std::string &	name,
		const float	x,
		const float	y,
		const float	z,
		const float	w
	)

Definition at line 378 of file program.cpp.

                                                                                                                  {
    glUniform4f(getUniformLocation(name), x, y, z, w);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting vector 4 in program");
#endif
}

setVector4() [2/2]

void AbstractProgram::setVector4	(	const std::string &	name,
		const color4i &	color,
		const float	outRange = 1.0f
	)

Definition at line 386 of file program.cpp.

                                                                                                  {
    const float scale = outRange / 255;
    setVector4(name, scale * color.r, scale * color.g, scale * color.b, scale * color.a);
}

setMatrix2()

void AbstractProgram::setMatrix2	(	const std::string &	name,
		const Matrix2 &	mat
	)

Definition at line 392 of file program.cpp.

                                                                          {
    GLfloat m[4] = { 1, 0, 0, 1 };
    mat.getElements(m[0], m[2], m[1], m[3]);
    glUniformMatrix2fv(getUniformLocation(name), 1, false, m);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting matrix 2x2 in program");
#endif
}

setMatrix3() [1/2]

void AbstractProgram::setMatrix3	(	const std::string &	name,
		const Matrix2 &	mat,
		const Point &	pos
	)

Definition at line 402 of file program.cpp.

                                                                                            {
    GLfloat m[9] = { 1, 0, 0, 0, 1, 0, pos.x, pos.y, 1 };
    mat.getElements(m[0], m[3], m[1], m[4]);
    glUniformMatrix3fv(getUniformLocation(name), 1, false, m);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting matrix 3x3 in program");
#endif
}

setMatrix3() [2/2]

void AbstractProgram::setMatrix3	(	const std::string &	name,
		const AffineMapping &	mapping
	)

Definition at line 412 of file program.cpp.

                                                                                    {
    setMatrix3(name, mapping.matrix, mapping.position);
}

setIntegerArray() [1/2]

void AbstractProgram::setIntegerArray	(	const std::string &	name,
		const int *	values,
		const int	length
	)

Definition at line 417 of file program.cpp.

                                                                                                {
    if (sizeof(GLint) != sizeof(int)) {
        GLint* convValues = new GLint[length];
        for (int i = 0; i < length; ++i)
            convValues[i] = values[i];
        glUniform1iv(getUniformLocation(name), length, convValues);
        delete[] convValues;
    }
    else {
        glUniform1iv(getUniformLocation(name), length, values);
    }
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting integer array in program");
#endif
}

setIntegerArray() [2/2]

void AbstractProgram::setIntegerArray	(	const std::string &	name,
		const int	firstValue,
		const int	length
	)

Definition at line 434 of file program.cpp.

                                                                                                   {
    static const int STORAGE_LEN = 8;
    GLint storage[STORAGE_LEN];
    const bool alloc = length > STORAGE_LEN;
    GLint* values = alloc ? new GLint[length] : storage;
    for (int i = 0; i < length; ++i)
        values[i] = firstValue + i;
    glUniform1iv(getUniformLocation(name), length, values);
    if (alloc)
        delete[] values;
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting integer array in program");
#endif
}

setFloatArray()

void AbstractProgram::setFloatArray	(	const std::string &	name,
		const float *	values,
		const int	length
	)

Definition at line 450 of file program.cpp.

                                                                                                {
    glUniform1fv(getUniformLocation(name), length, values);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting float array in program");
#endif
}

setVec2Array()

void AbstractProgram::setVec2Array	(	const std::string &	name,
		const float *	xy,
		const int	length
	)

Definition at line 458 of file program.cpp.

                                                                                           {
    glUniform2fv(getUniformLocation(name), length, xy);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting vec2 array in program");
#endif
}

setVec4Array()

void AbstractProgram::setVec4Array	(	const std::string &	name,
		const float *	xyzw,
		const int	length
	)

Definition at line 466 of file program.cpp.

                                                                                             {
    glUniform4fv(getUniformLocation(name), length, xyzw);
#ifdef BEATMUP_DEBUG
    GL::GLException::check("setting vec4 array in program");
#endif
}

bindSampler()

void AbstractProgram::bindSampler	(	GraphicPipeline &	gpu,
		GL::TextureHandler &	image,
		const char *	uniformId,
		TextureParam	param
	)

Definition at line 474 of file program.cpp.

                                                                                                                          {
    handle_t uniform = getUniformLocation(uniformId);
    GLint unit;
    glGetUniformiv(getHandle(), uniform, &unit);
    GL::GLException::check("binding sampler in program");
    gpu.bind(image, unit, param);
}

bindImage()

void AbstractProgram::bindImage	(	GraphicPipeline &	gpu,
		GL::TextureHandler &	image,
		const char *	uniformId,
		bool	read,
		bool	write
	)

Definition at line 483 of file program.cpp.

                                                                                                                           {
    handle_t uniform = getUniformLocation(uniformId);
    GLint unit;
    glGetUniformiv(getHandle(), uniform, &unit);
    GL::GLException::check("binding image in program");
    gpu.bind(image, unit, read, write);
}

bindAtomicCounter()

void AbstractProgram::bindAtomicCounter	(	GraphicPipeline &	gpu,
		AtomicCounter &	counter,
		int	unit
	)

Definition at line 493 of file program.cpp.

                                                                                              {
    glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, unit, counter.handle);
    GL::GLException::check("binding atomic counter");
}

Member Data Documentation

uniformsCache

std::map<std::string, handle_t> Beatmup::GL::AbstractProgram::uniformsCache

private

Definition at line 137 of file program.h.

attribsCache

std::map<std::string, handle_t> Beatmup::GL::AbstractProgram::attribsCache

private

Definition at line 137 of file program.h.

handle

handle_t Beatmup::GL::AbstractProgram::handle

private

Definition at line 138 of file program.h.

---

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

• core/gpu/program.h
• core/gpu/program.cpp