pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

optimised working with attributes and uniforms.

Browse source
This commit is contained in:
rachytski 2012-12-02 15:27:39 +03:00 • committed by Alex Zolotarev
parent 2de2bdc3a1
commit 660cc3f261
13 changed files with 471 additions and 158 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
base/matrix.hpp
View file

@ -21,6 +21,11 @@ namespace math
m_data[i] = src.m_data[i];
}
Matrix(T * data)
{
copy(data, data + Rows * Cols, m_data);
}
template <typename U>
Matrix<T, Rows, Cols> const & operator=(Matrix<U, Rows, Cols> const & src)
{

38
graphics/defines.cpp Normal file
View file

@ -0,0 +1,38 @@
#include "defines.hpp"
#include "../base/macros.hpp"
#include "../base/logging.hpp"
#include "../std/string.hpp"
namespace graphics
{
namespace {
struct Data
{
ESemantic m_val;
char const * m_name;
};
}
Data s_semantics[] = {
{ESemPosition, "Position"},
{ESemNormal, "Normal"},
{ESemTexCoord0, "TexCoord0"},
{ESemSampler0, "Sampler0"},
{ESemModelView, "ModelView"},
{ESemProjection, "Projection"}
};
void convert(char const * name, ESemantic & sem)
{
for (unsigned i = 0; i < ARRAY_SIZE(s_semantics); ++i)
{
if (strcmp(name, s_semantics[i].m_name) == 0)
{
sem = s_semantics[i].m_val;
return;
}
}
LOG(LINFO, ("Unknown Semantics=", name, "specified!"));
}
}

25
graphics/defines.hpp
View file

@ -10,11 +10,32 @@ namespace graphics
EFragmentShader
};
enum ESemantic
{
ESemPosition,
ESemNormal,
ESemTexCoord0,
ESemSampler0,
ESemModelView,
ESemProjection
};
void convert(char const * name, ESemantic & sem);
enum EDataType
{
EInteger,
EIntegerVec2,
EIntegerVec3,
EIntegerVec4,
EFloat,
EUnsigned,
EInteger
EFloatVec2,
EFloatVec3,
EFloatVec4,
EFloatMat2,
EFloatMat3,
EFloatMat4,
ESampler2D
};
enum EPrimitives

1
graphics/graphics.pro
View file

@ -71,6 +71,7 @@ SOURCES += \
render_context.cpp \
coordinates.cpp \
render_target.cpp \
defines.cpp
HEADERS += \
opengl/opengl.hpp \

78
graphics/opengl/defines_conv.cpp
View file

