Shader::Shader(const std::string &vertex_shader_code, const std::string &fragment_shader_code) {
// Create shaders
auto vertex_shader_id = glCreateShader(GL_VERTEX_SHADER);
auto fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER);
auto result = GL_FALSE;
auto info_length = 0;
// Compile vertex shader
auto vertex_shader_code_ptr = vertex_shader_code.c_str();
glShaderSource(vertex_shader_id, 1, &vertex_shader_code_ptr, NULL);
glCompileShader(vertex_shader_id);
// Check vertex shader log
glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS, &result);
if (result == GL_FALSE) {
glGetShaderiv(vertex_shader_id, GL_INFO_LOG_LENGTH, &info_length);
std::string vertex_shader_log((unsigned int) info_length, ' ');
glGetShaderInfoLog(vertex_shader_id, info_length, NULL,
&vertex_shader_log[0]);
std::cout << "Error Compiling Vertex Shader ..." << std::endl;
std::cout << vertex_shader_log << std::endl;
}
// Compile fragment shader
auto fragment_shader_code_ptr = fragment_shader_code.c_str();
glShaderSource(fragment_shader_id, 1, &fragment_shader_code_ptr, NULL);
glCompileShader(fragment_shader_id);
// Check fragment shader log
glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS, &result);
if (result == GL_FALSE) {
glGetShaderiv(fragment_shader_id, GL_INFO_LOG_LENGTH, &info_length);
std::string fragment_shader_log((unsigned long) info_length, ' ');
glGetShaderInfoLog(fragment_shader_id, info_length, NULL,
&fragment_shader_log[0]);
std::cout << "Error Compiling Fragment Shader ..." << std::endl;
std::cout << fragment_shader_log << std::endl;
}
// Create and link the program
auto program_id = glCreateProgram();
glAttachShader(program_id, vertex_shader_id);
glAttachShader(program_id, fragment_shader_id);
glBindFragDataLocation(program_id, 0, "FragmentColor");
glLinkProgram(program_id);
// Check program log
glGetProgramiv(program_id, GL_LINK_STATUS, &result);
if (result == GL_FALSE) {
glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &info_length);
std::string program_log((unsigned long) info_length, ' ');
glGetProgramInfoLog(program_id, info_length, NULL, &program_log[0]);
std::cout << "Error Linking Shader Program ..." << std::endl;
std::cout << program_log << std::endl;
}
glDeleteShader(vertex_shader_id);
glDeleteShader(fragment_shader_id);
program = program_id;
}
void __shaderStuff(Shader& s) {
s.Link();
s.Use();
glBindFragDataLocation(s.ProgramHandle, 0, "outColor");
glUniform1i(glGetUniformLocation(s.ProgramHandle, "tex"), 0);
GLint posAttrib = glGetAttribLocation(s.ProgramHandle, "position");
glEnableVertexAttribArray(posAttrib);
checkGL;
glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 9, 0);
checkGL;
GLint tposAttrib = glGetAttribLocation(s.ProgramHandle, "texpos");
checkGL;
glEnableVertexAttribArray(tposAttrib);
checkGL;
glVertexAttribPointer(tposAttrib, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 9, (void*)(sizeof(float) * 3));
checkGL;
GLint colAttrib = glGetAttribLocation(s.ProgramHandle, "color");
checkGL;
glEnableVertexAttribArray(colAttrib);
checkGL;
glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 9, (void*)(sizeof(float) * 5));
}
/**
* Vraci program (zkompilovane shadery) pro renderovani uzivatelskeho pohledu
*/
GLuint Shaders::getUserViewProgram() {
const char *p_s_vertex_shader =
"#version 330\n"
"in vec3 v_pos;\n" // atributy - vstup z dat vrcholu
"in vec3 v_col;\n" // barva vrcholu
"\n"
"uniform mat4 t_modelview_projection_matrix;\n" // parametr shaderu - transformacni matice
"\n"
"out vec3 v_color;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = t_modelview_projection_matrix * vec4(v_pos, 1.0);\n" // musime zapsat pozici
" v_color = v_col;\n"
"}\n";
const char *p_s_fragment_shader =
"#version 330\n"
"in vec3 v_color;\n" // vstupy z vertex shaderu
"\n"
"out vec4 frag_color;\n" // vystup do framebufferu
"\n"
"void main()\n"
"{\n"
" frag_color = vec4(v_color, 1.0f);\n"
"}\n";
// zkompiluje vertex / fragment shader, pripoji je k programu
n_user_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(n_user_vertex_shader, 1, &p_s_vertex_shader, NULL);
glCompileShader(n_user_vertex_shader);
if(!CheckShader(n_user_vertex_shader, "vertex shader"))
return false;
n_user_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(n_user_fragment_shader, 1, &p_s_fragment_shader, NULL);
glCompileShader(n_user_fragment_shader);
if(!CheckShader(n_user_fragment_shader, "fragment shader"))
return false;
n_user_program_object = glCreateProgram();
glAttachShader(n_user_program_object, n_user_vertex_shader);
glAttachShader(n_user_program_object, n_user_fragment_shader);
// nabinduje atributy (propojeni mezi obsahem VBO a vstupem do vertex shaderu)
glBindAttribLocation(n_user_program_object, 0, "v_pos");
glBindAttribLocation(n_user_program_object, 1, "v_col");
// nabinduje vystupni promenou (propojeni mezi framebufferem a vystupem fragment shaderu)
glBindFragDataLocation(n_user_program_object, 0, "frag_color");
// slinkuje program
glLinkProgram(n_user_program_object);
if(!CheckProgram(n_user_program_object, "program"))
return false;
else
return n_user_program_object;
}
/*
* Erstellt ein Shaderprogramm aus den angegebenen Shaderdateien.
* Liefert den Index, an dessen Postion das Progemm und die einzelnen Shader in den Vektoren gespeichert werden.
*/
int OpenGLRenderer::createProgram(QString vertexPath, QString pixelPath) {
// Shader laden
GLuint vertex_ID = glCreateShader(GL_VERTEX_SHADER);
GLuint pixel_ID = glCreateShader(GL_FRAGMENT_SHADER);
//const char* vs = readFile(vertexPath).c_str(); // geht nicht in einem Schritt... stürzt ab?!
//const char* fs = readFile(pixelPath).c_str();
std::string vsString = readFile(vertexPath);
std::string fsString = readFile(pixelPath);
const char* vs = vsString.c_str();
const char* fs = fsString.c_str();
glShaderSource(vertex_ID, 1, &vs, 0);
glShaderSource(pixel_ID, 1, &fs, 0);
// Shader kompilieren
glCompileShader(vertex_ID);
printShaderInfoLog(vertex_ID);
glCompileShader(pixel_ID);
printShaderInfoLog(pixel_ID);
// Programm aus Shadern erstellen
GLuint program_ID = glCreateProgram();
glAttachShader(program_ID, vertex_ID); // erst Vertexshader
glAttachShader(program_ID, pixel_ID); // danach Pixelshader
glBindFragDataLocation(program_ID, 0, "fragColor"); // fragColor enthält am Ende die Farbe des Pixels ist (Ausgabe des Pixelshaders)
glLinkProgram(program_ID);
printProgramInfoLog(program_ID);
checkForErrors();
vShader_IDs.append(vertex_ID);
pShader_IDs.append(pixel_ID);
program_IDs.append(program_ID);
return vShader_IDs.size() - 1;
}
bool initProgram()
{
bool Validated = true;
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 150 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 150 --profile core");
Validated = Validated && Compiler.check();
ProgramName = glCreateProgram();
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, FragShaderName);
glBindAttribLocation(ProgramName, semantic::attr::POSITION, "Position");
glBindAttribLocation(ProgramName, semantic::attr::TEXCOORD, "Texcoord");
glBindFragDataLocation(ProgramName, semantic::frag::COLOR, "Color");
glLinkProgram(ProgramName);
Validated = Validated && Compiler.check_program(ProgramName);
}
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName, "MVP");
UniformDiffuse = glGetUniformLocation(ProgramName, "Diffuse");
}
return Validated && this->checkError("initProgram");
}
bool initProgram()
{
bool Validated(true);
if(Validated)
{
compiler Compiler;
std::vector<GLuint> ShaderName(shader::MAX);
ShaderName[shader::VERT] = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 150 --profile core");
ShaderName[shader::FRAG] = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 150 --profile core");
Validated = Validated && Compiler.check();
ProgramName = glCreateProgram();
glAttachShader(ProgramName, ShaderName[shader::VERT]);
glAttachShader(ProgramName, ShaderName[shader::FRAG]);
glBindAttribLocation(ProgramName, semantic::attr::POSITION, "Position");
glBindAttribLocation(ProgramName, semantic::attr::TEXCOORD, "Texcoord");
glBindFragDataLocation(ProgramName, semantic::frag::COLOR, "Color");
glLinkProgram(ProgramName);
Validated = Validated && Compiler.checkProgram(ProgramName);
}
if(Validated)
{
UniformTransform = glGetUniformBlockIndex(ProgramName, "transform");
UniformDiffuse = glGetUniformLocation(ProgramName, "Diffuse");
}
Validated = Validated && this->checkError("initProgram");
return Validated;
}
/*
* Category: Shaders
*
* Core in:
* OpenGL : 3.0
*/
void rglBindFragDataLocation(GLuint program, GLuint colorNumber,
const char * name)
{
#if !defined(HAVE_OPENGLES2)
glBindFragDataLocation(program, colorNumber, name);
#endif
}
bool initProgram()
{
bool Validated = true;
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SAMPLE_VERT_SHADER, "--version 150 --profile core");
GLuint GeomShaderName = Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + SAMPLE_GEOM_SHADER, "--version 150 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SAMPLE_FRAG_SHADER, "--version 150 --profile core");
ProgramName = glCreateProgram();
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, GeomShaderName);
glAttachShader(ProgramName, FragShaderName);
glBindAttribLocation(ProgramName, semantic::attr::POSITION, "Position");
glBindAttribLocation(ProgramName, semantic::attr::COLOR, "Color");
glBindFragDataLocation(ProgramName, semantic::frag::COLOR, "Color");
glLinkProgram(ProgramName);
Validated = Validated && Compiler.check();
Validated = Validated && Compiler.checkProgram(ProgramName);
}
if(Validated)
{
glUseProgram(ProgramName);
glUniformBlockBinding(ProgramName, glGetUniformBlockIndex(ProgramName, "transform"), semantic::uniform::TRANSFORM0);
glUniformBlockBinding(ProgramName, glGetUniformBlockIndex(ProgramName, "constant"), semantic::uniform::CONSTANT);
glUseProgram(0);
}
return Validated && this->checkError("initProgram");
}
bool initProgram()
{
bool Validated = true;
if(Validated)
{
GLuint VertShaderName = glf::createShader(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERT_SHADER_SOURCE);
GLuint FragShaderName = glf::createShader(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE);
Validated = Validated && glf::checkShader(VertShaderName, VERT_SHADER_SOURCE);
Validated = Validated && glf::checkShader(FragShaderName, FRAG_SHADER_SOURCE);
ProgramName = glCreateProgram();
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, FragShaderName);
glBindFragDataLocation(ProgramName, glf::semantic::frag::COLOR, "Color");
glDeleteShader(VertShaderName);
glDeleteShader(FragShaderName);
glLinkProgram(ProgramName);
Validated = Validated && glf::checkProgram(ProgramName);
}
if(Validated)
{
UniformTextureMatrix = glGetUniformLocation(ProgramName, "Orientation");
UniformDiffuse = glGetUniformLocation(ProgramName, "Diffuse");
}
return Validated && glf::checkError("initProgram");
}
bool initProgram()
{
bool Validated = true;
// Create program
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 150 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 150 --profile core");
ProgramName = glCreateProgram();
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, FragShaderName);
glBindAttribLocation(ProgramName, semantic::attr::POSITION, "Position");
glBindFragDataLocation(ProgramName, semantic::frag::COLOR, "Color");
glLinkProgram(ProgramName);
Validated = Validated && Compiler.check();
Validated = Validated && Compiler.check_program(ProgramName);
}
// Get variables locations
if(Validated)
{
UniformTransform = glGetUniformBlockIndex(ProgramName, "transform");
UniformMaterial = glGetUniformBlockIndex(ProgramName, "material");
}
return Validated && this->checkError("initProgram");
}
bool initProgram()
{
bool Validated = true;
if(Validated)
{
GLuint VertexShaderName = glf::createShader(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERTEX_SHADER_SOURCE);
GLuint FragmentShaderName = glf::createShader(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FRAGMENT_SHADER_SOURCE);
Validated = Validated && glf::checkShader(VertexShaderName, VERTEX_SHADER_SOURCE);
Validated = Validated && glf::checkShader(FragmentShaderName, FRAGMENT_SHADER_SOURCE);
ProgramName = glCreateProgram();
glAttachShader(ProgramName, VertexShaderName);
glAttachShader(ProgramName, FragmentShaderName);
glBindAttribLocation(ProgramName, glf::semantic::attr::POSITION, "Position");
glBindAttribLocation(ProgramName, glf::semantic::attr::TEXCOORD, "Texcoord");
glBindFragDataLocation(ProgramName, glf::semantic::frag::COLOR, "Color");
glDeleteShader(VertexShaderName);
glDeleteShader(FragmentShaderName);
glLinkProgram(ProgramName);
Validated = Validated && glf::checkProgram(ProgramName);
}
if(Validated)
{
UniformTransform = glGetUniformBlockIndex(ProgramName, "transform");
UniformDiffuse = glGetUniformLocation(ProgramName, "Diffuse");
}
return Validated && glf::checkError("initProgram");
}
/**
* @fn void ScreenRepaint::initFrameBufferObjects();
*
* @brief Initialises the frame buffer objects. If this is the first time this method is called, then the
* shader programs are read in and the texture and pixel buffer object handles are created and stored.
* Otherwise, if this is called as the result of a resize, a new ortho2D matrix is recalculated, and if
* the canvas is larger than previous sizes, the pixel buffer size is re-allocated.
*
* @todo Fix bug that causes texture to draw incorrectly at large canvas sizes.
*
* @author Phil
* @date 3/15/2012
*/
void ScreenRepaint::initFrameBufferObjects(){
if(!fboInitialized){
// Create screen post process program
//screenRenderProg = gltLoadShaderPairWithAttributes("/shaders/texpassthrough.vs", "/shaders/gaussianGlow.fs", 2, GLT_ATTRIBUTE_VERTEX, "vVertex", GLT_ATTRIBUTE_TEXTURE0, "texCoord0");
screenRenderProg = gltLoadShaderPairWithAttributes(vertexFileName, fragmentFileName, 2, GLT_ATTRIBUTE_VERTEX, "vVertex", GLT_ATTRIBUTE_TEXTURE0, "texCoord0");
glBindFragDataLocation(screenRenderProg, 0, "oColor"); // bind the output of the shader to index zero - this is the same as using the default (depricated) gl_FragColor
glLinkProgram(screenRenderProg); // relink, so that the graphics card knows what it's outputting to.
screenWidthLoc = glGetUniformLocation(screenRenderProg, "screenWidth");
screenHeightLoc = glGetUniformLocation(screenRenderProg, "screenHeight");
// Create screen textures
glActiveTexture(screenTextureID); // note that we are using GL_TEXTURE1, not the default
glGenTextures(1, screenTextures);
// Allocate a pixel buffer to initialize textures and PBOs
pixelDataSize = CALC_SCREEN_PIXELS;
// Setup texture unit
// Initialize texture data
glBindTexture(GL_TEXTURE_2D, screenTextures[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
// Alloc space for copying pixels so we dont call malloc on every draw
glGenBuffers(1, pixBuffObjs);
glBindBuffer(GL_PIXEL_PACK_BUFFER, pixBuffObjs[0]);
glBufferData(GL_PIXEL_PACK_BUFFER, pixelDataSize, NULL, GL_DYNAMIC_COPY);
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
// Create geometry and a matrix for screen aligned drawing
gltGenerateOrtho2DMat(screenWidth/2, screenHeight/2, orthoMatrix, screenQuad);
// Make sure all went well
gltCheckErrors();
fboInitialized = true;
}else{
// reset screen aligned quad
gltGenerateOrtho2DMat(screenWidth, screenHeight, orthoMatrix, screenQuad);
GLuint val = CALC_SCREEN_PIXELS;
if(pixelDataSize < val){
pixelDataSize = val;
// Resize PBOs
glBindBuffer(GL_PIXEL_PACK_BUFFER, pixBuffObjs[0]);
glBufferData(GL_PIXEL_PACK_BUFFER, pixelDataSize, NULL, GL_DYNAMIC_COPY);
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
}
gltCheckErrors();
}
}
void Graphics::initGL(){
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Create Vertex Array Object
glGenVertexArrays(1, &_vao);
glBindVertexArray(_vao);
// Create a Vertex Buffer Object and copy the vertex data to it
glGenBuffers(1, &_vbo);
GLfloat vertices[] = {
// Position Color Texcoords
-1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, // Top-left
1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, // Top-right
1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, // Bottom-right
-1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f // Bottom-left
};
glBindBuffer(GL_ARRAY_BUFFER, _vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_DYNAMIC_DRAW);
glGenBuffers(1, &_ebo);
GLuint elements[] = {
0, 1, 2,
2, 3, 0
};
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
sizeof(elements), elements, GL_DYNAMIC_DRAW);
// Create and compile the vertex shader
_vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(_vertexShader, 1, &cVertexSrc, NULL);
glCompileShader(_vertexShader);
// Create and compile the fragment shader
_fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(_fragmentShader, 1, &cFragmentSrc, NULL);
glCompileShader(_fragmentShader);
// Link the vertex and fragment shader into a shader program
_shaderProgram = glCreateProgram();
glAttachShader(_shaderProgram, _vertexShader);
glAttachShader(_shaderProgram, _fragmentShader);
glBindFragDataLocation(_shaderProgram, 0, "outColor");
glLinkProgram(_shaderProgram);
glUseProgram(_shaderProgram);
// Specify the layout of the vertex data
GLint posAttrib = glGetAttribLocation(_shaderProgram, "position");
glEnableVertexAttribArray(posAttrib);
glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
GLint colAttrib = glGetAttribLocation(_shaderProgram, "color");
glEnableVertexAttribArray(colAttrib);
glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));
GLint texAttrib = glGetAttribLocation(_shaderProgram, "texcoord");
glEnableVertexAttribArray(texAttrib);
glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(6 * sizeof(GLfloat)));
}
void RenderSystem::bindFragmentDataLocation(
RenderSystem::ShaderProgramID handle,
RenderSystem::ShaderVariableLocation location,
const char* const name
) {
glBindFragDataLocation(handle, location, name);
CROSS_GL_ASSERT();
}
//----------------------------------------------------------------------------//
void OpenGL3Shader::bindFragDataLocation(const std::string &name)
{
if(d_program > 0)
{
glBindFragDataLocation(d_program, 0, name.c_str() );
link();
}
}
void Shader::Compile(const std::string &pVSName, const std::string &pFSName, const std::string &pGSName){
std::string all = String(pVSName)+pFSName+pGSName;
Shader* tmp = ResourceManager::Call().Get<Shader>(all);
if(tmp != 0){
//Shader existe deja, on copie ses identifiants dans celui ci
mProgram = tmp->mProgram;
}else{
//Shader n'existe pas, on le cree
// Ajout du shader au ResourceManager
ResourceManager::Call().Add(all, this);
// Chargement des fichiers shaders
LoadVertexShader(pVSName);
LoadFragmentShader(pFSName);
if(!pGSName.empty())
LoadGeometryShader(pGSName);
// Creation du shader mProgram
mProgram = glCreateProgram();
// Linkage des deux shaders précédemment créés
glAttachShader(mProgram, mVShader);
glAttachShader(mProgram, mFShader);
if(mGShader)
glAttachShader(mProgram, mGShader);
// Linkage du mProgramme a OGL
glLinkProgram(mProgram);
GLint error;
glGetProgramiv(mProgram, GL_LINK_STATUS, &error);
if(!error){
char log[1024];
glGetProgramInfoLog(mProgram, 1024, NULL, log);
if(mVShader)
glDeleteShader(mVShader);
if(mFShader)
glDeleteShader(mFShader);
if(mGShader)
glDeleteShader(mGShader);
throw Exception(String("Shader Link Error :\n")+log);
}
// Destruction des Shaders. ils sont maintenant dans le program
glDeleteShader(mVShader);
glDeleteShader(mFShader);
if(mGShader)
glDeleteShader(mGShader);
// Attribution des texCoords
glUseProgram(mProgram);
glUniform1i(glGetUniformLocation(mProgram, "tex"), 0);
glBindFragDataLocation(mProgram, 0, "finalColor");
glUseProgram(0);
}
}
GLuint compileShaders(char* pixelShaders, char* vertexShaders){
string vertexSourceStr = LoadFileToString(vertexShaders);
string fragmentSourceStr = LoadFileToString(pixelShaders);
const GLchar* vertexSource = vertexSourceStr.c_str();
const GLchar* fragmentSource = fragmentSourceStr.c_str();
GLint Result = GL_FALSE;
int InfoLogLength;
printf("Compiling shader : %s\n", vertexShaders);
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
// Check Vertex Shader
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &Result);
glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &InfoLogLength);
std::vector<char> VertexShaderErrorMessage(InfoLogLength);
glGetShaderInfoLog(vertexShader, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
fprintf(stdout, "%s\n", &VertexShaderErrorMessage[0]);
printf("Compiling shader : %s\n", pixelShaders);
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
// Check Fragment Shader
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &Result);
glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &InfoLogLength);
std::vector<char> FragmentShaderErrorMessage(InfoLogLength);
glGetShaderInfoLog(fragmentShader, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
fprintf(stdout, "%s\n", &FragmentShaderErrorMessage[0]);
printf("Linking program\n");
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glBindFragDataLocation(shaderProgram, 0, "outColor");
glLinkProgram(shaderProgram);
glUseProgram(shaderProgram);
// Check the program
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &Result);
glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &InfoLogLength);
std::vector<char> ProgramErrorMessage(InfoLogLength + 1);
glGetProgramInfoLog(shaderProgram, InfoLogLength, NULL, &ProgramErrorMessage[0]);
fprintf(stdout, "%s\n", &ProgramErrorMessage[0]);
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
return shaderProgram;
}
Shader * Shader::loadShader(string name)
{
Shader * s = new Shader();
for (int i = 0; i < 5; i++) name.pop_back();
s->name = name;
string vertPath = name + ".vert";
string fragPath = name + ".frag";
//Start with a handle for the shader program...
GLhandleARB shaderProgramHandle = glCreateProgramObjectARB ();
//glBindAttribLocation (shaderProgramHandle, 0, "mg_vertex");
//glBindAttribLocation (shaderProgramHandle, 1, "uv");
// use glGetAttribLocation instead
GLhandleARB vertObject = makeShader(vertPath.c_str(), GL_VERTEX_SHADER);
GLhandleARB fragObject = makeShader(fragPath.c_str(), GL_FRAGMENT_SHADER);
glAttachObjectARB(shaderProgramHandle, vertObject);
glAttachObjectARB(shaderProgramHandle, fragObject);
glLinkProgramARB (shaderProgramHandle);
//Find out if compilation worked and return the program handle if it did...
int status; glGetObjectParameterivARB (shaderProgramHandle, GL_OBJECT_LINK_STATUS_ARB, &status);
if (status != 0)
{
//return shaderProgramHandle; //Everything OK...
s->shaderProgram = shaderProgramHandle;
s->vertexShader = vertObject;
s->fragmentShader = fragObject;
return s;
}
//It didn't, so log error information...
//::log ("\nFailed to link shader \"%s\"...", name.c_str ());
int length = 0;
glGetObjectParameterivARB (shaderProgramHandle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
glBindFragDataLocation(shaderProgramHandle, 0, "outColour");
const long MAXIMUM_LOG_STRING = 1024; char logString [MAXIMUM_LOG_STRING];
GLsizei messageLength = min (length, MAXIMUM_LOG_STRING);
if (messageLength > 0) {
glGetInfoLogARB (shaderProgramHandle, messageLength, 0, logString);
}
//and detach what was previously attached and discard the program handle that was obtained...
glDetachObjectARB(shaderProgramHandle, fragObject);
glDetachObjectARB(shaderProgramHandle, vertObject);
glDeleteObjectARB (shaderProgramHandle); //Should also detach the attached handles...
return NULL;
}
GLuint setupShaders(char * vertexfile, char * fragmentfile, GLuint * program)
{
char *vs = NULL,*fs = NULL,*fs2 = NULL;
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
if(vertexShader == 0 || fragmentShader == 0)
std::cout << " Error with glCreateShader" << std::endl;
vs = textFileRead(vertexfile);
fs = textFileRead(fragmentfile);
if(vs == NULL)
std::cout << "vs files null\n" << std::endl;
if(fs == NULL)
std::cout << "fs files null\n" << std::endl;
const char * vv = vs;
const char * ff = fs;
glShaderSource(vertexShader, 1, &vv,NULL);
glShaderSource(fragmentShader, 1, &ff,NULL);
free(vs);free(fs);
glCompileShader(vertexShader);
glCompileShader(fragmentShader);
printShaderInfoLog(vertexShader);
printShaderInfoLog(fragmentShader);
*program = glCreateProgram();
glAttachShader(*program,vertexShader);
glAttachShader(*program,fragmentShader);
glBindFragDataLocation(*program, 0, "output");
glBindAttribLocation(*program,vertexLoc,"position");
glBindAttribLocation(*program,normalLoc,"normal");
glBindAttribLocation(*program,texCoordLoc,"texCoord");
glLinkProgram(*program);
glValidateProgram(*program);
IO::printProgramInfoLog(*program);
GLuint k = glGetUniformBlockIndex(*program,"Matrices");
glUniformBlockBinding(*program, k, matricesUniLoc);
glUniformBlockBinding(*program, glGetUniformBlockIndex(*program,"Material"), materialUniLoc);
texUnit = glGetUniformLocation(*program,"texUnit");
return(*program);
}
inline void VL_glBindFragDataLocation(GLuint program, GLuint colorNumber, const GLchar *name)
{
if (glBindFragDataLocation)
glBindFragDataLocation(program, colorNumber, name);
else
if (glBindFragDataLocationEXT)
glBindFragDataLocationEXT(program, colorNumber, name);
else
VL_UNSUPPORTED_FUNC();
}
void Program::BindFragDataLocation(GLuint colorNumber, const char* name)
{
if (compiled_)
{
ERROR_WARNING("Program was already compiled.")
return;
}
glBindFragDataLocation(program_, colorNumber, name);
}
void Background :: initgl() {
// The standard gl object stuff.
vert = createShader(GL_VERTEX_SHADER, VS_BKGD);
frag = createShader(GL_FRAGMENT_SHADER, FS_BKGD);
prog = glCreateProgram();
glAttachShader(prog, vert);
glAttachShader(prog, frag);
glBindFragDataLocation(prog, 0, "out_color");
glLinkProgram(prog);
glUseProgram(prog);
printShaderError(vert, VS_BKGD);
printShaderError(frag, FS_BKGD);
//vao, vbo,
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Uploaded to the GPU
float rectArray [] {
-1.0f, 1.0f, 0.0f, 0.0f, // TL
1.0f, 1.0f, 1.0f, 0.0f, // TR
1.0f, -1.0f, 1.0f, 1.0f, // BR
-1.0f, 1.0f, 0.0f, 0.0f, // TL
-1.0f, -1.0f, 0.0f, 1.0f, // BL
1.0f, -1.0f, 1.0f, 1.0f // BR
};
glBufferData(GL_ARRAY_BUFFER, sizeof(rectArray), rectArray, GL_STATIC_DRAW);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
GLuint pos = glGetAttribLocation(prog, "pos");
GLuint uv = glGetAttribLocation(prog, "uv");
glVertexAttribPointer(pos, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4, nullptr);
glVertexAttribPointer(uv , 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4, (void *) (sizeof(GLfloat) * 2));
glEnableVertexAttribArray(pos);
glEnableVertexAttribArray(uv);
glUniform1i(glGetUniformLocation(prog, "BkgdTex"), BSPOT_BKGD);
// ren_dim / img_dim = num of repeat
glUniform2f(glGetUniformLocation(prog, "rep_num"),
RENDER_WIDTH / (float) ih->getSheetWidth(),
RENDER_HEIGHT / (float) ih->getSheetHeight());
// Because the vectors must be horizontal (in arrays), the matrix must be transposed.
glUniform2f(glGetUniformLocation(prog, "img_dim"), ih->getSheetWidth(), ih->getSheetHeight());
unbind();
}
bool initProgram()
{
bool Validated(true);
if(Validated)
{
glf::compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_RENDER,
"--version 400 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE_RENDER,
"--version 400 --profile core");
Validated = Validated && Compiler.check();
ProgramName[program::RENDER] = glCreateProgram();
glAttachShader(ProgramName[program::RENDER], VertShaderName);
glAttachShader(ProgramName[program::RENDER], FragShaderName);
glBindAttribLocation(ProgramName[program::RENDER], glf::semantic::attr::POSITION, "Position");
glBindAttribLocation(ProgramName[program::RENDER], glf::semantic::attr::COLOR, "Color");
glBindFragDataLocation(ProgramName[program::RENDER], glf::semantic::frag::COLOR, "Color");
glLinkProgram(ProgramName[program::RENDER]);
glDeleteShader(VertShaderName);
glDeleteShader(FragShaderName);
Validated = Validated && glf::checkProgram(ProgramName[program::RENDER]);
}
if(Validated)
{
UniformTransform[program::RENDER] = glGetUniformBlockIndex(ProgramName[program::RENDER], "transform");
UniformShadow = glGetUniformLocation(ProgramName[program::RENDER], "Shadow");
}
if(Validated)
{
glf::compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_DEPTH,
"--version 400 --profile core");
Validated = Validated && Compiler.check();
ProgramName[program::DEPTH] = glCreateProgram();
glAttachShader(ProgramName[program::DEPTH], VertShaderName);
glBindAttribLocation(ProgramName[program::DEPTH], glf::semantic::attr::POSITION, "Position");
glLinkProgram(ProgramName[program::DEPTH]);
glDeleteShader(VertShaderName);
Validated = Validated && glf::checkProgram(ProgramName[program::DEPTH]);
}
if(Validated)
{
UniformTransform[program::DEPTH] = glGetUniformBlockIndex(ProgramName[program::DEPTH], "transform");
}
return Validated;
}
int SCE_RBuildProgram (SCE_RProgram *prog)
{
const int modes[2] = {GL_INTERLEAVED_ATTRIBS, GL_SEPARATE_ATTRIBS};
int status = GL_TRUE;
int loginfo_size = 0;
char *loginfo = NULL;
int i, j;
if (prog->linked)
return SCE_OK;
/* setting transform feedback up */
if (prog->fb_enabled) {
glTransformFeedbackVaryings (prog->id, prog->n_varyings,
(const GLchar**)prog->fb_varyings,
modes[prog->fb_mode]);
}
/* TODO: follows the same pattern as SCE_RSetDrawBuffers */
j = 0;
for (i = 0; i < SCE_MAX_ATTACHMENT_BUFFERS; i++) {
if (*prog->outputs[i])
glBindFragDataLocation (prog->id, j++, prog->outputs[i]);
}
glLinkProgram (prog->id);
glGetProgramiv (prog->id, GL_LINK_STATUS, &status);
if (status != GL_TRUE) {
SCEE_Log (SCE_INVALID_OPERATION);
glGetProgramiv (prog->id, GL_INFO_LOG_LENGTH, &loginfo_size);
loginfo = SCE_malloc (loginfo_size + 1);
if (!loginfo) {
SCEE_LogSrc ();
return SCE_ERROR;
}
memset (loginfo, '\0', loginfo_size + 1);
glGetProgramInfoLog (prog->id, loginfo_size, &loginfo_size, loginfo);
/* TODO: add program name */
SCEE_LogMsg ("can't link program, reason: %s", loginfo);
SCE_free (loginfo);
return SCE_ERROR;
}
prog->linked = SCE_TRUE;
/* if the map was previously built, rebuild it */
if (prog->map_built)
SCE_RSetupProgramAttributesMapping (prog);
return SCE_OK;
}
static GLuint link_program(GLuint vertexShader, GLuint fragShader) {
GLuint program = glCreateProgram();
glAttachShader(program, vertexShader);
glAttachShader(program, fragShader);
glBindFragDataLocation(program, 0, "outColor");
glLinkProgram(program);
return program;
}
void GLMainShader::GetShaderLocations()
{
uint* pCurrProgram = &ProgramID[0];
do {
// Attribute locations
GetAttribLocation(Vertex, *pCurrProgram, "Position");
GetAttribLocation(TexCoords, *pCurrProgram, "TexCoord");
GetAttribLocation(Normal, *pCurrProgram, "Normal");
GetAttribLocation(Colors, *pCurrProgram, "Colors");
GetAttribLocation(Tangent, *pCurrProgram, "Tangent");
GetAttribLocation(Bitangent, *pCurrProgram, "Bitangent");
GetAttribLocation(VertexJoint, *pCurrProgram, "Joints");
GetAttribLocation(VertexWeight, *pCurrProgram, "Weights");
GetAttribLocation(Light, *pCurrProgram, "Light");
// Get a handle to the the matrix uniforms
GetUniformLocation(MatMVP, *pCurrProgram, "MVP");
GetUniformLocation(MatMV, *pCurrProgram, "MV");
GetUniformLocation(MatN, *pCurrProgram, "N");
GetUniformLocation(MatP, *pCurrProgram, "P");
// Get the Light uniform handles
GetUniformLocation(Bones, *pCurrProgram, "Bones");
GetUniformLocation(LightType, *pCurrProgram, "LightType");
GetUniformLocation(LightPosition_eyespace, *pCurrProgram, "LightPosition_eyespace");
GetUniformLocation(LightDiffuse, *pCurrProgram, "LightDiffuse");
GetUniformLocation(LightAmbient, *pCurrProgram, "LightAmbient");
GetUniformLocation(LightSpecular, *pCurrProgram, "LightSpecular");
GetUniformLocation(LightLinearAttenuation, *pCurrProgram, "linearAttenuation");
GetUniformLocation(LightConstantAttenuation, *pCurrProgram, "constantAttenuation");
GetUniformLocation(LightQuadraticAttenuation, *pCurrProgram, "quadraticAttenuation");
// Materials
GetUniformLocation(MaterialType, *pCurrProgram, "MaterialType");
GetUniformLocation(DiffuseTexture, *pCurrProgram, "DiffuseMap");
GetUniformLocation(BumpmapTexture, *pCurrProgram, "NormalMap");
GetUniformLocation(SpecularTexture, *pCurrProgram, "SpecularMap");
GetUniformLocation(RenderedTexture, *pCurrProgram, "RenderedTexture");
GetUniformLocation(DepthTexture, *pCurrProgram, "DepthTexture");
GetUniformLocation(DiffuseColor, *pCurrProgram, "DiffuseColor");
GetUniformLocation(AmbientColor, *pCurrProgram, "AmbientColor");
GetUniformLocation(SpecularColor, *pCurrProgram, "SpecularColor");
GetUniformLocation(Shininess, *pCurrProgram, "Shininess");
glBindFragDataLocation(*pCurrProgram, 0, "Color0");
// Relink for the output locations
glLinkProgram(*pCurrProgram);
} while(*++pCurrProgram != 0);
}
void MainGraphicsWidget::voxelRender()
{
VoxelGrid::getInstance()->buildVoxels(m_lightBuffer->getLight());
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix3(NORMAL, glm::mat3(1.0f));
view->viewport();
view->use3D(true);
camera->transform();
GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("Voxel");
glslProgram->use();
glBindFragDataLocation(glslProgram->getHandle(), 0, "fragColor");
glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex");
glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]);
glslProgram->sendUniform("modelviewMatrix", &MatrixManager::getInstance()->getMatrix4(MODELVIEW)[0][0]);
glm::mat4 cameraInverse = glm::mat4(1.0);
cameraInverse = camera->transformToMatrix(cameraInverse);
cameraInverse = glm::inverse(cameraInverse);
glslProgram->sendUniform("invCameraMatrix", &cameraInverse[0][0]);
glslProgram->sendUniform("worldSize", WORLD_SIZE);
//glslProgram->sendUniform("numVoxels", VOXEL_SIZE);
//glslProgram->sendUniform("mipLevel", VoxelGrid::getInstance()->getMipLevel());
int mipFactor = pow(2.0, VoxelGrid::getInstance()->getMipLevel());
glActiveTexture(GL_TEXTURE8);
glEnable(GL_TEXTURE_3D);
VoxelGrid::getInstance()->bind(VoxelGrid::getInstance()->getMipLevel());
glslProgram->sendUniform("voxelmap", 8);
//glEnable(GL_POINT_SMOOTH);
glPointSize(10.0f*mipFactor);
float voxelWidth = (float)WORLD_SIZE / (float)VOXEL_SIZE * mipFactor;
glBegin(GL_POINTS);
for (float x=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); x<(WORLD_SIZE/2.0); x+=voxelWidth)
{
for (float y=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); y<(WORLD_SIZE/2.0); y+=voxelWidth)
{
for (float z=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); z<(WORLD_SIZE/2.0); z+=voxelWidth)
{
glVertex3f(x,y,z);
}
}
}
glEnd();
glslProgram->disable();
}
GLuint setupShaders() {
char *vs = NULL,*fs = NULL,*fs2 = NULL;
GLuint p,v,f;
v = glCreateShader(GL_VERTEX_SHADER);
f = glCreateShader(GL_FRAGMENT_SHADER);
vs = textFileRead(vertexFileName);
fs = textFileRead(fragmentFileName);
const char * vv = vs;
const char * ff = fs;
glShaderSource(v, 1, &vv,NULL);
glShaderSource(f, 1, &ff,NULL);
free(vs);free(fs);
glCompileShader(v);
glCompileShader(f);
printShaderInfoLog(v);
printShaderInfoLog(f);
p = glCreateProgram();
glAttachShader(p,v);
glAttachShader(p,f);
glBindFragDataLocation(p, 0, "output");
glBindAttribLocation(p,vertexLoc,"position");
glBindAttribLocation(p,normalLoc,"normal");
glBindAttribLocation(p,texCoordLoc,"texCoord");
glLinkProgram(p);
glValidateProgram(p);
printProgramInfoLog(p);
program = p;
vertexShader = v;
fragmentShader = f;
GLuint k = glGetUniformBlockIndex(p,"Matrices");
glUniformBlockBinding(p, k, matricesUniLoc);
glUniformBlockBinding(p, glGetUniformBlockIndex(p,"Material"), materialUniLoc);
texUnit = glGetUniformLocation(p,"texUnit");
return(p);
}
GLuint ShaderUtils::CreateProgramWithShaders(const std::vector<GLuint> &shaderList,
const std::vector<VertexAttributeBindingData> &attributes,
const std::vector<VertexAttributeBindingData> &fragData) {
GLuint program = glCreateProgram();
for(size_t iLoop = 0; iLoop < shaderList.size(); iLoop++)
glAttachShader(program, shaderList[iLoop]);
for(size_t iLoop = 0; iLoop < attributes.size(); iLoop++)
glBindAttribLocation(program, attributes[iLoop].index, attributes[iLoop].strShaderFile );
for(size_t iLoop = 0; iLoop < fragData.size(); iLoop++)
glBindFragDataLocation(program, fragData[iLoop].index, fragData[iLoop].strShaderFile );
return program;
}
void OGLConstants::bindAttribFragDataLocations(GLuint program) {
glBindAttribLocation(program, VERTEX.location, VERTEX.name);
glBindAttribLocation(program, COLOR.location, COLOR.name);
glBindAttribLocation(program, NORMAL.location, NORMAL.name);
glBindAttribLocation(program, TEX_COORD_0.location, TEX_COORD_0.name);
glBindAttribLocation(program, TEX_COORD_1.location, TEX_COORD_1.name);
glBindAttribLocation(program, TANGENT.location, TANGENT.name);
glBindAttribLocation(program, BINORMAL.location, BINORMAL.name);
glBindFragDataLocation(program, FRAG_COLOR.location, FRAG_COLOR.name);
assert(!checkGLError());
}
