void Shader::CompileShader()
{
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Error linking shader program");
// glGetProgramiv(program, GL_LINK_STATUS, &success);
//if (success == 0)
//{
// glGetProgramInfoLog(program, sizeof(error), NULL, ErrorLog);
// fprintf(stderr, "Error linking shader program: '%s'\n", ErrorLog);
// exit(1);
//}
glValidateProgram(m_program);
CheckShaderError(m_program, GL_VALIDATE_STATUS, true, "Invalid shader program");
//glGetProgramiv(program, GL_VALIDATE_STATUS, &Success);
//if (!success) {
// glGetProgramInfoLog(ShaderProgram, sizeof(error), NULL, ErrorLog);
// fprintf(stderr, "Invalid shader program: '%s'\n", ErrorLog);
// exit(1);
//}
//glUseProgram(program);
//gScaleLocation = glGetUniformLocation(ShaderProgram, "gScale");
//assert(gScaleLocation != 0xFFFFFFFF);
}
void ShaderData::CompileShader() {
glLinkProgram(program);
CheckShaderError(program, GL_LINK_STATUS, true, "Error linking shader program");
glValidateProgram(program);
CheckShaderError(program, GL_VALIDATE_STATUS, true, "Invalid shader program");
}
Shader(const std::string &fileName)
{
program_ = glCreateProgram();
// Vertex shader
shaders_[0] = CreateShader(LoadShader(fileName + ".vs"),
GL_VERTEX_SHADER);
// Fragment shader
shaders_[1] = CreateShader(LoadShader(fileName + ".fs"),
GL_FRAGMENT_SHADER);
for (unsigned i = 0 ; i < NUM_SHADERS; ++i)
glAttachShader(program_,shaders_[i]);
glBindAttribLocation(program_, 0, "position");
glBindAttribLocation(program_, 1, "texCoord");
glLinkProgram(program_);
CheckShaderError(program_, GL_LINK_STATUS, true, "Error: Program linking failed");
glValidateProgram(program_);
CheckShaderError(program_, GL_VALIDATE_STATUS, true, "Error: Program is invalid");
uniforms_[TRANSFORM_U] = glGetUniformLocation(program_, "transform");
}
void Shader::CreateShader(GLenum shaderType, const std::string& fileName)
{
//load data from file
std::string fileShaderData = LoadUtil::LoadShader(fileName);
if (fileShaderData == "")
{
return;
}
const GLchar* shaderData[1];
GLint shaderDataLength[1];
shaderData[0] = fileShaderData.c_str();
shaderDataLength[0] = fileShaderData.length();
//create shader
GLuint shader = glCreateShader(shaderType);
if (shader == 0)
std::cerr << "Error: Shader creation failure!" << std::endl;
//upload shader
glShaderSource(shader, 1, shaderData, shaderDataLength);
glCompileShader(shader);
m_shaderList.push_back(shader);
//check for errors
CheckShaderError(shader, GL_COMPILE_STATUS, false, "Error: Shader compilation failure! : " + fileName);
}
Shader::Shader(const std::string& filename)
{
m_shaders[0] = CreateShader("./Res/Shaders/" + filename + ".vs", GL_VERTEX_SHADER); //Creates shader ID
m_shaders[1] = CreateShader("./Res/Shaders/" + filename + ".fs", GL_FRAGMENT_SHADER);
m_program = glCreateProgram();
glAttachShader(m_program, m_shaders[0]);
glAttachShader(m_program, m_shaders[1]);
glLinkProgram(m_program);
CheckShaderError(m_program, true, GL_LINK_STATUS, "Error: Program linking failed.");
glValidateProgram(m_program);
CheckShaderError(m_program, true, GL_VALIDATE_STATUS, "Error: Program validation failed.");
glUseProgram(m_program);
}
Shader::Shader(const std::string& fileName){
m_program = glCreateProgram();
m_shaders[0] = createShader(LoadShader(fileName) + ".vs", GL_VERTEX_SHADER);
m_shaders[0] = createShader(LoadShader(fileName) + ".fs", GL_FRAGMENT_SHADER);
for (unsigned int i = 0; i < NUM_SHADERS; i++){
glAttachShader(m_program, m_shaders[i]);
}
glBindAttribLocation(m_program, 0, "position");
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Error: Program linking failure: ");
glValidateProgram(m_program);
CheckShaderError(m_program, GL_VALIDATE_STATUS, true, "Error: Program linking failure: ");
}
Shader::Shader(const std::string& fileName)
{
m_program = glCreateProgram();
m_shaders[0] = CreateShader(LoadShader(fileName + ".vs"), GL_VERTEX_SHADER);
m_shaders[1] = CreateShader(LoadShader(fileName + ".fs"), GL_FRAGMENT_SHADER);
for(unsigned int i = 0; i < NUM_SHADERS; i++)
glAttachShader(m_program, m_shaders[i]);
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Error linking shader program");
glValidateProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Invalid shader program");
m_uniforms[0] = glGetUniformLocation(m_program, "MVP");
m_uniforms[1] = glGetUniformLocation(m_program, "Normal");
m_uniforms[2] = glGetUniformLocation(m_program, "lightDirection");
}
Shader::Shader(const std::string& fileName)
{
m_program = glCreateProgram();
m_shaders[0] = CreateShader(LoadShader(fileName + ".vsh"), GL_VERTEX_SHADER);
m_shaders[1] = CreateShader(LoadShader(fileName + ".fsh"), GL_FRAGMENT_SHADER);
for (unsigned int i = 0; i < NUM_SHADERS; i++)
glAttachShader(m_program, m_shaders[i]);
glBindAttribLocation(m_program, 0, "position");
glBindAttribLocation(m_program, 1, "texCoord");
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Error linking shader program");
glValidateProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Invalid shader program");
m_uniforms[TRANSFORM_U] = glGetUniformLocation(m_program, "transform");
}
void GLComputeShader::loadShader(const std::string & fileName)
{
m_program = glCreateProgram();
GLuint m_shader = CreateShader(LoadShader(fileName + ".compute.glsl"), GL_COMPUTE_SHADER);
glAttachShader(m_program, m_shader);
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true);
}
void Shader::init(const std::string& fileName){
m_program = glCreateProgram();
m_shaders[0] = CreateShader(LoadShader(fileName + ".vs"), GL_VERTEX_SHADER);
m_shaders[1] = CreateShader(LoadShader(fileName + ".fs"), GL_FRAGMENT_SHADER);
for(unsigned int i = 0; i < NUM_SHADERS; i++)
glAttachShader(m_program, m_shaders[i]);
//this maps the variavles in the vertex shader to the
//data in functions out
glBindAttribLocation(m_program, 0, "position");
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Error linking shader program");
glValidateProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Invalid shader program");
m_uniforms[TRANSFORM_U] = glGetUniformLocation(m_program, "transform");
m_uniforms[COLOR_U] = glGetUniformLocation(m_program, "color");
}//end func
unsigned int Renderer::CreateShaderProgram(unsigned int* shaders, int numShaders)
{
unsigned int program = glCreateProgram();
for(int i = 0; i < numShaders; i++)
glAttachShader(program, shaders[i]);
glLinkProgram(program);
CheckShaderError(program, GL_LINK_STATUS, true, "Error linking shader program");
return program;
}
GLuint Shader::CreateShader(const std::string& text, unsigned int type)
{
GLuint shader = glCreateShader(type);
if (shader == 0)
std::cerr << "Error compiling shader type " << type << std::endl;
const GLchar* p[1];
p[0] = text.c_str();
GLint lengths[1];
lengths[0] = text.length();
glShaderSource(shader, 1, p, lengths);
glCompileShader(shader);
CheckShaderError(shader, GL_COMPILE_STATUS, false, "Error compiling shader!");
return shader;
}
void Shader::CreateProgram()
{
//create program and apply shaders
m_program = glCreateProgram();
for each (GLuint shader in m_shaderList)
glAttachShader(m_program, shader);
glBindAttribLocation(m_program, 0, "position");
glBindAttribLocation(m_program, 1, "texCoord");
glBindAttribLocation(m_program, 2, "normal");
//link,validate and check for errors
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Error: Program linking failure");
glValidateProgram(m_program);
CheckShaderError(m_program, GL_VALIDATE_STATUS, true, "Error: Program validation failure");
//delete shaders
for each(GLuint shader in m_shaderList)
{
glDetachShader(m_program, shader);
glDeleteShader(shader);
}
Shader::Shader(std::string filePath)
{
//---------------------------------------------------------------------------
//CREATE PROGRAM AND ADD SHADERS
//---------------------------------------------------------------------------
shaderProgram = glCreateProgram();
vertexShader = createShader(loadShader("./res/shaders/" + filePath + "/vertex.vsh"), GL_VERTEX_SHADER);
fragmentShader = createShader(loadShader("./res/shaders/" + filePath + "/fragment.fsh"), GL_FRAGMENT_SHADER);
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
//---------------------------------------------------------------------------
//ATTRIBUTES
//---------------------------------------------------------------------------
glBindAttribLocation(shaderProgram, 0, "position");
glBindAttribLocation(shaderProgram, 1, "rgbColor");
glBindAttribLocation(shaderProgram, 2, "texCoords");
//---------------------------------------------------------------------------
//LINK PROGRAM
//---------------------------------------------------------------------------
glLinkProgram(shaderProgram);
CheckShaderError(shaderProgram, GL_LINK_STATUS, true, "Error: Program linking failed: ");
glValidateProgram(shaderProgram);
CheckShaderError(shaderProgram, GL_VALIDATE_STATUS, true, "Error: Program is invalid: ");
//---------------------------------------------------------------------------
//UNIFORMS
//---------------------------------------------------------------------------
//transform
uniforms[TRANSFORM] = glGetUniformLocation(shaderProgram, "transform");
//color
uniforms[OVERRIDE_COLOR] = glGetUniformLocation(shaderProgram, "overrideColor");
glUniform3f(uniforms[OVERRIDE_COLOR], 1.0f, 1.0f, 1.0f);
}
Shader::Shader(const char* fileNameVs, const char* fileNameFs)
{
m_program = glCreateProgram();
m_shaders[0] = CreateShader(LoadShader(fileNameVs), GL_VERTEX_SHADER);
m_shaders[1] = CreateShader(LoadShader(fileNameFs), GL_FRAGMENT_SHADER);
for (unsigned int i = 0; i < NUM_SHADERS; i++)
glAttachShader(m_program, m_shaders[i]);
glBindAttribLocation(m_program, 0, "position");
//glBindAttribLocation(m_program, 1, "texCoord");
glBindAttribLocation(m_program, 1, "normal");
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Error linking shader program");
glValidateProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Invalid shader program");
m_uniforms[TRANSFORM_U] = glGetUniformLocation(m_program, "transform");
/*m_uniforms[0] = glGetUniformLocation(m_program, "MVP");
m_uniforms[1] = glGetUniformLocation(m_program, "Normal");
m_uniforms[2] = glGetUniformLocation(m_program, "lightDirection");*/
}
GLuint Shader::CreateShader(const std::string& filename, GLenum shaderType)
{
GLuint shader = glCreateShader(shaderType);
if (!shader) {
std::cout << "Error: Shader creation failed." << std::endl;
return -1;
}
LoadShader(shader, filename);
glCompileShader(shader); //Compiling the shader
CheckShaderError(shader, false, GL_COMPILE_STATUS, "Error: Vertex shader compilation failed.");
return shader;
}
static GLuint CreateShader(const std::string& source, GLenum shaderType) {
GLuint shaderId = glCreateShader(shaderType);
if (shaderId == 0)
std::cerr << "Error: Shader creation failed!" << std::endl;
// Compile Shader
std::cout << "Compiling Shader: " << shaderType << std::endl;
char const * ShaderSourcePointer = source.c_str();
glShaderSource(shaderId, 1, &ShaderSourcePointer, NULL);
glCompileShader(shaderId);
CheckShaderError(shaderId, "Shader compilation failed");
return shaderId;
}
GLuint Shader::CreateShader(const std::string& text, GLenum shaderType)
{
GLuint shader = glCreateShader(shaderType);
if (shader == 0)
LOG("Graphics", "Error: Error compiling shader type " + shaderType);
const GLchar* shaderSourceStrings[1];
shaderSourceStrings[0] = text.c_str();
GLint shaderSourceStringLengths[1];
shaderSourceStringLengths[0] = text.length();
glShaderSource(shader, 1, shaderSourceStrings, shaderSourceStringLengths);
glCompileShader(shader);
CheckShaderError(shader, GL_COMPILE_STATUS, false, "Error compiling shader!");
return shader;
}
GLuint GLShader::CreateShader(const std::string & text, GLenum shaderType)
{
GLuint shader = glCreateShader(shaderType);
if (shader == 0)
{
OutputDebugStringA((char*)"Error: Shader creation failed!");
}
const char* shaderTextPtr = text.c_str();
glShaderSource(shader, 1, &shaderTextPtr, nullptr);
glCompileShader(shader);
CheckShaderError(shader, GL_COMPILE_STATUS, false);
return shader;
}
void Shader::CreateProgram()
{
size_t i;
for (i = 0; i < m_NumShaders; i++)
{
m_Shaders[i] = CompileShader(m_ShaderTypes[i]);
if (!CheckShaderError(m_Shaders[i], shaderFileNames[i]))
glAttachShader(m_ProgramID, m_Shaders[i]);
}
glBindAttribLocation(m_ProgramID, 0, "position");
glBindAttribLocation(m_ProgramID, 1, "texCoord");
glLinkProgram(m_ProgramID);
if (CheckProgramError(m_ProgramID))
glDeleteProgram(m_ProgramID);
for (i = 0; i < m_NumShaders; i++)
glDeleteShader(m_Shaders[i]); // flag each shader for deletion when the program gets deleted, avoids memory leaks.
}
static GLuint createShader(const std::string& text, GLenum shaderType)
{
GLuint shader = glCreateShader(shaderType);
if (shader == 0)
std::cerr << "Error: Shader Creation failed!" << std::endl;
const GLchar* shaderSourceStrings[1];
GLint shaderSourceStringLengths[1];
shaderSourceStrings[0] = text.c_str();
shaderSourceStringLengths[0] = text.length();
glShaderSource(shader, 1, shaderSourceStrings, shaderSourceStringLengths);
glCompileShader(shader);
CheckShaderError(shader, GL_COMPILE_STATUS, false, "Error: Program compilation failed: ");
return shader;
}
GLShader::GLShader(const std::string& fileName)
{
//create program
m_program = glCreateProgram();
m_shaders[0] = CreateShader(LoadShader(fileName + ".vert.glsl"), GL_VERTEX_SHADER);
m_shaders[1] = CreateShader(LoadShader(fileName + ".frag.glsl"), GL_FRAGMENT_SHADER);
m_shaders[2] = CreateShader(LoadShader(fileName + ".geom.glsl"), GL_GEOMETRY_SHADER);
for (unsigned int i = 0; i < NUM_SHADERS; i++)
{
glAttachShader(m_program, m_shaders[i]);
}
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true);
m_uniforms[TRANSFROM_U] = glGetUniformLocation(m_program, "TransformMatrix");
m_uniforms[PROJVIEW_U] = glGetUniformLocation(m_program, "ProjectionViewMatrix");
m_uniforms[VIEWPOS_U] = glGetUniformLocation(m_program, "ViewPos");
}
Shader::Shader(const std::string& fileName) {
// Create program
m_program = glCreateProgram();
// Create shaders
m_shaders[0] = CreateShader(LoadShader(fileName + ".vertexshader"), GL_VERTEX_SHADER);
m_shaders[1] = CreateShader(LoadShader(fileName + ".fragmentshader"), GL_FRAGMENT_SHADER);
// Link the program
for (unsigned int i = 0; i < NUM_SHADERS; i++) {
glAttachShader(m_program, m_shaders[i]);
}
glLinkProgram(m_program);
// Check if linking worked
CheckShaderError(m_program, GL_LINK_STATUS, true, "Error: Program linking failed");
// Check if program is valid
// Can only be done after vertex array object is bound
// TODO Add the validation to the mesh (After the Vertex Array Object is bound)
//glValidateProgram(m_program);
//CheckShaderError(m_program, GL_VALIDATE_STATUS, true, "Error: Program is invalid");
}
static inline unsigned int CreateShader(const std::string& text, unsigned int type)
{
GLuint shader = glCreateShader(type);
//std::cout << text << std::endl;
std::stringstream errorMessage;
errorMessage << "Error compiling shader type " << type;
if(shader == 0)
Engine::GetDisplay()->Error(errorMessage.str());
const GLchar* p[1];
p[0] = text.c_str();
GLint lengths[1];
lengths[0] = text.length();
glShaderSource(shader, 1, p, lengths);
glCompileShader(shader);
CheckShaderError(shader, GL_COMPILE_STATUS, false, errorMessage.str());
return shader;
}
/**
* Creates the shader program used
*/
GLuint Shader::CreateShader(const std::string& text, GLenum type){
GLuint shader = glCreateShader(type);
if(shader == 0)
std::cerr << "Error compiling shader type " << type << std::endl;
const GLchar* shaderSourceString[1];
shaderSourceString[0] = text.c_str();
GLint shaderSourceLength[1];
shaderSourceLength[0] = text.length();
glShaderSource(shader,//the acutal shader
1,//the number of sources
shaderSourceString,//string cont
shaderSourceLength);//string len
glCompileShader(shader);
CheckShaderError(shader, GL_COMPILE_STATUS, false,//its just a shader only
"Error compiling shader!");
return shader;
}//end func
GLuint Shader::CreateShader(const std::string& text, GLenum shaderType) {
// Create shader
GLuint shader = glCreateShader(shaderType);
if ( shader == 0 ) {
// TODO Error Handling (Shader creation failed)
std::cerr << "Shader creation failed" << std::endl;
}
// Compile shader
const GLchar* shaderSourceStrings[1];
GLint shaderSourceStringLengths[1];
shaderSourceStrings[0] = text.c_str();
shaderSourceStringLengths[0] = text.length();
glShaderSource(shader, 1, shaderSourceStrings, shaderSourceStringLengths);
glCompileShader(shader);
// Check if shader was compiled correctly
CheckShaderError(shader, GL_COMPILE_STATUS, false, "Error: Shader compilation failed");
// return compiled shader
return shader;
}
int init_shaders()
{
GLchar vShaderStr[] =
"attribute vec3 position; \n"
"attribute vec2 texCoord; \n"
"varying vec2 texCoord0; \n"
"uniform mat4 MVP; \n"
"uniform int v_text; \n"
"void main() \n"
"{ \n"
" texCoord0 = texCoord; \n"
" if(v_text == 0) \n"
" {gl_Position = vec4(position, 1.0);} \n"
" else \n"
" {gl_Position = MVP * vec4(position, 1.0);} \n"
"} \n";
GLchar fShaderStr[] =
"varying vec2 texCoord0; \n"
"uniform sampler2D sampler; \n"
"uniform int f_text; \n"
"void main() \n"
"{ \n"
" if(f_text == 0) \n"
" {gl_FragColor = vec4(texture2D(sampler,texCoord0).rgb,1.0);}\n"
" else \n"
" {gl_FragColor = vec4(0.9,0.9,0.9,texture2D(sampler,texCoord0).a);} \n"
"} \n";
const GLchar* vShaderPtr = vShaderStr;
const GLchar* fShaderPtr = fShaderStr;
memset( &m_shader, 0, sizeof(shader) );
m_shader.m_program = glCreateProgram();
m_shader.m_shaders[0] = glCreateShader(GL_VERTEX_SHADER);
m_shader.m_shaders[1] = glCreateShader(GL_FRAGMENT_SHADER);
if(m_shader.m_shaders[0] == 0)
{
printf("Error compiling VRETEX shader.\n");
glDeleteShader(m_shader.m_shaders[0]);
glDeleteShader(m_shader.m_shaders[1]);
exit(-1);
}
else if(m_shader.m_shaders[1] == 0)
{
printf("Error compiling FRAGMENT shader.\n");
glDeleteShader(m_shader.m_shaders[0]);
glDeleteShader(m_shader.m_shaders[1]);
exit(-1);
}
glShaderSource(m_shader.m_shaders[0], 1, &vShaderPtr, NULL);
glCompileShader(m_shader.m_shaders[0]);
CheckShaderError(m_shader.m_shaders[0], GL_COMPILE_STATUS, false);
glShaderSource(m_shader.m_shaders[1], 1, &fShaderPtr, NULL);
glCompileShader(m_shader.m_shaders[1]);
CheckShaderError(m_shader.m_shaders[1], GL_COMPILE_STATUS, false);
glAttachShader (m_shader.m_program, m_shader.m_shaders[0]);
glAttachShader (m_shader.m_program, m_shader.m_shaders[1]);
glLinkProgram(m_shader.m_program);
CheckShaderError(m_shader.m_program, GL_LINK_STATUS, true);
glValidateProgram(m_shader.m_program);
CheckShaderError(m_shader.m_program, GL_LINK_STATUS, true);
glUseProgram(m_shader.m_program);
return (0);
}
void Renderer::ValidateShaderProgram(unsigned int program)
{
glValidateProgram(program);
CheckShaderError(program, GL_VALIDATE_STATUS, true, "Invalid shader program");
}
Shader::Shader(const std::string& fileNameVS, const std::string& fileNameFS):
m_fogEnabled(true)
{
m_program = glCreateProgram();
m_lightPosition = glm::vec3(0, 100, 100);
m_lightDirection = glm::vec3(0, 0, 0);
m_shaders[0] = CreateShader(
Loader::LoadFileContent(fileNameVS),
GL_VERTEX_SHADER
);
m_shaders[1] = CreateShader(
Loader::LoadFileContent(fileNameFS),
GL_FRAGMENT_SHADER
);
for (unsigned int i = 0; i < NUM_SHADERS; i++)
glAttachShader(m_program, m_shaders[i]);
glBindAttribLocation(m_program, 0, "position");
glBindAttribLocation(m_program, 1, "texCoord");
glBindAttribLocation(m_program, 2, "normal");
glLinkProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Error linking shader program");
glValidateProgram(m_program);
CheckShaderError(m_program, GL_LINK_STATUS, true, "Invalid shader program");
// MVP
m_uniforms[UNIFORM_MODEL_MATRIX_LOCATION] = glGetUniformLocation(m_program, "modelMat");
m_uniforms[UNIFORM_VIEW_MATRIX_LOCATION] = glGetUniformLocation(m_program, "viewMat");
m_uniforms[UNIFORM_PROJ_MATRIX_LOCATION] = glGetUniformLocation(m_program, "projectionMat");
// NORMAL
m_uniforms[UNIFORM_NORMAL_LOCATION] = glGetUniformLocation(m_program, "normalMat");
// LIGHT
m_uniforms[UNIFORM_LIGHT_POSITION_LOCATION] = glGetUniformLocation(m_program, "light.position");
m_uniforms[UNIFORM_LIGHT_DIRECTION_LOCATION] = glGetUniformLocation(m_program, "light.direction");
m_uniforms[UNIFORM_LIGHT_ATTENTUATION_LOCATION] = glGetUniformLocation(m_program, "light.attentuation");
m_uniforms[UNIFORM_LIGHT_COLOR_LOCATION] = glGetUniformLocation(m_program, "light.color");
// FOG
m_uniforms[UNIFORM_FOG_ENABLED] = glGetUniformLocation(m_program, "enableFog");
// MATERIAL
m_uniforms[UNIFORM_MAT_DIFFUSE_LOCATION] = glGetUniformLocation(m_program, "meshMat.diffuse");
m_uniforms[UNIFORM_MAT_AMBIENT_LOCATION] = glGetUniformLocation(m_program, "meshMat.ambient");
m_uniforms[UNIFORM_MAT_SPECULAR_LOCATION] = glGetUniformLocation(m_program, "meshMat.specular");
m_uniforms[UNIFORM_MAT_EMISSIVE_LOCATION] = glGetUniformLocation(m_program, "meshMat.emissive");
m_uniforms[UNIFORM_MAT_SHINE_LOCATION] = glGetUniformLocation(m_program, "meshMat.shininess");
// TEXTURE SAMPLER
m_uniforms[UNIFORM_TEX_SAMPLER_0] = glGetUniformLocation(m_program, "texSampler0");
m_uniforms[UNIFORM_TEX_SAMPLER_1] = glGetUniformLocation(m_program, "texSampler1");
m_uniforms[UNIFORM_TEX_SAMPLER_2] = glGetUniformLocation(m_program, "texSampler2");
m_uniforms[UNIFORM_TEX_SAMPLER_3] = glGetUniformLocation(m_program, "texSampler3");
// TIME
m_uniforms[UNIFORM_TIME_LOCATION] = glGetUniformLocation(m_program, "time");
}