@ -1,26 +1,74 @@
#include "defines_conv.hpp"
#include "../../base/macros.hpp"
namespace graphics
{
namespace gl
{
struct Info
{
int m_firstFull;
int m_firstBase;
char const * m_firstName;
int m_secondFull;
int m_secondBase;
int m_countBase;
char const * m_secondName;
};
Info s_dataTypes [] =
{
{GL_FLOAT, GL_FLOAT, "GL_FLOAT", EFloat, EFloat, 1, "EFloatVec1"},
{GL_FLOAT_VEC2, GL_FLOAT, "GL_FLOAT_VEC2", EFloatVec2, EFloat, 2, "EFloatVec2"},
{GL_FLOAT_VEC3, GL_FLOAT, "GL_FLOAT_VEC3", EFloatVec3, EFloat, 3, "EFloatVec3"},
{GL_FLOAT_VEC4, GL_FLOAT, "GL_FLOAT_VEC4", EFloatVec4, EFloat, 4, "EFloatVec4"},
{GL_INT, GL_INT, "GL_INT", EInteger, EInteger, 1, "EIntegerVec1"},
{GL_INT_VEC2, GL_INT, "GL_INT_VEC2", EIntegerVec2, EInteger, 2, "EIntegerVec2"},
{GL_INT_VEC3, GL_INT, "GL_INT_VEC3", EIntegerVec3, EInteger, 3, "EIntegerVec3"},
{GL_INT_VEC4, GL_INT, "GL_INT_VEC4", EIntegerVec4, EInteger, 4, "EIntegerVec4"},
{GL_FLOAT_MAT2, GL_FLOAT_MAT2, "GL_FLOAT_MAT2", EFloatMat2, EFloatMat2, 1, "EFloatMat2"},
{GL_FLOAT_MAT3, GL_FLOAT_MAT3, "GL_FLOAT_MAT3", EFloatMat3, EFloatMat3, 1, "EFloatMat3"},
{GL_FLOAT_MAT4, GL_FLOAT_MAT4, "GL_FLOAT_MAT4", EFloatMat4, EFloatMat4, 1, "EFloatMat4"},
{GL_SAMPLER_2D, GL_SAMPLER_2D, "GL_SAMPLER_2D", ESampler2D, ESampler2D, 1, "ESampler2D"}
};
void convert(GLenum from, EDataType & to)
{
for (unsigned i = 0; i < ARRAY_SIZE(s_dataTypes); ++i)
if (s_dataTypes[i].m_firstFull == from)
{
to = (EDataType)s_dataTypes[i].m_secondFull;
return;
}
to = (EDataType)0;
LOG(LINFO, ("Unknown GLenum for EDataType specified"));
}
void convert(EDataType from, GLenum & to)
{
switch (from)
{
case EFloat:
to = GL_FLOAT;
break;
case EUnsigned:
to = GL_UNSIGNED_INT;
break;
case EInteger:
to = GL_INT;
break;
default:
LOG(LERROR, ("Unknown EDataType specified: ", from));
to = 0;
}
for (unsigned i = 0; i < ARRAY_SIZE(s_dataTypes); ++i)
if (s_dataTypes[i].m_secondFull == from)
{
to = s_dataTypes[i].m_firstFull;
return;
}
to = 0;
LOG(LINFO, ("Unknown EDataType specified"));
}
void convert(GLenum from, EDataType & to, size_t & count)
{
for (unsigned i = 0; i < ARRAY_SIZE(s_dataTypes); ++i)
if (s_dataTypes[i].m_firstFull == from)
{
to = (EDataType)s_dataTypes[i].m_secondBase;
count = s_dataTypes[i].m_countBase;
return;
}
to = (EDataType)0;
count = 0;
LOG(LINFO, ("Unknown GLenum for EDataType specified"));
}
void convert(EShaderType from, GLenum & to)

4
graphics/opengl/defines_conv.hpp
View file

@ -8,6 +8,10 @@ namespace graphics
namespace gl
{
void convert(EDataType from, GLenum & to);
void convert(GLenum from, EDataType & to);
void convert(GLenum from, EDataType & to, size_t & cnt);
void convert(EShaderType from, GLenum & to);
void convert(EPrimitives from, GLenum & to);
}

29
graphics/opengl/geometry_renderer.cpp
View file

@ -168,9 +168,10 @@ namespace graphics
ProgramManager * pm = rc->programManager();
shared_ptr<Program> prg = pm->getProgram("basic", "noalphatest");
prg->setParam("ModelViewM", rc->matrix(EModelView));
prg->setParam("ProjM", rc->matrix(EProjection));
prg->setParam("Texture", 0);
prg->setParam(ESemModelView, rc->matrix(EModelView));
prg->setParam(ESemProjection, rc->matrix(EProjection));
prg->setParam(ESemSampler0, 0);
prg->setStorage(blitStorage);
prg->setVertexDecl(gl::Vertex::getVertexDecl());
prg->makeCurrent();
@ -211,6 +212,10 @@ namespace graphics
shared_ptr<Program> const & prg = rc->program();
prg->setParam(ESemModelView, rc->matrix(EModelView));
prg->setParam(ESemProjection, rc->matrix(EProjection));
prg->setParam(ESemSampler0, 0);
prg->setStorage(m_storage);
prg->setVertexDecl(Vertex::getVertexDecl());
prg->makeCurrent();
@ -407,9 +412,9 @@ namespace graphics
ProgramManager * pm = rc->programManager();
shared_ptr<Program> prg = pm->getProgram("basic", "alphatest");
prg->setParam("ModelViewM", rc->matrix(EModelView));
prg->setParam("ProjM", rc->matrix(EProjection));
prg->setParam("Texture", 0);
prg->setParam(ESemModelView, rc->matrix(EModelView));
prg->setParam(ESemProjection, rc->matrix(EProjection));
prg->setParam(ESemSampler0, 0);
rc->setProgram(prg);
}
@ -432,9 +437,9 @@ namespace graphics
ProgramManager * pm = rc->programManager();
shared_ptr<Program> prg = pm->getProgram("basic", "noalphatest");
prg->setParam("ModelViewM", rc->matrix(EModelView));
prg->setParam("ProjM", rc->matrix(EProjection));
prg->setParam("Texture", 0);
prg->setParam(ESemModelView, rc->matrix(EModelView));
prg->setParam(ESemProjection, rc->matrix(EProjection));
prg->setParam(ESemSampler0, 0);
rc->setProgram(prg);
}
@ -477,9 +482,9 @@ namespace graphics
ProgramManager * pm = rc->programManager();
shared_ptr<Program> prg = pm->getProgram("sharp", "alphatest");
prg->setParam("ModelViewM", rc->matrix(EModelView));
prg->setParam("ProjM", rc->matrix(EProjection));
prg->setParam("Texture", 0);
prg->setParam(ESemModelView, rc->matrix(EModelView));
prg->setParam(ESemProjection, rc->matrix(EProjection));
prg->setParam(ESemSampler0, 0);
rc->setProgram(prg);
}

