_Bool gl_init(void) { GLuint vertshader, fragshader; GLint status; const GLchar *data; vertshader = glCreateShader(GL_VERTEX_SHADER); if(!vertshader) { debug("glCreateShader() failed (vert)\n"); return 0; } data = &vertex_shader[0]; glShaderSource(vertshader, 1, &data, NULL); glCompileShader(vertshader); glGetShaderiv(vertshader, GL_COMPILE_STATUS, &status); if(!status) { #ifdef DEBUG debug("glCompileShader() failed (vert):\n%s\n", data); GLint infologsize = 0; glGetShaderiv(vertshader, GL_INFO_LOG_LENGTH, &infologsize); if(infologsize) { char* infolog = malloc(infologsize); glGetShaderInfoLog(vertshader, infologsize, NULL, (GLbyte*)infolog); debug("Infolog: %s\n", infolog); free(infolog); } #endif return 0; } fragshader = glCreateShader(GL_FRAGMENT_SHADER); if(!fragshader) { return 0; } data = &fragment_shader[0]; glShaderSource(fragshader, 1, &data, NULL); glCompileShader(fragshader); glGetShaderiv(fragshader, GL_COMPILE_STATUS, &status); if(!status) { #ifdef DEBUG debug("glCompileShader failed (frag):\n%s\n", data); GLint infologsize = 0; glGetShaderiv(fragshader, GL_INFO_LOG_LENGTH, &infologsize); if(infologsize) { char* infolog = malloc(infologsize); glGetShaderInfoLog(fragshader, infologsize, NULL, (GLbyte*)infolog); debug("Infolog: %s\n", infolog); free(infolog); } #endif return 0; } prog = glCreateProgram(); glAttachShader(prog, vertshader); glAttachShader(prog, fragshader); glBindAttribLocation(prog, 0, "pos"); glBindAttribLocation(prog, 1, "tex"); glLinkProgram(prog); glGetProgramiv(prog, GL_LINK_STATUS, &status); if(!status) { #ifdef DEBUG debug("glLinkProgram failed\n"); GLint infologsize = 0; glGetShaderiv(prog, GL_INFO_LOG_LENGTH, &infologsize); if(infologsize) { char* infolog = malloc(infologsize); glGetShaderInfoLog(prog, infologsize, NULL, (GLbyte*)infolog); debug("Infolog: %s\n", infolog); free(infolog); } #endif return 0; } glUseProgram(prog); matrix = glGetUniformLocation(prog, "matrix"); k = glGetUniformLocation(prog, "k"); k2 = glGetUniformLocation(prog, "k2"); samp = glGetUniformLocation(prog, "samp"); debug("uniforms: %i %i %i\n", matrix, k, samp); GLint zero = 0; float one[] = {1.0, 1.0, 1.0}; glUniform1iv(samp, 1, &zero); glUniform3fv(k2, 1, one); uint8_t wh = {255}; glGenTextures(1, &white); glBindTexture(GL_TEXTURE_2D, white); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 1, 1, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &wh); // glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE, sizeof(VERTEX2D), &quads[0]); glVertexAttribPointer(1, 2, GL_UNSIGNED_SHORT, GL_FALSE, sizeof(VERTEX2D), &quads[0].vertex[0].tx); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); //Alpha blending glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); // glPixelStorei(GL_UNPACK_ALIGNMENT, 1); #ifndef NO_OPENGL_ES uint8_t i = 0; uint16_t ii = 0; do { quad_indices[ii] = i + 0; quad_indices[ii + 1] = i + 1; quad_indices[ii + 2] = i + 3; quad_indices[ii + 3] = i + 3; quad_indices[ii + 4] = i + 1; quad_indices[ii + 5] = i + 2; i += 4; ii += 6; } while(i); #endif glGenTextures(countof(bitmap), bitmap); svg_draw(0); loadfonts(); float vec[4]; vec[0] = -(float)utox_window_width / 2.0; vec[1] = -(float)utox_window_height / 2.0; vec[2] = 2.0 / (float)utox_window_width; vec[3] = -2.0 / (float)utox_window_height; glUniform4fv(matrix, 1, vec); ui_size(utox_window_width, utox_window_height); glViewport(0, 0, utox_window_width, utox_window_height); redraw(); return 1; }
" varying highp vec4 lightPosition_PASS; \n" " varying highp vec2 varTexcoord; \n" " void main() \n" " { \n" " lightPosition_PASS = normalize(lightMatrix * light_POSITION_01); \n" " varTexcoord = texture; \n" " gl_Position = mvpMatrix * position; \n" " }\n"; //--------------------------------------------------------------------- sphere_SHADER_VERTEX = glCreateShader(GL_VERTEX_SHADER); glShaderSource(sphere_SHADER_VERTEX, 1, &vertexSource_sphere, NULL); glCompileShader(sphere_SHADER_VERTEX); //--------------------------------------------------------------------- const GLchar *fragmentSource_sphere = " #ifdef GL_ES \n" " #else \n" " #define highp \n" " #endif \n" " uniform sampler2D Texture1; \n" " uniform sampler2D NormalMap; \n" " uniform highp float shininess; \n" " uniform highp float attenuation; \n"
bool initialize(){ // Initialize basic geometry and shaders for this example //this defines a cube, this is why a model loader is nice //you can also do this with a draw elements and indices, try to get that working Vertex geometry[] = { {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, -1.0, 1.0}, {0.0, 0.0, 1.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}}, {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}}, {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}}, {{-1.0, -1.0, 1.0}, {0.0, 0.0, 1.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{-1.0, -1.0, 1.0}, {0.0, 0.0, 1.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}}, {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}}, {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}}, {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}} }; // Create a Vertex Buffer object to store this vertex info on the GPU glGenBuffers(1, &vbo_geometry); glBindBuffer(GL_ARRAY_BUFFER, vbo_geometry); glBufferData(GL_ARRAY_BUFFER, sizeof(geometry), geometry, GL_STATIC_DRAW); //--Geometry done GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER); GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); //Shader Sources // Put these into files and write a loader in the future // Note the added uniform! const char *vs; vs = shaderLoader("vertexShader"); const char *fs; fs = shaderLoader("fragmentShader"); //compile the shaders GLint shader_status; // Vertex shader first glShaderSource(vertex_shader, 1, &vs, NULL); glCompileShader(vertex_shader); //check the compile status glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &shader_status); if(!shader_status){ std::cerr << "[F] FAILED TO COMPILE VERTEX SHADER!" << std::endl; return false; } // Now the Fragment shader glShaderSource(fragment_shader, 1, &fs, NULL); glCompileShader(fragment_shader); //check the compile status glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &shader_status); if(!shader_status){ std::cerr << "[F] FAILED TO COMPILE FRAGMENT SHADER!" << std::endl; return false; } //Now we link the 2 shader objects into a program //This program is what is run on the GPU program = glCreateProgram(); glAttachShader(program, vertex_shader); glAttachShader(program, fragment_shader); glLinkProgram(program); //check if everything linked ok glGetProgramiv(program, GL_LINK_STATUS, &shader_status); if(!shader_status){ std::cerr << "[F] THE SHADER PROGRAM FAILED TO LINK" << std::endl; return false; } //Now we set the locations of the attributes and uniforms //this allows us to access them easily while rendering loc_position = glGetAttribLocation(program, const_cast<const char*>("v_position")); if(loc_position == -1){ std::cerr << "[F] POSITION NOT FOUND" << std::endl; return false; } loc_color = glGetAttribLocation(program, const_cast<const char*>("v_color")); if(loc_color == -1){ std::cerr << "[F] V_COLOR NOT FOUND" << std::endl; return false; } loc_mvpmat = glGetUniformLocation(program, const_cast<const char*>("mvpMatrix")); if(loc_mvpmat == -1){ std::cerr << "[F] MVPMATRIX NOT FOUND" << std::endl; return false; } //--Init the view and projection matrices // if you will be having a moving camera the view matrix will need to more dynamic // ...Like you should update it before you render more dynamic // for this project having them static will be fine view = glm::lookAt( glm::vec3(0.0, 8.0, -16.0), //Eye Position glm::vec3(0.0, 0.0, 0.0), //Focus point glm::vec3(0.0, 1.0, 0.0)); //Positive Y is up projection = glm::perspective( 45.0f, //the FoV typically 90 degrees is good which is what this is set to float(w)/float(h), //Aspect Ratio, so Circles stay Circular 0.01f, //Distance to the near plane, normally a small value like this 100.0f); //Distance to the far plane, //enable depth testing glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); //and its done return true; }
{ // create shaders const char* vsSource = "#version 150\n \ in vec4 Position; \ in vec4 Colour; \ out vec4 vColour; \ uniform mat4 ProjectionView; \ void main() { vColour = Colour; gl_Position = ProjectionView * Position; }"; const char* fsSource = "#version 150\n \ in vec4 vColour; \ out vec4 FragColor; \ void main() { FragColor = vColour; }"; unsigned int vs = glCreateShader(GL_VERTEX_SHADER); unsigned int fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(vs, 1, (const char**)&vsSource, 0); glCompileShader(vs); glShaderSource(fs, 1, (const char**)&fsSource, 0); glCompileShader(fs); m_shader = glCreateProgram(); glAttachShader(m_shader, vs); glAttachShader(m_shader, fs); glBindAttribLocation(m_shader, 0, "Position"); glBindAttribLocation(m_shader, 1, "Colour"); glLinkProgram(m_shader);
//////////////////////////////////////////////////////////////////////////////// //! //////////////////////////////////////////////////////////////////////////////// GLuint compileGLSLprogram(const char *vertex_shader_src, const char *fragment_shader_src) { GLuint v, f, p = 0; p = glCreateProgram(); if (vertex_shader_src) { v = glCreateShader(GL_VERTEX_SHADER); glShaderSource(v, 1, &vertex_shader_src, NULL); glCompileShader(v); // check if shader compiled GLint compiled = 0; glGetShaderiv(v, GL_COMPILE_STATUS, &compiled); if (!compiled) { //#ifdef NV_REPORT_COMPILE_ERRORS char temp[256] = ""; glGetShaderInfoLog( v, 256, NULL, temp); //shrLog("Vtx Compile failed:\n%s\n", temp); //#endif glDeleteShader( v); return 0; } else glAttachShader(p,v); } if (fragment_shader_src) { f = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(f, 1, &fragment_shader_src, NULL); glCompileShader(f); // check if shader compiled GLint compiled = 0; glGetShaderiv(f, GL_COMPILE_STATUS, &compiled); if (!compiled) { //#ifdef NV_REPORT_COMPILE_ERRORS char temp[256] = ""; glGetShaderInfoLog(f, 256, NULL, temp); //shrLog("frag Compile failed:\n%s\n", temp); //#endif glDeleteShader(f); return 0; } else glAttachShader(p,f); } glLinkProgram(p); int infologLength = 0; int charsWritten = 0; glGetProgramiv(p, GL_INFO_LOG_LENGTH, (GLint *)&infologLength); if (infologLength > 0) { char *infoLog = (char *)malloc(infologLength); glGetProgramInfoLog(p, infologLength, (GLsizei *)&charsWritten, infoLog); //shrLog("Shader compilation error: %s\n", infoLog); free(infoLog); } return p; }
void Shader::loadFrag(const std::string &filename) { // création du shader shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); compile(shaderFrag, filename); }
void Shader::loadVert(const std::string &filename) { // création du shader shaderVert = glCreateShader(GL_VERTEX_SHADER); compile(shaderVert, filename); }
static GLuint LoadProgram(const char* vsKey, const char* tcsKey, const char* tesKey, const char* gsKey, const char* fsKey) { GLchar spew[256]; GLint compileSuccess; GLuint programHandle = glCreateProgram(); const char* vsSource = pezGetShader(vsKey); pezCheck(vsSource != 0, "Can't find vshader: %s\n", vsKey); GLuint vsHandle = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vsHandle, 1, &vsSource, 0); glCompileShader(vsHandle); glGetShaderiv(vsHandle, GL_COMPILE_STATUS, &compileSuccess); glGetShaderInfoLog(vsHandle, sizeof(spew), 0, spew); pezCheck(compileSuccess, "Can't compile vshader:\n%s", spew); glAttachShader(programHandle, vsHandle); if (tcsKey) { const char* tcsSource = pezGetShader(tcsKey); pezCheck(tcsSource != 0, "Can't find tcshader: %s\n", tcsKey); GLuint tcsHandle = glCreateShader(GL_TESS_CONTROL_SHADER); glShaderSource(tcsHandle, 1, &tcsSource, 0); glCompileShader(tcsHandle); glGetShaderiv(tcsHandle, GL_COMPILE_STATUS, &compileSuccess); glGetShaderInfoLog(tcsHandle, sizeof(spew), 0, spew); pezCheck(compileSuccess, "Can't compile tcshader:\n%s", spew); glAttachShader(programHandle, tcsHandle); } if (tesKey) { const char* tesSource = pezGetShader(tesKey); pezCheck(tesSource != 0, "Can't find teshader: %s\n", tesKey); GLuint tesHandle = glCreateShader(GL_TESS_EVALUATION_SHADER); glShaderSource(tesHandle, 1, &tesSource, 0); glCompileShader(tesHandle); glGetShaderiv(tesHandle, GL_COMPILE_STATUS, &compileSuccess); glGetShaderInfoLog(tesHandle, sizeof(spew), 0, spew); pezCheck(compileSuccess, "Can't compile teshader:\n%s", spew); glAttachShader(programHandle, tesHandle); } if (gsKey) { const char* gsSource = pezGetShader(gsKey); pezCheck(gsSource != 0, "Can't find gshader: %s\n", gsKey); GLuint gsHandle = glCreateShader(GL_GEOMETRY_SHADER); glShaderSource(gsHandle, 1, &gsSource, 0); glCompileShader(gsHandle); glGetShaderiv(gsHandle, GL_COMPILE_STATUS, &compileSuccess); glGetShaderInfoLog(gsHandle, sizeof(spew), 0, spew); pezCheck(compileSuccess, "Can't compile gshader:\n%s", spew); glAttachShader(programHandle, gsHandle); } if (fsKey) { const char* fsSource = pezGetShader(fsKey); pezCheck(fsSource != 0, "Can't find fshader: %s\n", fsKey); GLuint fsHandle = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fsHandle, 1, &fsSource, 0); glCompileShader(fsHandle); glGetShaderiv(fsHandle, GL_COMPILE_STATUS, &compileSuccess); glGetShaderInfoLog(fsHandle, sizeof(spew), 0, spew); pezCheck(compileSuccess, "Can't compile fshader:\n%s", spew); glAttachShader(programHandle, fsHandle); } glBindAttribLocation(programHandle, PositionSlot, "Position"); glBindAttribLocation(programHandle, NormalSlot, "Normal"); glBindAttribLocation(programHandle, OcclusionSlot, "Occlusion"); glLinkProgram(programHandle); GLint linkSuccess; glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess); glGetProgramInfoLog(programHandle, sizeof(spew), 0, spew); pezCheck(linkSuccess, "Can't link shaders:\n%s", spew); glUseProgram(programHandle); return programHandle; }
int main() { glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); GLFWwindow* window = glfwCreateWindow(800, 600, "triangle", nullptr, nullptr); glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll); glewExperimental = GL_TRUE; glewInit(); glViewport(0, 0, 800, 600); glEnable(GL_DEPTH_TEST); GLint vertex = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertex, 1, &vertexshader, NULL); GLint fragment = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment, 1, &fragmentshader, NULL); glCompileShader(vertex); glCompileShader(fragment); GLint program = glCreateProgram(); glAttachShader(program, vertex); glAttachShader(program, fragment); glLinkProgram(program); GLint fragment1 = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment1, 1, &fragmentshader1, NULL); glCompileShader(fragment1); GLint program1 = glCreateProgram(); glAttachShader(program1, vertex); glAttachShader(program1, fragment1); glLinkProgram(program1); GLfloat vertices[] = { -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f }; glm::vec3 cubePositions[] = { glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, -4.0f), glm::vec3(0.0f, 0.0f, -10.f), glm::vec3(0.0f, 0.0f, -22.0f), glm::vec3(0.0f, 0.0f, -35.0f), glm::vec3(0.0f, 0.0f, -55.0f), glm::vec3(0.0f, 0.0f, -80.0f), }; GLfloat angle[7] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; GLfloat size[7] = { 0.3f, 1.0f, 1.2f, 0.7, 5.0f, 4.0f, 3.0f }; GLuint vbo, vaoc, vaol; glGenBuffers(1, &vbo); glGenVertexArrays(1, &vaoc); glGenVertexArrays(1, &vaol); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBindVertexArray(vaoc); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); glBindVertexArray(0); glBindVertexArray(vaol); glBindBuffer(GL_ARRAY_BUFFER, vbo); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glBindVertexArray(0); while (!glfwWindowShouldClose(window)) { glfwPollEvents(); movement(); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glUseProgram(program); glm::mat4 model; glm::mat4 view; glm::mat4 projection; view = glm::lookAt(camerapos, camerapos - cameramove, cameraup); projection = glm::perspective(aspect, (GLfloat)800 / (GLfloat)600, 0.1f, 200.0f); GLint modelLoc = glGetUniformLocation(program, "model"); GLint viewLoc = glGetUniformLocation(program, "view"); GLint projLoc = glGetUniformLocation(program, "projection"); GLint objectcolorLoc = glGetUniformLocation(program, "objectcolor"); GLint lightcolorLoc = glGetUniformLocation(program, "lightcolor"); GLint lightPosLoc = glGetUniformLocation(program, "lightPos"); GLint viewPosLoc = glGetUniformLocation(program, "viewPos"); glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); glUniform3f(lightcolorLoc, 1.0f, 1.0f, 1.0f); glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z); glUniform3f(viewPosLoc, camerapos.x, camerapos.y, camerapos.z); glBindVertexArray(vaoc); for (GLint i = 0; i < 7; i++) { model = glm::mat4(); model = glm::translate(model, cubePositions[i]); angle[i] = angle[i] + ((7 - i)* 0.00002); GLfloat radius = (20.0f + -1 * cubePositions[i].z); GLfloat x = sin(angle[i]) * radius; GLfloat z = (1 - cos(angle[i])) * radius; model = glm::translate(model, glm::vec3(x, 0.0f, z)); model = glm::rotate(model, (GLfloat)glfwGetTime() / (i + 1) * 2, glm::vec3(0.0f, 1.0f, 0.0f)); model = glm::scale(model, glm::vec3(size[i])); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glUniform3f(objectcolorLoc, 1.0f - (GLfloat)0.14f * i, 0.0f + (GLfloat)0.1f * i, 0.0f + (GLfloat)0.1f * i); glDrawArrays(GL_TRIANGLES, 0, 36); } glBindVertexArray(0); glUseProgram(program1); modelLoc = glGetUniformLocation(program1, "model"); viewLoc = glGetUniformLocation(program1, "view"); projLoc = glGetUniformLocation(program1, "projection"); glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); model = glm::mat4(); model = glm::translate(model, lightPos); model = glm::scale(model, glm::vec3(10.0f)); model = glm::rotate(model, (GLfloat)glfwGetTime() *0.2f, glm::vec3(0.0f, 1.0f, 0.0f)); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glBindVertexArray(vaol); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); glfwSwapBuffers(window); } glfwTerminate(); return 0; }
void Shader::create(const std::string _vertexFileName, const std::string& _fragmentFileName) { clear(); assert(!_vertexFileName.empty() && !_fragmentFileName.empty()); // Vertex Shader Loading unsigned int vertexShader; std::ifstream fileVs; fileVs.open(_vertexFileName.c_str(), std::ios::binary); assert(fileVs.is_open()); if(fileVs.is_open()) { fileVs.seekg(0, std::ios::end); unsigned int fileSize = (unsigned int)(fileVs.tellg()); assert(fileSize != 0); fileVs.seekg(std::ios::beg); char *bufferVs = new char[fileSize+1]; fileVs.read(bufferVs, fileSize); fileVs.close(); bufferVs[fileSize] = '\0'; /////////////////////////////////////////////////////////////////// vertexShader = glCreateShader(GL_VERTEX_SHADER); assert(vertexShader != 0); glShaderSource(vertexShader, 1, (const char **)(&bufferVs), NULL); glCompileShader(vertexShader); delete [] bufferVs; //Get Compilation Information int compiled; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compiled); if(compiled == 0) { int length; glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &length); char *str = new char[length]; glGetShaderInfoLog(vertexShader, length, NULL, str); std::cerr << "Vertex shader error " << str << std::endl; delete [] str; assert(false); return; } } else { std::cerr << "Didn't succeed to open the vertex shader file!" << std::endl; assert(false); return; } // Fragment Shader Loading unsigned int fragmentShader; std::ifstream fileFs; fileFs.open(_fragmentFileName.c_str(), std::ios::binary); assert(fileFs.is_open()); if(fileFs.is_open()) { fileFs.seekg(0, std::ios::end); unsigned int fileSize = (unsigned int)(fileFs.tellg()); assert(fileSize != 0); fileFs.seekg(std::ios::beg); char *bufferFs = new char[fileSize+1]; fileFs.read(bufferFs, fileSize); fileFs.close(); bufferFs[fileSize] = '\0'; /////////////////////////////////////////////////////////////////// fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); assert(fragmentShader != 0); glShaderSource(fragmentShader, 1, (const char **)(&bufferFs), NULL); glCompileShader(fragmentShader); delete [] bufferFs; //Get Compilation Information int compiled; glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compiled); if(compiled == 0) { int length; glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &length); char *str = new char[length]; glGetShaderInfoLog(fragmentShader, length, NULL, str); std::cerr << "Fragment shader Error " << str << std::endl; delete [] str; assert(false); return; } } else { std::cerr << "Didn't succeed to open the fragment shader file!" << std::endl; assert(false); return; } //Bind Vertex and Fragment programObj_ = glCreateProgram(); assert(programObj_ != 0); glAttachShader(programObj_, vertexShader); glAttachShader(programObj_, fragmentShader); glDeleteShader(vertexShader); glDeleteShader(fragmentShader); glLinkProgram(programObj_); //Get Linker Information int linked; glGetProgramiv(programObj_, GL_LINK_STATUS, &linked); if(linked == 0) { int length; glGetProgramiv(programObj_, GL_INFO_LOG_LENGTH, &length); char *str = new char[length]; glGetProgramInfoLog(programObj_, length, NULL, str); std::cerr << "Linker error " << str << std::endl; delete [] str; clear(); assert(false); } }
GLuint LoadShaders(const char * vertex_file_path, const char * fragment_file_path){ // Create the shaders GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER); GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER); // Read the Vertex Shader code from the file std::string VertexShaderCode; std::ifstream VertexShaderStream(vertex_file_path, std::ios::in); if (VertexShaderStream.is_open()){ std::string Line = ""; while (getline(VertexShaderStream, Line)) VertexShaderCode += "\n" + Line; VertexShaderStream.close(); } else{ printf("Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !\n", vertex_file_path); getchar(); return 0; } // Read the Fragment Shader code from the file std::string FragmentShaderCode; std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in); if (FragmentShaderStream.is_open()){ std::string Line = ""; while (getline(FragmentShaderStream, Line)) FragmentShaderCode += "\n" + Line; FragmentShaderStream.close(); } GLint Result = GL_FALSE; int InfoLogLength; // Compile Vertex Shader printf("Compiling shader : %s\n", vertex_file_path); char const * VertexSourcePointer = VertexShaderCode.c_str(); glShaderSource(VertexShaderID, 1, &VertexSourcePointer, NULL); glCompileShader(VertexShaderID); // Check Vertex Shader glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result); glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); if (InfoLogLength > 0){ std::vector<char> VertexShaderErrorMessage(InfoLogLength + 1); glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]); printf("%s\n", &VertexShaderErrorMessage[0]); } // Compile Fragment Shader printf("Compiling shader : %s\n", fragment_file_path); char const * FragmentSourcePointer = FragmentShaderCode.c_str(); glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer, NULL); glCompileShader(FragmentShaderID); // Check Fragment Shader glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result); glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); if (InfoLogLength > 0){ std::vector<char> FragmentShaderErrorMessage(InfoLogLength + 1); glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]); printf("%s\n", &FragmentShaderErrorMessage[0]); } // Link the program printf("Linking program\n"); GLuint ProgramID = glCreateProgram(); glAttachShader(ProgramID, VertexShaderID); glAttachShader(ProgramID, FragmentShaderID); glLinkProgram(ProgramID); // Check the program glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result); glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength); if (InfoLogLength > 0){ std::vector<char> ProgramErrorMessage(InfoLogLength + 1); glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]); printf("%s\n", &ProgramErrorMessage[0]); } glDeleteShader(VertexShaderID); glDeleteShader(FragmentShaderID); return ProgramID; }
///////////////////////////////////////////////////////////////// // Load a pair of shaders, compile, and link together. Specify the complete // file path for each shader. Note, there is no support for // just loading say a vertex program... you have to do both. GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg, bool loadFromFile) { // Temporary Shader objects GLuint hVertexShader; GLuint hFragmentShader; GLuint hReturn = 0; GLint testVal; // Create shader objects hVertexShader = glCreateShader(GL_VERTEX_SHADER); hFragmentShader = glCreateShader(GL_FRAGMENT_SHADER); if (loadFromFile) { if(gltLoadShaderFile(szVertexProg, hVertexShader) == false) { glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } if(gltLoadShaderFile(szFragmentProg, hFragmentShader) == false) { glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } } else { gltLoadShaderSrc(vertexShader, hVertexShader); gltLoadShaderSrc(fragmentShader, hFragmentShader); } // Compile them glCompileShader(hVertexShader); glCompileShader(hFragmentShader); // Check for errors glGetShaderiv(hVertexShader, GL_COMPILE_STATUS, &testVal); if(testVal == GL_FALSE) { char temp[256] = ""; glGetShaderInfoLog( hVertexShader, 256, NULL, temp); fprintf( stderr, "Compile failed:\n%s\n", temp); assert(0); exit(0); glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } glGetShaderiv(hFragmentShader, GL_COMPILE_STATUS, &testVal); if(testVal == GL_FALSE) { char temp[256] = ""; glGetShaderInfoLog( hFragmentShader, 256, NULL, temp); fprintf( stderr, "Compile failed:\n%s\n", temp); assert(0); exit(0); glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } // Link them - assuming it works... hReturn = glCreateProgram(); glAttachShader(hReturn, hVertexShader); glAttachShader(hReturn, hFragmentShader); glLinkProgram(hReturn); // These are no longer needed glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); // Make sure link worked too glGetProgramiv(hReturn, GL_LINK_STATUS, &testVal); if(testVal == GL_FALSE) { glDeleteProgram(hReturn); return (GLuint)NULL; } return hReturn; }
// load shaders GLuint loadShader(const char *vertex_path, const char *fragment_path) { // create shaders GLuint vertShader = glCreateShader(GL_VERTEX_SHADER); GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER); // read shaders std::string vertShaderStr = readFile(vertex_path); std::string fragShaderStr = readFile(fragment_path); const char *vertShaderSrc = vertShaderStr.c_str(); const char *fragShaderSrc = fragShaderStr.c_str(); // hold results GLint result = GL_FALSE; int logLength; // compile vertex shader glShaderSource(vertShader, 1, &vertShaderSrc, NULL); glCompileShader(vertShader); // check vertex shader glGetShaderiv(vertShader, GL_COMPILE_STATUS, &result); // failed compile if(!result) { glGetShaderiv(vertShader, GL_INFO_LOG_LENGTH, &logLength); std::vector<char> vertShaderError((logLength > 1) ? logLength : 1); glGetShaderInfoLog(vertShader, logLength, NULL, &vertShaderError[0]); std::cerr << "[F] FAILED TO COMPILE VERTEX SHADER!" << &vertShaderError[0] << std::endl; return false; } // compile fragment shader glShaderSource(fragShader, 1, &fragShaderSrc, NULL); glCompileShader(fragShader); // check fragment shader glGetShaderiv(fragShader, GL_COMPILE_STATUS, &result); // failed compile if(!result) { glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &logLength); std::vector<char> fragShaderError((logLength > 1) ? logLength : 1); glGetShaderInfoLog(fragShader, logLength, NULL, &fragShaderError[0]); std::cerr << "[F] FAILED TO COMPILE FRAGMENT SHADER!" << &fragShaderError[0] << std::endl; return false; } // create program and link with shaders GLuint program = glCreateProgram(); glAttachShader(program, vertShader); glAttachShader(program, fragShader); glLinkProgram(program); // check program status glGetProgramiv(program, GL_LINK_STATUS, &result); // failed program if(!result) { glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength); std::vector<char> programError( (logLength > 1) ? logLength : 1 ); glGetProgramInfoLog(program, logLength, NULL, &programError[0]); std::cerr << "[F] THE SHADER PROGRAM FAILED TO LINK" << &programError[0] << std::endl; return false; } // delete shaders after attachment glDeleteShader(vertShader); glDeleteShader(fragShader); // return program with shaders return program; }
int main() { int width = 640; int height = 480; if(glfwInit() == GL_FALSE) { std::cerr << "failed to init GLFW" << std::endl; return 1; } // sadly glew doesn't play nice with core profiles... glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3); // create a window if(glfwOpenWindow(width, height, 0, 0, 0, 8, 24, 8, GLFW_WINDOW) == GL_FALSE) { std::cerr << "failed to open window" << std::endl; glfwTerminate(); return 1; } // setup windows close callback glfwSetWindowCloseCallback(closedWindow); // this time we disable the mouse cursor since we want differential // mouse input glfwDisable(GLFW_MOUSE_CURSOR); if (gl3wInit()) { std::cerr << "failed to init GL3W" << std::endl; glfwCloseWindow(); glfwTerminate(); return 1; } // draw shader std::string vertex_source = "#version 330\n" "uniform mat4 ViewProjection;\n" "layout(location = 0) in vec4 vposition;\n" "layout(location = 1) in vec3 normal;\n" "out vec4 fcolor;\n" "void main() {\n" " float brightness = dot(normal,normalize(vec3(1,2,3)));\n" " brightness = 0.3+((brightness>0)?0.7*brightness:0.3*brightness);\n" " fcolor = vec4(brightness,brightness,brightness,1);\n" " gl_Position = ViewProjection*vposition;\n" "}\n"; std::string fragment_source = "#version 330\n" "in vec4 fcolor;\n" "layout(location = 0) out vec4 FragColor;\n" "void main() {\n" " FragColor = abs(fcolor);\n" "}\n"; // program and shader handles GLuint shader_program, vertex_shader, fragment_shader; // we need these to properly pass the strings const char *source; int length; // create and compiler vertex shader vertex_shader = glCreateShader(GL_VERTEX_SHADER); source = vertex_source.c_str(); length = vertex_source.size(); glShaderSource(vertex_shader, 1, &source, &length); glCompileShader(vertex_shader); if(!check_shader_compile_status(vertex_shader)) { return 1; } // create and compiler fragment shader fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); source = fragment_source.c_str(); length = fragment_source.size(); glShaderSource(fragment_shader, 1, &source, &length); glCompileShader(fragment_shader); if(!check_shader_compile_status(fragment_shader)) { return 1; } // create program shader_program = glCreateProgram(); // attach shaders glAttachShader(shader_program, vertex_shader); glAttachShader(shader_program, fragment_shader); // link the program and check for errors glLinkProgram(shader_program); check_program_link_status(shader_program); // obtain location of projection uniform GLint DrawViewProjection_location = glGetUniformLocation(shader_program, "ViewProjection"); // trivial shader for occlusion queries std::string query_vertex_source = "#version 330\n" "uniform mat4 ViewProjection;\n" "layout(location = 0) in vec4 vposition;\n" "void main() {\n" " gl_Position = ViewProjection*vposition;\n" "}\n"; std::string query_fragment_source = "#version 330\n" "void main() {\n" "}\n"; // program and shader handles GLuint query_shader_program, query_vertex_shader, query_fragment_shader; // create and compiler vertex shader query_vertex_shader = glCreateShader(GL_VERTEX_SHADER); source = query_vertex_source.c_str(); length = query_vertex_source.size(); glShaderSource(query_vertex_shader, 1, &source, &length); glCompileShader(query_vertex_shader); if(!check_shader_compile_status(query_vertex_shader)) { return 1; } // create and compiler fragment shader query_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); source = query_fragment_source.c_str(); length = query_fragment_source.size(); glShaderSource(query_fragment_shader, 1, &source, &length); glCompileShader(query_fragment_shader); if(!check_shader_compile_status(query_fragment_shader)) { return 1; } // create program query_shader_program = glCreateProgram(); // attach shaders glAttachShader(query_shader_program, query_vertex_shader); glAttachShader(query_shader_program, query_fragment_shader); // link the program and check for errors glLinkProgram(query_shader_program); check_program_link_status(query_shader_program); // obtain location of projection uniform GLint QueryViewProjection_location = glGetUniformLocation(query_shader_program, "ViewProjection"); // chunk container and chunk parameters std::vector<Chunk> chunks; int chunkrange = 4; int chunksize = 32; // chunk extraction std::cout << "generating chunks, this may take a while." << std::endl; // iterate over all chunks we want to extract for(int i = -chunkrange;i<chunkrange;++i) for(int j = -chunkrange;j<chunkrange;++j) for(int k = -chunkrange;k<chunkrange;++k) { Chunk chunk; // chunk data // generate and bind the vao glGenVertexArrays(1, &chunk.vao); glBindVertexArray(chunk.vao); // generate and bind the vertex buffer object glGenBuffers(1, &chunk.vbo); glBindBuffer(GL_ARRAY_BUFFER, chunk.vbo); std::vector<glm::vec3> vertexData; glm::vec3 offset = static_cast<float>(chunksize) * glm::vec3(i,j,k); float threshold = 0.0f; // iterate over all blocks within the chunk for(int x = 0;x<chunksize;++x) for(int y = 0;y<chunksize;++y) for(int z = 0;z<chunksize;++z) { glm::vec3 pos = glm::vec3(x,y,z) + offset; // insert quads if current block is solid and neighbors are not if(world_function(pos)<threshold) { if(world_function(pos+glm::vec3(1,0,0))>=threshold) { vertexData.push_back(pos+0.5f*glm::vec3( 1, 1, 1)); vertexData.push_back(glm::vec3( 1, 0, 0)); vertexData.push_back(pos+0.5f*glm::vec3( 1,-1, 1)); vertexData.push_back(glm::vec3( 1, 0, 0)); vertexData.push_back(pos+0.5f*glm::vec3( 1, 1,-1)); vertexData.push_back(glm::vec3( 1, 0, 0)); vertexData.push_back(pos+0.5f*glm::vec3( 1,-1,-1)); vertexData.push_back(glm::vec3( 1, 0, 0)); } if(world_function(pos+glm::vec3(0,1,0))>=threshold) { vertexData.push_back(pos+0.5f*glm::vec3( 1, 1, 1)); vertexData.push_back(glm::vec3( 0, 1, 0)); vertexData.push_back(pos+0.5f*glm::vec3( 1, 1,-1)); vertexData.push_back(glm::vec3( 0, 1, 0)); vertexData.push_back(pos+0.5f*glm::vec3(-1, 1, 1)); vertexData.push_back(glm::vec3( 0, 1, 0)); vertexData.push_back(pos+0.5f*glm::vec3(-1, 1,-1)); vertexData.push_back(glm::vec3( 0, 1, 0)); } if(world_function(pos+glm::vec3(0,0,1))>=threshold) { vertexData.push_back(pos+0.5f*glm::vec3( 1, 1, 1)); vertexData.push_back(glm::vec3( 0, 0, 1)); vertexData.push_back(pos+0.5f*glm::vec3(-1, 1, 1)); vertexData.push_back(glm::vec3( 0, 0, 1)); vertexData.push_back(pos+0.5f*glm::vec3( 1,-1, 1)); vertexData.push_back(glm::vec3( 0, 0, 1)); vertexData.push_back(pos+0.5f*glm::vec3(-1,-1, 1)); vertexData.push_back(glm::vec3( 0, 0, 1)); } if(world_function(pos-glm::vec3(1,0,0))>=threshold) { vertexData.push_back(pos+0.5f*glm::vec3(-1, 1, 1)); vertexData.push_back(glm::vec3(-1, 0, 0)); vertexData.push_back(pos+0.5f*glm::vec3(-1, 1,-1)); vertexData.push_back(glm::vec3(-1, 0, 0)); vertexData.push_back(pos+0.5f*glm::vec3(-1,-1, 1)); vertexData.push_back(glm::vec3(-1, 0, 0)); vertexData.push_back(pos+0.5f*glm::vec3(-1,-1,-1)); vertexData.push_back(glm::vec3(-1, 0, 0)); } if(world_function(pos-glm::vec3(0,1,0))>=threshold) { vertexData.push_back(pos+0.5f*glm::vec3( 1,-1, 1)); vertexData.push_back(glm::vec3( 0,-1, 0)); vertexData.push_back(pos+0.5f*glm::vec3(-1,-1, 1)); vertexData.push_back(glm::vec3( 0,-1, 0)); vertexData.push_back(pos+0.5f*glm::vec3( 1,-1,-1)); vertexData.push_back(glm::vec3( 0,-1, 0)); vertexData.push_back(pos+0.5f*glm::vec3(-1,-1,-1)); vertexData.push_back(glm::vec3( 0,-1, 0)); } if(world_function(pos-glm::vec3(0,0,1))>=threshold) { vertexData.push_back(pos+0.5f*glm::vec3( 1, 1,-1)); vertexData.push_back(glm::vec3( 0, 0,-1)); vertexData.push_back(pos+0.5f*glm::vec3( 1,-1,-1)); vertexData.push_back(glm::vec3( 0, 0,-1)); vertexData.push_back(pos+0.5f*glm::vec3(-1, 1,-1)); vertexData.push_back(glm::vec3( 0, 0,-1)); vertexData.push_back(pos+0.5f*glm::vec3(-1,-1,-1)); vertexData.push_back(glm::vec3( 0, 0,-1)); } } } // upload glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3)*vertexData.size(), &vertexData[0], GL_STATIC_DRAW); // set up generic attrib pointers glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), (char*)0 + 0*sizeof(GLfloat)); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), (char*)0 + 3*sizeof(GLfloat)); // generate and bind the index buffer object glGenBuffers(1, &chunk.ibo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, chunk.ibo); chunk.quadcount = vertexData.size()/8; std::vector<GLuint> indexData(6*chunk.quadcount); for(int i = 0;i<chunk.quadcount;++i) { indexData[6*i + 0] = 4*i + 0; indexData[6*i + 1] = 4*i + 1; indexData[6*i + 2] = 4*i + 2; indexData[6*i + 3] = 4*i + 2; indexData[6*i + 4] = 4*i + 1; indexData[6*i + 5] = 4*i + 3; } // upload glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*indexData.size(), &indexData[0], GL_STATIC_DRAW); // chunk bounding box // generate and bind the vao glGenVertexArrays(1, &chunk.bounding_vao); glBindVertexArray(chunk.bounding_vao); // generate and bind the vertex buffer object glGenBuffers(1, &chunk.bounding_vbo); glBindBuffer(GL_ARRAY_BUFFER, chunk.bounding_vbo); // data for the bounding cube GLfloat boundingVertexData[] = { // X Y Z // face 0: offset.x+chunksize-0.5f, offset.y+chunksize-0.5f, offset.z+chunksize-0.5f, offset.x-0.5f, offset.y+chunksize-0.5f, offset.z+chunksize-0.5f, offset.x+chunksize-0.5f, offset.y-0.5f, offset.z+chunksize-0.5f, offset.x-0.5f, offset.y-0.5f, offset.z+chunksize-0.5f, // face 1: offset.x+chunksize-0.5f, offset.y+chunksize-0.5f, offset.z+chunksize-0.5f, offset.x+chunksize-0.5f, offset.y-0.5f, offset.z+chunksize-0.5f, offset.x+chunksize-0.5f, offset.y+chunksize-0.5f, offset.z-0.5f, offset.x+chunksize-0.5f, offset.y-0.5f, offset.z-0.5f, // face 2: offset.x+chunksize-0.5f, offset.y+chunksize-0.5f, offset.z+chunksize-0.5f, offset.x+chunksize-0.5f, offset.y+chunksize-0.5f, offset.z-0.5f, offset.x-0.5f, offset.y+chunksize-0.5f, offset.z+chunksize-0.5f, offset.x-0.5f, offset.y+chunksize-0.5f, offset.z-0.5f, // face 3: offset.x+chunksize-0.5f, offset.y+chunksize-0.5f, offset.z-0.5f, offset.x+chunksize-0.5f, offset.y-0.5f, offset.z-0.5f, offset.x-0.5f, offset.y+chunksize-0.5f, offset.z-0.5f, offset.x-0.5f, offset.y-0.5f, offset.z-0.5f, // face 4: offset.x-0.5f, offset.y+chunksize-0.5f, offset.z+chunksize-0.5f, offset.x-0.5f, offset.y+chunksize-0.5f, offset.z-0.5f, offset.x-0.5f, offset.y-0.5f, offset.z+chunksize-0.5f, offset.x-0.5f, offset.y-0.5f, offset.z-0.5f, // face 5: offset.x+chunksize-0.5f, offset.y-0.5f, offset.z+chunksize-0.5f, offset.x-0.5f, offset.y-0.5f, offset.z+chunksize-0.5f, offset.x+chunksize-0.5f, offset.y-0.5f, offset.z-0.5f, offset.x-0.5f, offset.y-0.5f, offset.z-0.5f, }; // 6 faces with 4 vertices with 6 components (floats) // fill with data glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*6*4*3, boundingVertexData, GL_STATIC_DRAW); // set up generic attrib pointers glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), (char*)0 + 0*sizeof(GLfloat)); // generate and bind the index buffer object glGenBuffers(1, &chunk.bounding_ibo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, chunk.bounding_ibo); GLuint boundingIndexData[] = { 0, 1, 2, 2, 1, 3, 4, 5, 6, 6, 5, 7, 8, 9,10,10, 9,11, 12,13,14,14,13,15,16,17,18,18,17,19,20,21,22,22,21,23, }; // fill with data glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*6*2*3, boundingIndexData, GL_STATIC_DRAW); // generate the query object for the occlusion query glGenQueries(1, &chunk.query); // set the center location of the chunk chunk.center = offset + 0.5f*chunksize; // add to container chunks.push_back(chunk); } // "unbind" vao glBindVertexArray(0); // timer query setup // use multiple queries to avoid stalling on getting the results const int querycount = 5; GLuint queries[querycount]; int current_query = 0; glGenQueries(querycount, queries); // we are drawing 3d objects so we want depth testing glEnable(GL_DEPTH_TEST); // camera position and orientation glm::vec3 position; glm::mat4 rotation = glm::mat4(1.0f); running = true; float t = glfwGetTime(); bool occlusion_cull = true; bool space_down = false; // mouse position int mousex, mousey; glfwGetMousePos(&mousex, &mousey); while(running) { // calculate timestep float new_t = glfwGetTime(); float dt = new_t - t; t = new_t; // update mouse differential int tmpx, tmpy; glfwGetMousePos(&tmpx, &tmpy); glm::vec2 mousediff(tmpx-mousex, tmpy-mousey); mousex = tmpx; mousey = tmpy; // find up, forward and right vector glm::mat3 rotation3(rotation); glm::vec3 up = glm::transpose(rotation3)*glm::vec3(0.0f, 1.0f, 0.0f); glm::vec3 right = glm::transpose(rotation3)*glm::vec3(1.0f, 0.0f, 0.0f); glm::vec3 forward = glm::transpose(rotation3)*glm::vec3(0.0f, 0.0f,-1.0f); // apply mouse rotation rotation = glm::rotate(rotation, 0.2f*mousediff.x, up); rotation = glm::rotate(rotation, 0.2f*mousediff.y, right); // roll if(glfwGetKey('Q')) { rotation = glm::rotate(rotation, 180.0f*dt, forward); } if(glfwGetKey('E')) { rotation = glm::rotate(rotation,-180.0f*dt, forward); } // movement if(glfwGetKey('W')) { position += 10.0f*dt*forward; } if(glfwGetKey('S')) { position -= 10.0f*dt*forward; } if(glfwGetKey('D')) { position += 10.0f*dt*right; } if(glfwGetKey('A')) { position -= 10.0f*dt*right; } // toggle occlusion culling if(glfwGetKey(GLFW_KEY_SPACE) && !space_down) { occlusion_cull = !occlusion_cull; } space_down = glfwGetKey(GLFW_KEY_SPACE); // terminate on escape if(glfwGetKey(GLFW_KEY_ESC)) { running = false; } // calculate ViewProjection matrix glm::mat4 Projection = glm::perspective(90.0f, 4.0f / 3.0f, 0.1f, 200.f); glm::mat4 View = rotation*glm::translate(glm::mat4(1.0f), -position); glm::mat4 ViewProjection = Projection*View; // set matrices for both shaders glUseProgram(query_shader_program); glUniformMatrix4fv(QueryViewProjection_location, 1, GL_FALSE, glm::value_ptr(ViewProjection)); glUseProgram(shader_program); glUniformMatrix4fv(DrawViewProjection_location, 1, GL_FALSE, glm::value_ptr(ViewProjection)); // set clear color to sky blue glClearColor(0.5f,0.8f,1.0f,1.0f); // clear glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // sort chunks by distance std::sort(chunks.begin(), chunks.end(), DistancePred(position)); size_t i = 0; float maxdist = chunksize; // start timer query glBeginQuery(GL_TIME_ELAPSED, queries[current_query]); // peel chunks while(i!=chunks.size()) { size_t j = i; if(occlusion_cull) { // start occlusion queries and render for the current slice glDisable(GL_CULL_FACE); // we don't want the queries to actually render something glDepthMask(GL_FALSE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glUseProgram(query_shader_program); for(;j<chunks.size() && glm::distance(chunks[j].center, position)<maxdist;++j) { // frustum culling glm::vec4 projected = ViewProjection*glm::vec4(chunks[j].center,1); if( (glm::distance(chunks[j].center,position) > chunksize) && (std::max(std::abs(projected.x), std::abs(projected.y)) > projected.w+chunksize)) continue; // begin occlusion query glBeginQuery(GL_ANY_SAMPLES_PASSED, chunks[j].query); // draw bounding box glBindVertexArray(chunks[j].bounding_vao); glDrawElements(GL_TRIANGLES, 6*6, GL_UNSIGNED_INT, 0); // end occlusion query glEndQuery(GL_ANY_SAMPLES_PASSED); } j = i; } // render the current slice glEnable(GL_CULL_FACE); // turn rendering back on glDepthMask(GL_TRUE); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glUseProgram(shader_program); for(;j<chunks.size() && glm::distance(chunks[j].center, position)<maxdist;++j) { // frustum culling glm::vec4 projected = ViewProjection*glm::vec4(chunks[j].center,1); if( (glm::distance(chunks[j].center,position) > chunksize) && (std::max(std::abs(projected.x), std::abs(projected.y)) > projected.w+chunksize)) continue; // begin conditional render if(occlusion_cull) glBeginConditionalRender(chunks[j].query, GL_QUERY_BY_REGION_WAIT); // draw chunk glBindVertexArray(chunks[j].vao); glDrawElements(GL_TRIANGLES, 6*chunks[j].quadcount, GL_UNSIGNED_INT, 0); // end conditional render if(occlusion_cull) glEndConditionalRender(); } i = j; maxdist += 2*chunksize; } // end timer query glEndQuery(GL_TIME_ELAPSED); // display timer query results from querycount frames before if(GL_TRUE == glIsQuery(queries[(current_query+1)%querycount])) { GLuint64 result; glGetQueryObjectui64v(queries[(current_query+1)%querycount], GL_QUERY_RESULT, &result); std::cout << result*1.e-6 << " ms/frame" << std::endl; } // advance query counter current_query = (current_query + 1)%querycount; // check for errors GLenum error = glGetError(); if(error != GL_NO_ERROR) { std::cerr << gluErrorString(error); running = false; } // finally swap buffers glfwSwapBuffers(); } // delete the created objects for(size_t i = 0;i<chunks.size();++i) { glDeleteVertexArrays(1, &chunks[i].vao); glDeleteBuffers(1, &chunks[i].vbo); glDeleteBuffers(1, &chunks[i].ibo); glDeleteVertexArrays(1, &chunks[i].bounding_vao); glDeleteBuffers(1, &chunks[i].bounding_vbo); glDeleteBuffers(1, &chunks[i].bounding_ibo); glDeleteQueries(1, &chunks[i].query); } glDeleteQueries(querycount, queries); glDetachShader(shader_program, vertex_shader); glDetachShader(shader_program, fragment_shader); glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); glDeleteProgram(shader_program); glDetachShader(query_shader_program, query_vertex_shader); glDetachShader(query_shader_program, query_fragment_shader); glDeleteShader(query_vertex_shader); glDeleteShader(query_fragment_shader); glDeleteProgram(query_shader_program); glfwCloseWindow(); glfwTerminate(); return 0; }
Shader(const std::string &fileName, GLenum type) : mObjectName(0), mType(type) { mObjectName = glCreateShader(mType); setFromFile(fileName); }
// Create a GLSL program object from vertex and fragment shader files GLuint InitShader(const char* vShaderFile, const char* fShaderFile) { struct Shader { const char* filename; GLenum type; GLchar* source; } shaders[2] = { { vShaderFile, GL_VERTEX_SHADER, NULL }, { fShaderFile, GL_FRAGMENT_SHADER, NULL } }; GLuint program = glCreateProgram(); for ( int i = 0; i < 2; ++i ) { Shader& s = shaders[i]; s.source = readShaderSource( s.filename ); if ( shaders[i].source == NULL ) { std::cerr << "Failed to read " << s.filename << std::endl; exit( EXIT_FAILURE ); } GLuint shader = glCreateShader( s.type ); glShaderSource( shader, 1, (const GLchar**) &s.source, NULL ); glCompileShader( shader ); GLint compiled; glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled ); if ( !compiled ) { std::cerr << s.filename << " failed to compile:" << std::endl; GLint logSize; glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logSize ); char* logMsg = new char[logSize]; glGetShaderInfoLog( shader, logSize, NULL, logMsg ); std::cerr << logMsg << std::endl; delete [] logMsg; exit( EXIT_FAILURE ); } delete [] s.source; glAttachShader( program, shader ); } /* link and error check */ glLinkProgram(program); GLint linked; glGetProgramiv( program, GL_LINK_STATUS, &linked ); if ( !linked ) { std::cerr << "Shader program failed to link" << std::endl; GLint logSize; glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logSize); char* logMsg = new char[logSize]; glGetProgramInfoLog( program, logSize, NULL, logMsg ); std::cerr << logMsg << std::endl; delete [] logMsg; exit( EXIT_FAILURE ); } /* use program object */ glUseProgram(program); return program; }
GLShader::GLShader(EGLShaderType type, const string &filename) :m_ID(GL_NONE), m_type(type) { // Check if file exists if(!fileExists(filename)) { cerr << "Shader source file '" << filename << "' does not exist." << endl; } // File exists else { // Create shader m_ID = glCreateShader(getShaderTypeConstant(type)); if(m_ID == GL_NONE) { cerr << "Could not create OpenGL shader." << endl; } // Successfully created shader else { cout << "Created OpenGL shader: " << m_ID << endl; // Load shader source string line, source; ifstream sourceStream(filename); while(sourceStream.good() && !sourceStream.eof()) { getline(sourceStream, line); source.append(line + "\n"); } // Compile shader const char *sourceCString = source.c_str(); glShaderSource(m_ID, 1, &sourceCString, nullptr); glCompileShader(m_ID); // Check compilation GLint compileResult; glGetShaderiv(m_ID, GL_COMPILE_STATUS, &compileResult); if(compileResult != GL_TRUE) { cerr << "Shader compilation of file '" << filename << "' failed." << endl; GLsizei logLength; GLchar log[1024]; glGetShaderInfoLog( m_ID, sizeof(log), &logLength, log); cerr << "Shader info log: " << endl << log << endl; } // Compilation worked else { cout << "Successfully compiled shader '" << filename << "'" << endl; } } } }
void Poh::gLib::Shader::glibShader::Build(Poh::gLib::Application::itfApplication * _application, const char * VertexShaderSource, const char * FragmentShaderSource) { if (_application->MakeContextCurrent() != 0) { throw glibException(GLIB_ERROR_TYPE_SHADER | OPENGL_CONTEXT_ERROR); } if (_shader != 0) { } if (glewInit() != GLEW_OK) { throw glibException(GLIB_ERROR_TYPE_SHADER | OPENGL_CONTEXT_ERROR); } _shader = glCreateProgram(); if (_shader == 0) { throw glibException(GLIB_ERROR_TYPE_SHADER | OPENGL_SHADER_OVERRIDE_ERROR); } GLint success = 0; success = 0; GLuint _vShr = glCreateShader(GL_VERTEX_SHADER); glShaderSource(_vShr, 1, &VertexShaderSource, 0); glCompileShader(_vShr); glGetShaderiv(_vShr, GL_COMPILE_STATUS, &success); if (success != GL_TRUE) { GLint len = 0; glGetShaderiv(_vShr, GL_INFO_LOG_LENGTH, &success); GLchar * log = new GLchar[len]{}; glGetShaderInfoLog(_vShr, len, 0, log); delete[] log; } success = 0; GLuint _fShr = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(_fShr, 1, &FragmentShaderSource, 0); glCompileShader(_fShr); glGetShaderiv(_fShr, GL_COMPILE_STATUS, &success); if (success != GL_TRUE) { GLint len = 0; glGetShaderiv(_fShr, GL_INFO_LOG_LENGTH, &success); GLchar * log = new GLchar[len]{}; glGetShaderInfoLog(_fShr, len, 0, log); delete[] log; } glAttachShader(_shader, _vShr); glAttachShader(_shader, _fShr); glLinkProgram(_shader); success = 0; glGetProgramiv(_shader, GL_LINK_STATUS, &success); if (success != GL_TRUE) { GLint len = 0; glGetProgramiv(_shader, GL_INFO_LOG_LENGTH, &success); GLchar * log = new GLchar[len]{}; glGetProgramInfoLog(_shader, len, 0, log); delete[] log; } glDeleteShader(_vShr); glDeleteShader(_fShr); glGenBuffers(1, &_vbo); glGenVertexArrays(1, &_vao); }
GLuint CreateProgram(const char* VertexShader, const char* FragmentShader) { Text sourceVert, sourceFrag; //Load Vertex Shader sourceVert.readTexFile(VertexShader); const char* vpString = sourceVert.getContent(); //Load Fragment Shader sourceFrag.readTexFile(FragmentShader); const char* fpString = sourceFrag.getContent(); GLuint programHandle = glCreateProgram(); GLint compileSuccess; GLchar compilerSpew[256]; //Attach Vertex Shader GLuint vsHandle = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vsHandle, 1, &vpString, 0); glCompileShader(vsHandle); glGetShaderiv(vsHandle, GL_COMPILE_STATUS, &compileSuccess); glGetShaderInfoLog(vsHandle, sizeof(compilerSpew), 0, compilerSpew); if (!compileSuccess) { std::cout<<"Failed to compile/attach"; } else { std::cout<<"Succeded to compile/attach"; } glAttachShader(programHandle, vsHandle); //Attach Fragment Shader GLuint fsHandle = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fsHandle, 1, &fpString, 0); glCompileShader(fsHandle); glAttachShader(programHandle, fsHandle); glGetShaderiv(fsHandle, GL_COMPILE_STATUS, &compileSuccess); glGetShaderInfoLog(fsHandle, sizeof(compilerSpew), 0, compilerSpew); if (!compileSuccess) { std::cout<<"Failed to compile/attach"; } else { std::cout<<"Succeded to compile/attach"; } glLinkProgram(programHandle); GLint linkSuccess; glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess); glGetProgramInfoLog(programHandle, sizeof(compilerSpew), 0, compilerSpew); if (!linkSuccess) { std::cout<<"Failed to compile/attach"; } else { std::cout<<"Succeded to compile/attach"; } return programHandle; }
GLuint LoadShaders( ShaderInfo* shaders ) { if ( shaders == NULL ) { return 0; } GLuint program = glCreateProgram(); ShaderInfo* entry = shaders; while ( entry->type != GL_NONE ) { GLuint shader = glCreateShader( entry->type ); entry->shader = shader; const GLchar* source = ReadShader( entry->filename ); if ( source == NULL ) { for ( entry = shaders; entry->type != GL_NONE; ++entry ) { glDeleteShader( entry->shader ); entry->shader = 0; } return 0; } glShaderSource( shader, 1, &source, NULL ); delete [] source; glCompileShader( shader ); GLint compiled; glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled ); if ( !compiled ) { #ifdef _DEBUG GLsizei len; glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &len ); GLchar* log = new GLchar[len+1]; glGetShaderInfoLog( shader, len, &len, log ); std::cerr << "Shader compilation failed: " << log << std::endl; delete [] log; #endif /* DEBUG */ return 0; } glAttachShader( program, shader ); ++entry; } glLinkProgram( program ); GLint linked; glGetProgramiv( program, GL_LINK_STATUS, &linked ); if ( !linked ) { #ifdef _DEBUG GLsizei len; glGetProgramiv( program, GL_INFO_LOG_LENGTH, &len ); GLchar* log = new GLchar[len+1]; glGetProgramInfoLog( program, len, &len, log ); std::cerr << "Shader linking failed: " << log << std::endl; delete [] log; #endif /* DEBUG */ for ( entry = shaders; entry->type != GL_NONE; ++entry ) { glDeleteShader( entry->shader ); entry->shader = 0; } return 0; } return program; }
bool GLSLShader_vinit(GLSLShader * self, const char * vshaderSource, size_t vshaderLength, const char * fshaderSource, size_t fshaderLength, va_list args) { GLint shaderLength; GLuint vertexShader, fragmentShader; const char * attribName; GLuint attribLocation; #ifdef DEBUG GLint logLength; #endif call_super(init, self); self->dispose = GLSLShader_dispose; self->getUniformLocation = GLSLShader_getUniformLocation; self->activate = GLSLShader_activate; self->deactivate = GLSLShader_deactivate; self->validate = GLSLShader_validate; self->program = glCreateProgram(); vertexShader = glCreateShader(GL_VERTEX_SHADER); fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); shaderLength = vshaderLength; glShaderSource(vertexShader, 1, (const GLchar **) &vshaderSource, &shaderLength); glCompileShader(vertexShader); #ifdef DEBUG glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logLength); if (logLength > 0) { GLchar * log = malloc(logLength); glGetShaderInfoLog(vertexShader, logLength, &logLength, log); if (logLength > 0) { // Surprisingly enough, this is not always true! In the glgraphics test harness, Windows gives me 1 the first time, and 0 the second... fprintf(stderr, "Vertex shader compile log:\n%s\n", log); } free(log); } #endif shaderLength = fshaderLength; glShaderSource(fragmentShader, 1, (const GLchar **) &fshaderSource, &shaderLength); glCompileShader(fragmentShader); #ifdef DEBUG glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &logLength); if (logLength > 0) { GLchar * log = malloc(logLength); glGetShaderInfoLog(fragmentShader, logLength, &logLength, log); if (logLength > 0) { fprintf(stderr, "Fragment shader compile log:\n%s\n", log); } free(log); } #endif glAttachShader(self->program, vertexShader); glAttachShader(self->program, fragmentShader); for (attribName = va_arg(args, const char *); attribName != NULL; attribName = va_arg(args, const char *)) { attribLocation = va_arg(args, GLuint); glBindAttribLocation(self->program, attribLocation, attribName); } glLinkProgram(self->program); #ifdef DEBUG glGetProgramiv(self->program, GL_INFO_LOG_LENGTH, &logLength); if (logLength > 0) { GLchar * log = malloc(logLength); glGetProgramInfoLog(self->program, logLength, &logLength, log); if (logLength > 0) { fprintf(stderr, "Program link log:\n%s\n", log); } free(log); } #endif glDeleteShader(vertexShader); glDeleteShader(fragmentShader); return true; }
GLuint ShaderLoader::loadShader() { GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); //Read Shader std::string strVertexShader = loadFile(pathVertexShader); std::string strFragmentShader = loadFile(pathFragmentShader); const char* cStrVertexShader = strVertexShader.c_str(); const char* cStrFragmentShader = strFragmentShader.c_str(); GLint result = GL_FALSE; int logLength; //Compile Vertex Shader glShaderSource(vertexShader, 1, &cStrVertexShader, NULL); glCompileShader(vertexShader); //Check Vertex Shader glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &result); glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logLength); std::vector<char> vertexShaderError((logLength > 1) ? logLength : 1); if(logLength > 1) { glGetShaderInfoLog(vertexShader, logLength, NULL, &vertexShaderError[0]); std::cerr << &vertexShaderError[0] << std::endl; } //Compile Fragment Shader glShaderSource(fragmentShader, 1, &cStrFragmentShader, NULL); glCompileShader(fragmentShader); //Check Fragment Shader glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &result); glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &logLength); std::vector<char> fragmentShaderError((logLength > 1) ? logLength : 1); if(logLength > 1) { glGetShaderInfoLog(fragmentShader, logLength, NULL, &fragmentShaderError[0]); std::cerr << &fragmentShaderError[0] << std::endl; } //Link Program GLuint program = glCreateProgram(); glAttachShader(program, vertexShader); glAttachShader(program, fragmentShader); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &result); glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength); std::vector<char> programError( (logLength > 1) ? logLength : 1); if(logLength > 1) { glGetProgramInfoLog(program, logLength, NULL, &programError[0]); std::cerr << &programError[0] << std::endl; } //Return Program return program; }
void OpenGlImplement::InitShaders() { /////CHECK VERSION OF OPENGL///// //char message [200]; //strcpy (message, (char *)glGetString(GL_VERSION)); //strcat (message, "\n\nEs necesario tener la versinn 3.2 para que funcione adecuadamente.\nSi no es tu caso, actualiza tus Driver de video.\nPrecione ENTER para continuar. "); //SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION,"OpenGL Version: ", (const char *)message,NULL); //Success flag bool success = true; //Generate program shaderProgram = glCreateProgram(); GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); // Read shaders std::string vertShaderStr = readFile("vertex.glsl"); std::string fragShaderStr = readFile("fragment.glsl"); const GLchar *vertexShaderSource = vertShaderStr.c_str(); const GLchar *fragmentShaderSource = fragShaderStr.c_str(); glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glCompileShader(vertexShader); GLint vShaderCompiled = GL_FALSE; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &vShaderCompiled); if (vShaderCompiled != GL_TRUE) printf("Unable to compile vertex shader %d!\n", vertexShader); glAttachShader(shaderProgram, vertexShader); glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); glCompileShader(fragmentShader); GLint fShaderCompiled = GL_FALSE; glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &fShaderCompiled); if (fShaderCompiled != GL_TRUE) printf("Unable to compile fragment shader %d!\n", fragmentShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); GLint programSuccess = GL_TRUE; glGetProgramiv(shaderProgram, GL_LINK_STATUS, &programSuccess); if (programSuccess != GL_TRUE) printf("Error linking program %d!\n", shaderProgram); //Get vertex attribute location vertexPositionAttribute = glGetAttribLocation(shaderProgram, "aVertexPosition"); vertexTextureCoordAttribute = glGetAttribLocation(shaderProgram, "aTextureCoord"); samplerUniform = glGetUniformLocation(shaderProgram, "uSampler"); //Initialize clear color glClearColor(0.6f, 0.6f, 0.6f, 1.f); glViewport(0, 0, WIDTH_SCREEN, HEIGHT_SCREEN); //glClearDepth(1.0f); // Set background depth to farthest glEnable(GL_DEPTH_TEST); // Enable depth testing for z-culling glDepthFunc(GL_ALWAYS); // Set the type of depth-test glShadeModel(GL_SMOOTH); // Enable smooth shading glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Nice perspective corrections }
void load_shader(Shader *s, char *vert_filename, char *frag_filename) { assert(s != NULL); assert(vert_filename != NULL); assert(frag_filename != NULL); strncpy(s->vert_filename, (vert_filename), MAX_FILENAME_LEN); strncpy(s->frag_filename, (frag_filename), MAX_FILENAME_LEN); s->vert_program_id = glCreateShader(GL_VERTEX_SHADER); if (s->vert_program_id == 0) { set_error_msg(&s->status, "Could not create vert shader."); return; } s->frag_program_id = glCreateShader(GL_FRAGMENT_SHADER); if (s->frag_program_id == 0) { set_error_msg(&s->status, "Could not create frag shader."); return; } char *vs = NULL; int vs_size; vs = text_file_read(s->vert_filename, &vs_size); if (vs == NULL) { set_error_msg(&s->status, "Could not read vert shader '%s'.", s->vert_filename); return; } char *fs = NULL; int fs_size; fs = text_file_read(s->frag_filename, &fs_size); if (fs == NULL) { set_error_msg(&s->status, "Could not read frag shader '%s'.", s->frag_filename); return; } GLenum glerror; GLint result; const char * vv = vs; const char * ff = fs; glShaderSource(s->vert_program_id, 1, &vv, NULL); if ((glerror = glGetError()) != GL_NO_ERROR) { set_error_msg(&s->status, "Could set vert shader source. (%d)", glerror); return; } glShaderSource(s->frag_program_id, 1, &ff, NULL); if ((glerror = glGetError()) != GL_NO_ERROR) { set_error_msg(&s->status, "Could set frag shader source. (%d)", glerror); return; } glCompileShader(s->vert_program_id); glGetShaderiv(s->vert_program_id, GL_COMPILE_STATUS, &result); if (result != GL_TRUE) { set_error_msg(&s->status, "Could not compile vert shader."); return; } glCompileShader(s->frag_program_id); glGetShaderiv(s->frag_program_id, GL_COMPILE_STATUS, &result); if (result != GL_TRUE) { set_error_msg(&s->status, "Could not compile frag shader."); return; } free(vs); free(fs); print_shader_log(s->vert_program_id); print_shader_log(s->frag_program_id); s->program_id = glCreateProgram(); if (s->program_id == 0) { set_error_msg(&s->status, "Could not create program."); return; } glAttachShader(s->program_id, s->vert_program_id); if ((glerror = glGetError()) != GL_NO_ERROR) { set_error_msg(&s->status, "Could not attach vert shader. (%d)", glerror); return; } glAttachShader(s->program_id, s->frag_program_id); if ((glerror = glGetError()) != GL_NO_ERROR) { set_error_msg(&s->status, "Could not attach frag shader. (%d)", glerror); return; } glBindFragDataLocation(s->program_id, 0, "FracColor"); if ((glerror = glGetError()) != GL_NO_ERROR) { set_error_msg(&s->status, "Could not bind frag data location. (%d)", glerror); return; } glLinkProgram(s->program_id); glGetProgramiv(s->program_id, GL_LINK_STATUS, &result); if ((glerror = glGetError()) != GL_NO_ERROR || result == GL_FALSE) { set_error_msg(&s->status, "Could not bind frag data location. (%d,%d)", glerror, result); return; } print_program_log(s->program_id); s->vertex_loc = glGetAttribLocation(s->program_id, "MCvertex"); s->normal_loc = glGetAttribLocation(s->program_id, "MCnormal"); s->tangent_loc = glGetAttribLocation(s->program_id, "MCtangent"); s->tex_coords_loc = glGetAttribLocation(s->program_id, "TexCoord0"); s->proj_matrix_loc = glGetUniformLocation(s->program_id, "MVPMatrix"); s->view_matrix_loc = glGetUniformLocation(s->program_id, "MVMatrix"); s->rot_matrix_loc = glGetUniformLocation(s->program_id, "RotMatrix"); }
//----------------------------------------------------------------------------------------------------------------- " normal_PASS = normalize(mvMatrix * vec4(normal, 1.0)).xyz; \n" //----------------------------------------------------------------------------------------------------------------- " varTexcoord = texture; \n" " gl_Position = mvpMatrix * position; \n" " }\n"; //--------------------------------------------------------------------- cube_relief_SHADER_VERTEX = glCreateShader(GL_VERTEX_SHADER); glShaderSource(cube_relief_SHADER_VERTEX, 1, &vertexSource_cube_relief, NULL); glCompileShader(cube_relief_SHADER_VERTEX); //--------------------------------------------------------------------- const GLchar *fragmentSource_cube_relief = " #ifdef GL_ES \n" " #else \n" " #define highp \n" " #endif \n" " uniform sampler2D Texture1; \n" " uniform sampler2D NormalMap; \n" " uniform sampler2D HeightMap; \n" " uniform highp float shininess; \n" " uniform highp float attenuation; \n"
// pass in pointers so we can free the memory in the gpu later void setup_polygons(GLuint *vertex_attribute_obj, GLuint *element_buffer, GLuint *vertex_buffer, GLuint *v_shader, GLuint *f_shader, GLuint *shader_program, int height) { glewInit(); // calculate OpenGL point for 50px away from the top float top = ((height / 2.0f - 50) / (height / 2.0f)); // create vertices simple triangle float vertices[] = { //position //texture coordinates -1.0f, top , 0.0f, 0.0f, // top left 1.0f, top , 1.0f, 0.0f, // top right 1.0f, -1.0f, 1.0f, 1.0f, // bottom-right -1.0f, -1.0f, 0.0f, 1.0f // bottom-left }; glDeleteBuffers(1, vertex_attribute_obj); glDeleteBuffers(1, vertex_buffer); // create vertex array object for storing shader and attribute data glGenVertexArrays(1, vertex_attribute_obj); glBindVertexArray(*vertex_attribute_obj); // create vertex buffer glGenBuffers(1, vertex_buffer); // generate one buffer // make this buffer the "active" buffer glBindBuffer(GL_ARRAY_BUFFER, *vertex_buffer); // put vertices into the buffer glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); // create element buffer GLuint elements[] = { 0, 1, 2, 2, 3, 0 }; glGenBuffers(1, element_buffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *element_buffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW); // create vertex shader *v_shader = glCreateShader(GL_VERTEX_SHADER); // load shader source into GPU glShaderSource(*v_shader, 1, &vertex_shader, NULL); // compile the shader glCompileShader(*v_shader); // check if shader compiled correctly GLint status; glGetShaderiv(*v_shader, GL_COMPILE_STATUS, &status); if(status != GL_TRUE) { puts("Error compiling vertex shader"); // get error log from shader char buffer[512]; glGetShaderInfoLog(*v_shader, 512, NULL, buffer); printf("%s\n", buffer); } // same thing for fragment shader *f_shader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(*f_shader, 1, &fragment_shader, NULL); glCompileShader(*f_shader); glGetShaderiv(*f_shader, GL_COMPILE_STATUS, &status); if(status != GL_TRUE) { puts("Error compiling fragment shader"); // get error log from shader char buffer[512]; glGetShaderInfoLog(*f_shader, 512, NULL, buffer); printf("%s\n", buffer); } // combine shaders into a program *shader_program = glCreateProgram(); glAttachShader(*shader_program, *v_shader); glAttachShader(*shader_program, *f_shader); /*glBindFragDataLocation(*shader_program, 0, "outColor");*/ // link the program glLinkProgram(*shader_program); // tell opengl to use this program glUseProgram(*shader_program); // get position of the input position in vertex_shader GLint posAttribute = glGetAttribLocation(*shader_program, "position"); // always 0 since it's the first and only arg // (arg_position, number of values for that arg, type for each component, // should they be normalized?, distance (in bytes) between each position attribute, // offset from start of array for first attribute value) glVertexAttribPointer(posAttribute, 2, GL_FLOAT, GL_FALSE, 4*sizeof(float), 0); // enable attribute array glEnableVertexAttribArray(posAttribute); GLint texAttrib = glGetAttribLocation(*shader_program, "texCoord"); glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 4*sizeof(float), (void*)(2*sizeof(float))); glEnableVertexAttribArray(texAttrib); }
int CShaderObject::GenProgram(const char* vertexShader, const char* fragmentShader, const char** Attribs, int AttribsArraySize, const char** Uniforms, int UniformsArraySize, const char** Textures, int TextureArraySize) { if (Initialized) return -1; int i; pid = glCreateProgram(); GLuint vs = glCreateShader(GL_VERTEX_SHADER); GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(vs, 1, &vertexShader, 0); glShaderSource(fs, 1, &fragmentShader, 0); glCompileShader(vs); GLint compiled = 0; glGetShaderiv(vs, GL_COMPILE_STATUS, &compiled); if (!compiled) { GLint infoLen = 0; glGetShaderiv(vs, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen) { char* buf = new char[infoLen]; if (buf) { glGetShaderInfoLog(vs, infoLen, NULL, buf); //LOGI("Shader log:\n%s\n", buf); delete[] buf; } } return 0; } glAttachShader(pid, vs); glDeleteShader(vs); glCompileShader(fs); glGetShaderiv(fs, GL_COMPILE_STATUS, &compiled); if (!compiled) { GLint infoLen = 0; glGetShaderiv(fs, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen) { char* buf = new char[infoLen]; if (buf) { glGetShaderInfoLog(fs, infoLen, NULL, buf); //LOGI("Shader log:\n%s\n", buf); delete[] buf; } } return 0; } glAttachShader(pid, fs); glDeleteShader(fs); glLinkProgram(pid); // check if program linked GLint success = 0; glGetProgramiv(pid, GL_LINK_STATUS, &success); if (!success) { GLint bufLength = 0; glGetProgramiv(pid, GL_INFO_LOG_LENGTH, &bufLength); if (bufLength) { char* buf = new char[bufLength]; if (buf) { glGetProgramInfoLog(pid, bufLength, NULL, buf); delete [] buf; } } glDeleteProgram(pid); pid = 0; } if (!pid) return -1; glUseProgram(pid); //bind the vertex attribute from string Attribs[i] to location i for (i = 0; i < AttribsArraySize; ++i) { glBindAttribLocation(pid, i, Attribs[i]); } //get location of uniform from string Uniforms[i] for (i=0; i<UniformsArraySize; i++) { auiLocation[i] = glGetUniformLocation(pid, Uniforms[i]); } int sid; //set the sampler2D named by string Textures[i] to texture i for (i=0; i<TextureArraySize; i++) { sid = glGetUniformLocation(pid, Textures[i]); glUniform1i(sid, i); } Initialized = 1; return 0; }
int CShaderObject::GenCSProgram(const char* computeShader, const char** Uniforms, int UniformsArraySize, const char** Textures, int TextureArraySize) { int i; GLuint program = glCreateProgram(); GLuint cs = glCreateShader(GL_COMPUTE_SHADER); glShaderSource(cs, 1, &(computeShader), 0); glCompileShader(cs); GLint compiled = 0; glGetShaderiv(cs, GL_COMPILE_STATUS, &compiled); if (!compiled) { GLint infoLen = 0; glGetShaderiv(cs, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen) { char* buf = new char[infoLen]; if (buf) { glGetShaderInfoLog(cs, infoLen, NULL, buf); //LOGI("Shader log:\n%s\n", buf); delete[] buf; } } return 0; } glAttachShader(program, cs); // can be deleted since the program will keep a reference glDeleteShader(cs); glLinkProgram(program); // check if program linked GLint success = 0; glGetProgramiv(program, GL_LINK_STATUS, &success); if (!success) { GLint bufLength = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength); if (bufLength) { char* buf = new char[bufLength]; if (buf) { glGetProgramInfoLog(program, bufLength, NULL, buf); //LOGI("Could not link program:\n%s\n", buf); delete [] buf; } } glDeleteProgram(program); program = 0; } //get location of uniform from string Uniforms[i] for (i=0; i<UniformsArraySize; i++) { auiLocation[i] = glGetUniformLocation(program, Uniforms[i]); } err = glGetError(); int sid; //set the sampler2D named by string Textures[i] to texture i for (i=0; i<TextureArraySize; i++) { sid = glGetUniformLocation(program, Textures[i]); glUniform1i(sid, i); } pid = program; return pid; }
Shader(): handle(glCreateShader(detail::ShaderType<T>::value)) {}
OpenGLProgram::OpenGLProgram(string vertex_shader_file_name, string fragment_shader_file_name) { /* Cool preprocessing */ m_program_ok = true; ifstream input_vertex_shader_file(vertex_shader_file_name, ios::in | ios::binary); if (input_vertex_shader_file) { input_vertex_shader_file.seekg(0, ios::end); m_vertex_shader_source.resize(static_cast<unsigned int>(input_vertex_shader_file.tellg())); input_vertex_shader_file.seekg(0, ios::beg); input_vertex_shader_file.read(&m_vertex_shader_source[0], m_vertex_shader_source.size()); input_vertex_shader_file.close(); } else { cerr << "Could not open vertex shader file at: " << vertex_shader_file_name << endl; m_program_ok = false; } ifstream input_fragment_shader_file(fragment_shader_file_name, ios::in | ios::binary); if (input_fragment_shader_file) { input_fragment_shader_file.seekg(0, ios::end); m_fragment_shader_source.resize(static_cast<unsigned int>(input_fragment_shader_file.tellg())); input_fragment_shader_file.seekg(0, ios::beg); input_fragment_shader_file.read(&m_fragment_shader_source[0], m_fragment_shader_source.size()); input_fragment_shader_file.close(); } else { cerr << "Could not open fragment shader file at: " << fragment_shader_file_name << endl; m_program_ok = false; } /* or not */ m_vertex_shader = glCreateShader(GL_VERTEX_SHADER); const char* start = &m_vertex_shader_source[0]; glShaderSource(m_vertex_shader, 1, &start, NULL); m_fragment_shader= glCreateShader(GL_FRAGMENT_SHADER); start = &m_fragment_shader_source[0]; glShaderSource(m_fragment_shader, 1, &start, NULL); try { int status; glCompileShader(m_vertex_shader); glGetShaderiv(m_vertex_shader, GL_COMPILE_STATUS, &status); if(status == GL_FALSE) { throw m_vertex_shader; } glCompileShader(m_fragment_shader); glGetShaderiv(m_fragment_shader, GL_COMPILE_STATUS, &status); if(status == GL_FALSE) { throw m_fragment_shader; } } catch(GLuint bad_shader) { printShaderInfoLog(bad_shader); m_program_ok = false; } m_program = glCreateProgram(); try { int status; glAttachShader(m_program, m_vertex_shader); glAttachShader(m_program, m_fragment_shader); glLinkProgram(m_program); glGetProgramiv(m_program, GL_LINK_STATUS, &status); if(status == GL_FALSE) { throw m_program; } } catch(GLuint bad_program) { printProgramInfoLog(bad_program); m_program_ok = false; } }