340
graphics/opengl/program.cpp
View file

@ -43,6 +43,50 @@ namespace graphics
throw LinkException("Could not link program: ", "Unknown link error");
}
/// getting all uniforms
int cnt = 0;
OGLCHECK(glGetProgramivFn(m_handle, GL_ACTIVE_UNIFORMS, &cnt));
GLchar name[1024];
GLsizei len = 0;
GLint size;
GLenum type;
for (unsigned i = 0; i < cnt; ++i)
{
Uniform f;
ESemantic sem;
OGLCHECK(glGetActiveUniform(m_handle, i, ARRAY_SIZE(name), &len, &size, &type, name));
f.m_handle = glGetUniformLocation(m_handle, name);
OGLCHECKAFTER;
convert(type, f.m_type);
convert(name, sem);
m_uniforms[sem] = f;
}
OGLCHECK(glGetProgramivFn(m_handle, GL_ACTIVE_ATTRIBUTES, &cnt));
for (unsigned i = 0; i < cnt; ++i)
{
Attribute a;
ESemantic sem;
OGLCHECK(glGetActiveAttrib(m_handle, i, ARRAY_SIZE(name), &len, &size, &type, name));
a.m_handle = glGetAttribLocation(m_handle, name);
OGLCHECKAFTER;
convert(type, a.m_type, a.m_count);
convert(name, sem);
m_attributes[sem] = a;
}
}
Program::~Program()
@ -50,103 +94,126 @@ namespace graphics
OGLCHECK(glDeleteProgramFn(m_handle));
}
GLuint Program::getParam(char const * name)
void Program::setParam(ESemantic sem, float v0)
{
GLuint res = glGetUniformLocationFn(m_handle, name);
OGLCHECKAFTER;
return res;
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EFloat;
f.m_data.m_floatVal[0] = v0;
}
GLuint Program::getAttribute(char const * name)
void Program::setParam(ESemantic sem, float v0, float v1)
{
GLuint res = glGetAttribLocationFn(m_handle, name);
OGLCHECKAFTER;
return res;
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EFloatVec2;
f.m_data.m_floatVal[0] = v0;
f.m_data.m_floatVal[1] = v1;
}
void setParamImpl(GLuint prgID, char const * name, function<void(GLint)> fn)
void Program::setParam(ESemantic sem, float v0, float v1, float v2)
{
GLuint res = glGetUniformLocationFn(prgID, name);
OGLCHECKAFTER;
OGLCHECK(fn(res));
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EFloatVec3;
f.m_data.m_floatVal[0] = v0;
f.m_data.m_floatVal[1] = v1;
f.m_data.m_floatVal[2] = v2;
}
void Program::setParam(char const * name, float v0)
void Program::setParam(ESemantic sem, float v0, float v1, float v2, float v3)
{
function<void(GLint)> fn = bind(&glUniform1f, _1, v0);
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EFloatVec4;
f.m_data.m_floatVal[0] = v0;
f.m_data.m_floatVal[1] = v1;
f.m_data.m_floatVal[2] = v2;
f.m_data.m_floatVal[3] = v3;
}
void Program::setParam(char const * name, float v0, float v1)
void Program::setParam(ESemantic sem, int v0)
{
function<void(GLint)> fn = bind(&glUniform2f, _1, v0, v1);
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EInteger;
f.m_data.m_intVal[0] = v0;
}
void Program::setParam(char const * name, float v0, float v1, float v2)
void Program::setParam(ESemantic sem, int v0, int v1)
{
function<void(GLint)> fn = bind(&glUniform3f, _1, v0, v1, v2);
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EIntegerVec2;
f.m_data.m_intVal[0] = v0;
f.m_data.m_intVal[1] = v1;
}
void Program::setParam(char const * name, float v0, float v1, float v2, float v3)
void Program::setParam(ESemantic sem, int v0, int v1, int v2)
{
function<void(GLint)> fn = bind(&glUniform4f, _1, v0, v1, v2, v3);
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EIntegerVec3;
f.m_data.m_intVal[0] = v0;
f.m_data.m_intVal[1] = v1;
f.m_data.m_intVal[2] = v2;
}
void Program::setParam(char const * name, int v0)
void Program::setParam(ESemantic sem, int v0, int v1, int v2, int v3)
{
function<void(GLint)> fn = bind(&glUniform1i, _1, v0);
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EIntegerVec4;
f.m_data.m_intVal[0] = v0;
f.m_data.m_intVal[1] = v1;
f.m_data.m_intVal[2] = v2;
f.m_data.m_intVal[3] = v3;
}
void Program::setParam(char const * name, int v0, int v1)
void Program::setParam(ESemantic sem, math::Matrix<float, 2, 2> const & m)
{
function<void(GLint)> fn = bind(&glUniform2i, _1, v0, v1);
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EFloatMat2;
copy(&m(0, 0), &m(0, 0) + 2 * 2, f.m_data.m_matVal);
}
void Program::setParam(char const * name, int v0, int v1, int v2)
void Program::setParam(ESemantic sem, math::Matrix<float, 3, 3> const & m)
{
function<void(GLint)> fn = bind(&glUniform3i, _1, v0, v1, v2);
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
f.m_type = EFloatMat3;
copy(&m(0, 0), &m(0, 0) + 3 * 3, f.m_data.m_matVal);
}
void Program::setParam(char const * name, int v0, int v1, int v2, int v3)
void Program::setParam(ESemantic sem, math::Matrix<float, 4, 4> const & m)
{
function<void(GLint)> fn = bind(&glUniform4i, _1, v0, v1, v2, v3);
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
}
map<ESemantic, Uniform>::iterator it = m_uniforms.find(sem);
ASSERT(it != m_uniforms.end(), ());
Uniform & f = it->second;
void Program::setParam(char const * name, math::Matrix<float, 2, 2> const & m)
{
function<void(GLint)> fn = bind(&glUniformMatrix2fv, _1, 1, 0, &m(0, 0));
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
}
void Program::setParam(char const * name, math::Matrix<float, 3, 3> const & m)
{
function<void(GLint)> fn = bind(&glUniformMatrix3fv, _1, 1, 0, &m(0, 0));
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
}
void Program::setParam(char const * name, math::Matrix<float, 4, 4> const & m)
{
function<void(GLint)> fn = bind(&glUniformMatrix4fv, _1, 1, 0, &m(0, 0));
m_uniforms[name] = bind(&setParamImpl, m_handle, name, fn);
}
void enableAndSetVertexAttrib(GLuint id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void * ptr)
{
OGLCHECK(glEnableVertexAttribArray(id));
OGLCHECK(glVertexAttribPointer(id, size, type, normalized, stride, ptr));
}
void Program::setAttribute(GLuint id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void *ptr)
{
function<void()> fn = bind(&enableAndSetVertexAttrib, id, size, type, normalized, stride, ptr);
m_attributes[id] = fn;
f.m_type = EFloatMat4;
copy(&m(0, 0), &m(0, 0) + 4 * 4, f.m_data.m_matVal);
}
void Program::setVertexDecl(VertexDecl const * decl)
@ -154,15 +221,23 @@ namespace graphics
for (size_t i = 0; i < decl->size(); ++i)
{
VertexAttrib const * va = decl->getAttr(i);
GLuint attrID = getAttribute(va->m_name.c_str());
GLenum glType;
convert(va->m_elemType, glType);
setAttribute(attrID,
va->m_elemCount,
glType,
false,
va->m_stride,
(void*)((unsigned char*)m_storage.m_vertices->glPtr() + va->m_offset));
map<ESemantic, Attribute>::iterator it = m_attributes.find(va->m_semantic);
ASSERT(it != m_attributes.end(), ());
Attribute & a = it->second;
a.m_offset = va->m_offset;
a.m_stride = va->m_stride;
a.m_count = va->m_elemCount;
/// a.m_count could be different from va->m_elemCount
/// as GLSL could provide missing attribute components
/// with default values according to internal rules.
/// (f.e. all components except 4th in vec4 are made 0
/// by default, and 4th is 1 by default).
// ASSERT(a.m_count == va->m_elemCount, ());
ASSERT(a.m_type == va->m_elemType, ());
}
}
@ -171,27 +246,120 @@ namespace graphics
m_storage = storage;
}
void Program::applyAttributes()
{
/// setting all attributes streams;
for (TAttributes::const_iterator it = m_attributes.begin();
it != m_attributes.end();
++it)
{
Attribute const & a = it->second;
GLenum t;
convert(a.m_type, t);
OGLCHECK(glEnableVertexAttribArray(a.m_handle));
OGLCHECK(glVertexAttribPointer(a.m_handle,
a.m_count,
t,
false,
a.m_stride,
(void*)((unsigned char *)m_storage.m_vertices->glPtr() + a.m_offset)));
}
}
void Program::applyUniforms()
{
/// setting all uniforms
for (TUniforms::const_iterator it = m_uniforms.begin();
it != m_uniforms.end();
++it)
{
Uniform const & u = it->second;
switch (u.m_type)
{
case EFloat:
OGLCHECK(glUniform1f(u.m_handle,
u.m_data.m_floatVal[0]));
break;
case EFloatVec2:
OGLCHECK(glUniform2f(u.m_handle,
u.m_data.m_floatVal[0],
u.m_data.m_floatVal[1]));
break;
case EFloatVec3:
OGLCHECK(glUniform3f(u.m_handle,
u.m_data.m_floatVal[0],
u.m_data.m_floatVal[1],
u.m_data.m_floatVal[2]));
break;
case EFloatVec4:
OGLCHECK(glUniform4f(u.m_handle,
u.m_data.m_floatVal[0],
u.m_data.m_floatVal[1],
u.m_data.m_floatVal[2],
u.m_data.m_floatVal[3]));
break;
case EInteger:
OGLCHECK(glUniform1i(u.m_handle,
u.m_data.m_intVal[0]));
break;
case EIntegerVec2:
OGLCHECK(glUniform2i(u.m_handle,
u.m_data.m_intVal[0],
u.m_data.m_intVal[1]));
break;
case EIntegerVec3:
OGLCHECK(glUniform3i(u.m_handle,
u.m_data.m_intVal[0],
u.m_data.m_intVal[1],
u.m_data.m_intVal[2]));
break;
case EIntegerVec4:
OGLCHECK(glUniform4i(u.m_handle,
u.m_data.m_intVal[0],
u.m_data.m_intVal[1],
u.m_data.m_intVal[2],
u.m_data.m_intVal[3]));
break;
case EFloatMat2:
OGLCHECK(glUniformMatrix2fv(u.m_handle,
1,
false,
u.m_data.m_matVal));
break;
case EFloatMat3:
OGLCHECK(glUniformMatrix3fv(u.m_handle,
1,
false,
u.m_data.m_matVal));
break;
case EFloatMat4:
OGLCHECK(glUniformMatrix4fv(u.m_handle,
1,
false,
u.m_data.m_matVal));
break;
case ESampler2D:
OGLCHECK(glUniform1i(u.m_handle,
u.m_data.m_intVal[0]));
break;
}
}
}
void Program::makeCurrent()
{
OGLCHECK(glUseProgramFn(m_handle));
m_storage.m_vertices->makeCurrent();
/// setting all attributes streams;
for (TAttributes::const_iterator it = m_attributes.begin();
it != m_attributes.end();
++it)
{
it->second();
}
applyAttributes();
m_storage.m_indices->makeCurrent();
/// setting all uniforms
for (TUniforms::const_iterator it = m_uniforms.begin();
it != m_uniforms.end();
++it)
it->second();
applyUniforms();
}
}
}

55
graphics/opengl/program.hpp
View file

@ -3,6 +3,8 @@
#include "opengl.hpp"
#include "storage.hpp"
#include "../defines.hpp"
#include "../../base/matrix.hpp"
#include "../../base/exception.hpp"
@ -21,12 +23,36 @@ namespace graphics
{
private:
void applyAttributes();
void applyUniforms();
struct Uniform
{
struct Data
{
float m_matVal[4 * 4];
int m_intVal[4];
float m_floatVal[4];
} m_data;
EDataType m_type;
GLint m_handle;
};
struct Attribute
{
GLint m_handle;
size_t m_offset;
EDataType m_type;
size_t m_count;
size_t m_stride;
};
GLuint m_handle;
typedef map<string, function<void()> > TUniforms;
typedef map<ESemantic, Uniform> TUniforms;
TUniforms m_uniforms;
typedef map<GLuint, function<void()> > TAttributes;
typedef map<ESemantic, Attribute> TAttributes;
TAttributes m_attributes;
Storage m_storage;
@ -43,22 +69,19 @@ namespace graphics
unsigned getParam(char const * name);
void setParam(char const * name, float v0);
void setParam(char const * name, float v0, float v1);
void setParam(char const * name, float v0, float v1, float v2);
void setParam(char const * name, float v0, float v1, float v2, float v3);
void setParam(ESemantic sem, float v0);
void setParam(ESemantic sem, float v0, float v1);
void setParam(ESemantic sem, float v0, float v1, float v2);
void setParam(ESemantic sem, float v0, float v1, float v2, float v3);
void setParam(char const * name, int v0);
void setParam(char const * name, int v0, int v1);
void setParam(char const * name, int v0, int v1, int v2);
void setParam(char const * name, int v0, int v1, int v2, int v3);
void setParam(ESemantic sem, int v0);
void setParam(ESemantic sem, int v0, int v1);
void setParam(ESemantic sem, int v0, int v1, int v2);
void setParam(ESemantic sem, int v0, int v1, int v2, int v3);
void setParam(char const * name, math::Matrix<float, 2, 2> const & m);
void setParam(char const * name, math::Matrix<float, 3, 3> const & m);
void setParam(char const * name, math::Matrix<float, 4, 4> const & m);
GLuint getAttribute(char const * name);
void setAttribute(GLuint id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void * ptr);
void setParam(ESemantic sem, math::Matrix<float, 2, 2> const & m);
void setParam(ESemantic sem, math::Matrix<float, 3, 3> const & m);
void setParam(ESemantic sem, math::Matrix<float, 4, 4> const & m);
void setVertexDecl(VertexDecl const * decl);

36
graphics/opengl/program_manager.cpp
View file

@ -17,13 +17,13 @@ namespace graphics
static const char vxSrc[] =
"attribute vec4 Position;\n"
"attribute vec2 Normal;\n"
"attribute vec2 TexCoordIn;\n"
"uniform mat4 ProjM;\n"
"uniform mat4 ModelViewM;\n"
"varying vec2 TexCoordOut;\n"
"attribute vec2 TexCoord0;\n"
"uniform mat4 Projection;\n"
"uniform mat4 ModelView;\n"
"varying vec2 TexCoordOut0;\n"
"void main(void) {\n"
" gl_Position = (vec4(Normal, 0.0, 0.0) + Position * ModelViewM) * ProjM;\n"
" TexCoordOut = TexCoordIn;\n"
" gl_Position = (vec4(Normal, 0.0, 0.0) + Position * ModelView) * Projection;\n"
" TexCoordOut0 = TexCoord0;\n"
"}\n";
m_vxShaders["basic"].reset(new Shader(vxSrc, EVertexShader));
@ -33,13 +33,13 @@ namespace graphics
static const char sharpVxSrc[] =
"attribute vec4 Position;\n"
"attribute vec2 Normal;\n"
"attribute vec2 TexCoordIn;\n"
"uniform mat4 ProjM;\n"
"uniform mat4 ModelViewM;\n"
"varying vec2 TexCoordOut;\n"
"attribute vec2 TexCoord0;\n"
"uniform mat4 Projection;\n"
"uniform mat4 ModelView;\n"
"varying vec2 TexCoordOut0;\n"
"void main(void) {\n"
" gl_Position = floor(vec4(Normal, 0.0, 0.0) + Position * ModelViewM) * ProjM;\n"
" TexCoordOut = TexCoordIn;\n"
" gl_Position = floor(vec4(Normal, 0.0, 0.0) + Position * ModelView) * Projection;\n"
" TexCoordOut0 = TexCoord0;\n"
"}\n";
m_vxShaders["sharp"].reset(new Shader(sharpVxSrc, EVertexShader));
@ -47,10 +47,10 @@ namespace graphics
/// Fragment Shader with alphaTest
static const char alphaTestFrgSrc [] =
"uniform sampler2D Texture;\n"
"varying " PRECISION " vec2 TexCoordOut;\n"
"uniform sampler2D Sampler0;\n"
"varying " PRECISION " vec2 TexCoordOut0;\n"
"void main(void) {\n"
" gl_FragColor = texture2D(Texture, TexCoordOut);\n"
" gl_FragColor = texture2D(Sampler0, TexCoordOut0);\n"
" if (gl_FragColor.a == 0.0)\n"
" discard;\n"
"}\n";
@ -60,10 +60,10 @@ namespace graphics
/// Fragment shader without alphaTest
static const char noAlphaTestFrgSrc[] =
"uniform sampler2D Texture;\n"
"varying " PRECISION " vec2 TexCoordOut;\n"
"uniform sampler2D Sampler0;\n"
"varying " PRECISION " vec2 TexCoordOut0;\n"
"void main(void) {\n"
" gl_FragColor = texture2D(Texture, TexCoordOut);\n"
" gl_FragColor = texture2D(Sampler0, TexCoordOut0);\n"
"}\n";
m_frgShaders["noalphatest"].reset(new Shader(noAlphaTestFrgSrc, EFragmentShader));

6
graphics/opengl/vertex.cpp
View file

@ -43,9 +43,9 @@ namespace graphics
{
static VertexAttrib attrs [] =
{
VertexAttrib("Position", vertexOffset, EFloat, 3, sizeof(Vertex)),
VertexAttrib("Normal", normalOffset, EFloat, 2, sizeof(Vertex)),
VertexAttrib("TexCoordIn", texCoordOffset, EFloat, 2, sizeof(Vertex))
VertexAttrib(ESemPosition, vertexOffset, EFloat, 3, sizeof(Vertex)),
VertexAttrib(ESemNormal, normalOffset, EFloat, 2, sizeof(Vertex)),
VertexAttrib(ESemTexCoord0, texCoordOffset, EFloat, 2, sizeof(Vertex))
};
static VertexDecl vd(attrs, ARRAY_SIZE(attrs));

8
graphics/vertex_decl.cpp
View file

@ -2,16 +2,16 @@
namespace graphics
{
VertexAttrib::VertexAttrib(char const * name,
VertexAttrib::VertexAttrib(ESemantic semantic,
size_t offset,
EDataType elemType,
size_t elemCount,
size_t stride)
: m_offset(offset),
: m_semantic(semantic),
m_offset(offset),
m_elemType(elemType),
m_elemCount(elemCount),
m_stride(stride),
m_name(name)
m_stride(stride)
{}
VertexDecl::VertexDecl(VertexAttrib const * attrs, size_t cnt)

4
graphics/vertex_decl.hpp
View file

@ -10,13 +10,13 @@ namespace graphics
/// Single attribute of vertex.
struct VertexAttrib
{
ESemantic m_semantic;
size_t m_offset;
EDataType m_elemType;
size_t m_elemCount;
size_t m_stride;
string m_name;
VertexAttrib(char const * name,
VertexAttrib(ESemantic semantic,
size_t offset,
EDataType elemType,
size_t elemCount,