Shader *shader_basic(Mat4x4f *mv,Mat4x4f *p ) { Shader *s = NULL; GLuint shader_program; GLuint shader_frag; GLuint shader_vert; GLuint shader_vindex; GLuint shader_cindex; GLuint shader_proj; GLuint shader_mod; char vertexshader[] = "#version 140\n" "uniform mat4 proj;\n" "uniform mat4 mod;\n" "in vec4 Vertex;\n" "in vec4 Color;\n" "out vec4 ColorInterp;\n" "void main() {\n" "gl_Position = proj * (mod * Vertex);\n" "ColorInterp = Color;\n}"; char fragmentshader[] = "#version 140\n" "in vec4 ColorInterp;\n" "out vec4 out_FragColor;\n" "void main() {\n" "out_FragColor = ColorInterp;\n}"; const char * f = fragmentshader; const char * v = vertexshader; //printf("%s\n",vertexshader); //printf("\n\n%s\n",fragmentshader); s = (Shader*)malloc(sizeof(Shader)); if (s == NULL) return s; shader_vert = glCreateShader(GL_VERTEX_SHADER); shader_frag = glCreateShader(GL_FRAGMENT_SHADER); //shader_vert = shader_load("/home/ian/Graphics/Graphics/Gfx2/Shaders/const_mv.vert",GL_VERTEX_SHADER); //shader_frag = shader_load("/home/ian/Graphics/Graphics/Gfx2/Shaders/const_mv.frag",GL_FRAGMENT_SHADER); printGLError("shader A:"); if (!shader_vert) printf("error creating shader\n"); if (!shader_frag) printf("error creating shader\n"); glShaderSource(shader_vert,1,&v,NULL); glShaderSource(shader_frag,1,&f,NULL); printGLError("shader B:"); glCompileShader(shader_vert); shader_printCompileLog(shader_vert); glCompileShader(shader_frag); shader_printCompileLog(shader_frag); printGLError("shader C:"); shader_program = glCreateProgram(); glAttachShader(shader_program,shader_vert); glAttachShader(shader_program,shader_frag); printGLError("shader D:"); glLinkProgram(shader_program); printGLError("shader E:"); shader_proj = glGetUniformLocation(shader_program, "proj"); printGLError("shader F1:"); shader_mod = glGetUniformLocation(shader_program, "mod"); printGLError("shader F2:"); shader_vindex = glGetAttribLocation(shader_program, "Vertex"); shader_cindex = glGetAttribLocation(shader_program, "Color"); printGLError("shader G:"); // shader_uniform_m4x4f(&unis[0],shader_proj,p); //shader_uniform_m4x4f(&unis[1],shader_mod,mv); s->uniforms = (Uniform*)malloc(2*sizeof(Uniform)); if (s->uniforms == NULL) printf("ERROR\n"); s->num_uniforms = 2; shader_uniform_m4x4f(&s->uniforms[0],shader_proj,p); shader_uniform_m4x4f(&s->uniforms[1],shader_mod,mv); s->shader = shader_program; s->attributes[VERTEX_INDEX].vattrib = shader_vindex; s->attributes[VERTEX_INDEX].active = true; s->attributes[COLOR_INDEX].vattrib = shader_cindex; s->attributes[COLOR_INDEX].active = true; return s; }
int main() { int width = 640; int height = 480; if(glfwInit() == GL_FALSE) { std::cerr << "failed to init GLFW" << std::endl; return 1; } // select opengl version 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; }
// 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; }
bool LightPassHandles::installShaders(const std::string &vShaderName, const std::string &fShaderName) { GLint rc; // Create shader handles GLuint VS = glCreateShader(GL_VERTEX_SHADER); GLuint FS = glCreateShader(GL_FRAGMENT_SHADER); // Read shader sources const char *vshader = GLSL::textFileRead(vShaderName.c_str()); const char *fshader = GLSL::textFileRead(fShaderName.c_str()); glShaderSource(VS, 1, &vshader, NULL); glShaderSource(FS, 1, &fshader, NULL); // Compile vertex shader glCompileShader(VS); GLSL::printError(); glGetShaderiv(VS, GL_COMPILE_STATUS, &rc); GLSL::printShaderInfoLog(VS); if(!rc) { printf("Error compiling vertex shader %s\n", vShaderName.c_str()); return false; } // Compile fragment shader glCompileShader(FS); GLSL::printError(); glGetShaderiv(FS, GL_COMPILE_STATUS, &rc); GLSL::printShaderInfoLog(FS); if(!rc) { printf("Error compiling fragment shader %s\n", fShaderName.c_str()); return false; } // Create the program and link this->prog = glCreateProgram(); assert(this->prog > 0); glAttachShader(this->prog, VS); glAttachShader(this->prog, FS); glLinkProgram(this->prog); GLSL::printError(); glGetProgramiv(this->prog, GL_LINK_STATUS, &rc); GLSL::printProgramInfoLog(this->prog); if(!rc) { printf("Error linking shaders %s and %s\n", vShaderName.c_str(), fShaderName.c_str()); return false; } aPosition = GLSL::getAttribLocation(this->prog, "aPosition"); uScreenSize = GLSL::getUniformLocation(this->prog, "uScreenSize"); uNormMap = GLSL::getUniformLocation(this->prog, "uNormMap"); uPosMap = GLSL::getUniformLocation(this->prog, "uPosMap"); uColMap = GLSL::getUniformLocation(this->prog, "uColMap"); uDepthMap = GLSL::getUniformLocation(this->prog, "uDepthMap"); uLightCol = GLSL::getUniformLocation(this->prog, "uLightCol"); uLightAtten = GLSL::getUniformLocation(this->prog, "uLightAtten"); uLightDirection = GLSL::getUniformLocation(this->prog, "uLightDirection"); uLightAngleCos = GLSL::getUniformLocation(this->prog, "uLightAngleCos"); uDetectionLevel = GLSL::getUniformLocation(this->prog, "uDetectionLevel"); uAmbient = GLSL::getUniformLocation(this->prog, "uAmbient"); uNumLights = GLSL::getUniformLocation(this->prog, "uNumLights"); pt1 = GLSL::getUniformLocation(this->prog, "pt1"); pt2 = GLSL::getUniformLocation(this->prog, "pt2"); pt3 = GLSL::getUniformLocation(this->prog, "pt3"); detecDir = GLSL::getUniformLocation(this->prog, "detecDir"); uDepthMVP = GLSL::getUniformLocation(this->prog, "uDepthMVP"); // stuff to init quad buffers (i didn't know where to put this) /*glGenVertexArrays(1, &quad_VertexArrayID); assert(quad_VertexArrayID > 0); glBindVertexArray(quad_VertexArrayID);*/ glGenBuffers(1, &quad_vertexbuffer); assert(quad_vertexbuffer > 0); glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data) * sizeof(GLfloat), &g_quad_vertex_buffer_data[0], GL_STATIC_DRAW); return true; }
static void init_shaders(CUBE_STATE_T *state) { static const GLfloat vertex_data[] = { -1.0,-1.0,1.0, 1.0,-1.0,1.0, 1.0,1.0,1.0, -1.0,1.0,1.0, }; const GLchar *vshader_source = "attribute vec4 vertex;" "varying vec2 tcoord;" "void main(void) {" " vec4 pos = vertex;" " gl_Position = pos;" " tcoord = vertex.xy*0.5+0.5;" "}"; #if 0 //Mandelbrot const GLchar *mandelbrot_fshader_source = "uniform vec4 color;" "uniform vec2 scale;" "uniform vec2 centre;" "varying vec2 tcoord;" "void main(void) {" " float intensity;" " vec4 color2;" " float cr=(gl_FragCoord.x-centre.x)*scale.x;" " float ci=(gl_FragCoord.y-centre.y)*scale.y;" " float ar=cr;" " float ai=ci;" " float tr,ti;" " float col=0.0;" " float p=0.0;" " int i=0;" " for(int i2=1;i2<16;i2++)" " {" " tr=ar*ar-ai*ai+cr;" " ti=2.0*ar*ai+ci;" " p=tr*tr+ti*ti;" " ar=tr;" " ai=ti;" " if (p>16.0)" " {" " i=i2;" " break;" " }" " }" " color2 = vec4(float(i)*0.0625,0,0,1);" " gl_FragColor = color2;" "}"; // Julia const GLchar *julia_fshader_source = "uniform vec4 color;" "uniform vec2 scale;" "uniform vec2 centre;" "uniform vec2 offset;" "varying vec2 tcoord;" "uniform sampler2D tex;" "void main(void) {" " float intensity;" " vec4 color2;" " float ar=(gl_FragCoord.x-centre.x)*scale.x;" " float ai=(gl_FragCoord.y-centre.y)*scale.y;" " float cr=(offset.x-centre.x)*scale.x;" " float ci=(offset.y-centre.y)*scale.y;" " float tr,ti;" " float col=0.0;" " float p=0.0;" " int i=0;" " vec2 t2;" " t2.x=tcoord.x+(offset.x-centre.x)*(0.5/centre.y);" " t2.y=tcoord.y+(offset.y-centre.y)*(0.5/centre.x);" " for(int i2=1;i2<16;i2++)" " {" " tr=ar*ar-ai*ai+cr;" " ti=2.0*ar*ai+ci;" " p=tr*tr+ti*ti;" " ar=tr;" " ai=ti;" " if (p>16.0)" " {" " i=i2;" " break;" " }" " }" " color2 = vec4(0,float(i)*0.0625,0,1);" " color2 = color2+texture2D(tex,t2);" " gl_FragColor = color2;" "}"; state->vshader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(state->vshader, 1, &vshader_source, 0); glCompileShader(state->vshader); check(); if (state->verbose) showlog(state->vshader); state->fshader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(state->fshader, 1, &julia_fshader_source, 0); glCompileShader(state->fshader); check(); if (state->verbose) showlog(state->fshader); state->mshader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(state->mshader, 1, &mandelbrot_fshader_source, 0); glCompileShader(state->mshader); check(); if (state->verbose) showlog(state->mshader); // julia state->program = glCreateProgram(); glAttachShader(state->program, state->vshader); glAttachShader(state->program, state->fshader); glLinkProgram(state->program); check(); if (state->verbose) showprogramlog(state->program); state->attr_vertex = glGetAttribLocation(state->program, "vertex"); state->unif_color = glGetUniformLocation(state->program, "color"); state->unif_scale = glGetUniformLocation(state->program, "scale"); state->unif_offset = glGetUniformLocation(state->program, "offset"); state->unif_tex = glGetUniformLocation(state->program, "tex"); state->unif_centre = glGetUniformLocation(state->program, "centre"); // mandelbrot state->program2 = glCreateProgram(); glAttachShader(state->program2, state->vshader); glAttachShader(state->program2, state->mshader); glLinkProgram(state->program2); check(); if (state->verbose) showprogramlog(state->program2); state->attr_vertex2 = glGetAttribLocation(state->program2, "vertex"); state->unif_scale2 = glGetUniformLocation(state->program2, "scale"); state->unif_offset2 = glGetUniformLocation(state->program2, "offset"); state->unif_centre2 = glGetUniformLocation(state->program2, "centre"); check(); #endif glClearColor ( 0.0, 1.0, 1.0, 1.0 ); glGenBuffers(1, &state->buf); check(); // Prepare a texture image glGenTextures(1, &state->tex); check(); glBindTexture(GL_TEXTURE_2D,state->tex); check(); // glActiveTexture(0) glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,state->screen_width,state->screen_height,0,GL_RGB,GL_UNSIGNED_SHORT_5_6_5,0); check(); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); check(); // Prepare a framebuffer for rendering glGenFramebuffers(1,&state->tex_fb); check(); glBindFramebuffer(GL_FRAMEBUFFER,state->tex_fb); check(); glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D,state->tex,0); check(); glBindFramebuffer(GL_FRAMEBUFFER,0); check(); // Prepare viewport glViewport ( 0, 0, state->screen_width, state->screen_height ); check(); // Upload vertex data to a buffer glBindBuffer(GL_ARRAY_BUFFER, state->buf); glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW); glVertexAttribPointer(state->attr_vertex, 3, GL_FLOAT, 0, 12, 0); glEnableVertexAttribArray(state->attr_vertex); check(); }
GLuint DepalShaderCache::GetDepalettizeShader(GEBufferFormat pixelFormat) { u32 id = GenerateShaderID(pixelFormat); auto shader = cache_.find(id); if (shader != cache_.end()) { return shader->second->program; } char *buffer = new char[2048]; if (useGL3_) { GenerateDepalShader300(buffer, pixelFormat); } else { GenerateDepalShader100(buffer, pixelFormat); } GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER); const char *buf = buffer; glShaderSource(fragShader, 1, &buf, 0); glCompileShader(fragShader); CheckShaderCompileSuccess(fragShader, buffer); GLuint program = glCreateProgram(); glAttachShader(program, vertexShader_); glAttachShader(program, fragShader); glBindAttribLocation(program, 0, "a_position"); glBindAttribLocation(program, 1, "a_texcoord0"); if (useGL3_) { // This call is not really necessary, I think. #ifndef MOBILE_DEVICE glBindFragDataLocation(program, 0, "fragColor0"); #endif } glLinkProgram(program); glUseProgram(program); GLint u_tex = glGetUniformLocation(program, "tex"); GLint u_pal = glGetUniformLocation(program, "pal"); glUniform1i(u_tex, 0); glUniform1i(u_pal, 1); GLint linkStatus = GL_FALSE; glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); if (linkStatus != GL_TRUE) { GLint bufLength = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength); if (bufLength) { char* errorbuf = new char[bufLength]; glGetProgramInfoLog(program, bufLength, NULL, errorbuf); #ifdef SHADERLOG OutputDebugStringUTF8(buffer); OutputDebugStringUTF8(errorbuf); #endif ERROR_LOG(G3D, "Could not link program:\n %s \n\n %s", errorbuf, buf); delete[] errorbuf; // we're dead! } delete[] buffer; return 0; } DepalShader *depal = new DepalShader(); depal->program = program; depal->fragShader = fragShader; cache_[id] = depal; delete[] buffer; return depal->program; }
int main () { GLFWwindow* window = NULL; const GLubyte* renderer; const GLubyte* version; GLuint vao; GLuint vbo; /* geometry to use. these are 3 xyz points (9 floats total) to make a triangle */ GLfloat points[] = { 0.0f, 0.5f, 0.0f, 0.5f, -0.5f, 0.0f, -0.5f, -0.5f, 0.0f }; /* these are the strings of code for the shaders the vertex shader positions each vertex point */ const char* vertex_shader = "#version 400\n" "in vec3 vp;" "void main () {" " gl_Position = vec4 (vp, 1.0);" "}"; /* the fragment shader colours each fragment (pixel-sized area of the triangle) */ const char* fragment_shader = "#version 400\n" "out vec4 frag_colour;" "void main () {" " frag_colour = vec4 (0.5, 0.0, 0.5, 1.0);" "}"; /* GL shader objects for vertex and fragment shader [components] */ GLuint vs, fs; /* GL shader programme object [combined, to link] */ GLuint shader_programme; /* start GL context and O/S window using the GLFW helper library */ if (!glfwInit ()) { fprintf (stderr, "ERROR: could not start GLFW3\n"); return 1; } /* change to 3.2 if on Apple OS X */ glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 0); glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); window = glfwCreateWindow ( 640, 480, "Hello Triangle", NULL, NULL ); if (!window) { fprintf (stderr, "ERROR: could not open window with GLFW3\n"); glfwTerminate(); return 1; } glfwMakeContextCurrent (window); /* start GLEW extension handler */ glewExperimental = GL_TRUE; glewInit (); /* get version info */ renderer = glGetString (GL_RENDERER); /* get renderer string */ version = glGetString (GL_VERSION); /* version as a string */ printf ("Renderer: %s\n", renderer); printf ("OpenGL version supported %s\n", version); /* tell GL to only draw onto a pixel if the shape is closer to the viewer */ glEnable (GL_DEPTH_TEST); /* enable depth-testing */ glDepthFunc (GL_LESS);/*depth-testing interprets a smaller value as "closer"*/ /* a vertex buffer object (VBO) is created here. this stores an array of data on the graphics adapter's memory. in our case - the vertex points */ glGenBuffers (1, &vbo); glBindBuffer (GL_ARRAY_BUFFER, vbo); glBufferData (GL_ARRAY_BUFFER, 9 * sizeof (GLfloat), points, GL_STATIC_DRAW); /* the vertex array object (VAO) is a little descriptor that defines which data from vertex buffer objects should be used as input variables to vertex shaders. in our case - use our only VBO, and say 'every three floats is a variable' */ glGenVertexArrays (1, &vao); glBindVertexArray (vao); glEnableVertexAttribArray (0); glBindBuffer (GL_ARRAY_BUFFER, vbo); glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL); /* here we copy the shader strings into GL shaders, and compile them. we then create an executable shader 'program' and attach both of the compiled shaders. we link this, which matches the outputs of the vertex shader to the inputs of the fragment shader, etc. and it is then ready to use */ vs = glCreateShader (GL_VERTEX_SHADER); glShaderSource (vs, 1, &vertex_shader, NULL); glCompileShader (vs); fs = glCreateShader (GL_FRAGMENT_SHADER); glShaderSource (fs, 1, &fragment_shader, NULL); glCompileShader (fs); shader_programme = glCreateProgram (); glAttachShader (shader_programme, fs); glAttachShader (shader_programme, vs); glLinkProgram (shader_programme); /* this loop clears the drawing surface, then draws the geometry described by the VAO onto the drawing surface. we 'poll events' to see if the window was closed, etc. finally, we 'swap the buffers' which displays our drawing surface onto the view area. we use a double-buffering system which means that we have a 'currently displayed' surface, and 'currently being drawn' surface. hence the 'swap' idea. in a single-buffering system we would see stuff being drawn one-after-the-other */ while (!glfwWindowShouldClose (window)) { /* wipe the drawing surface clear */ glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glUseProgram (shader_programme); glBindVertexArray (vao); /* draw points 0-3 from the currently bound VAO with current in-use shader*/ glDrawArrays (GL_TRIANGLES, 0, 3); /* update other events like input handling */ glfwPollEvents (); /* put the stuff we've been drawing onto the display */ glfwSwapBuffers (window); } /* close GL context and any other GLFW resources */ glfwTerminate(); return 0; }
void piglit_init(int argc, char **argv) { enum piglit_result result = PIGLIT_PASS; GLuint data_bo = 0; GLfloat *data_buf; GLint ok = 1; GLint prog = 0; GLuint shader; const float one = 1.0f; piglit_require_extension("GL_ARB_compute_shader"); piglit_require_extension("GL_INTEL_blackhole_render"); data_buf = calloc(SIZE_X, sizeof(*data_buf)); glGenBuffers(1, &data_bo); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, data_bo); glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(float) * SIZE_X, data_buf, GL_STATIC_DRAW); free(data_buf); shader = glCreateShader(GL_COMPUTE_SHADER); glShaderSource(shader, 1, (const GLchar **) &compute_shader, NULL); glCompileShader(shader); glGetShaderiv(shader, GL_COMPILE_STATUS, &ok); assert(ok); prog = glCreateProgram(); glAttachShader(prog, shader); glLinkProgram(prog); glGetProgramiv(prog, GL_LINK_STATUS, &ok); assert(ok); glUseProgram(prog); assert(!glIsEnabled(GL_BLACKHOLE_RENDER_INTEL)); glMemoryBarrier(GL_ALL_BARRIER_BITS); glUniform1f(glGetUniformLocation(prog, "value"), 1.0f); glDispatchCompute(SIZE_X, 1, 1); glMemoryBarrier(GL_ALL_BARRIER_BITS); if (!piglit_probe_buffer(data_bo, GL_SHADER_STORAGE_BUFFER, "output_values", SIZE_X, 1, &one)) result = PIGLIT_FAIL; glEnable(GL_BLACKHOLE_RENDER_INTEL); assert(glIsEnabled(GL_BLACKHOLE_RENDER_INTEL)); glMemoryBarrier(GL_ALL_BARRIER_BITS); glUniform1f(glGetUniformLocation(prog, "value"), 2.0f); glDispatchCompute(SIZE_X, 1, 1); glMemoryBarrier(GL_ALL_BARRIER_BITS); if (!piglit_probe_buffer(data_bo, GL_SHADER_STORAGE_BUFFER, "output_values", SIZE_X, 1, &one)) result = PIGLIT_FAIL; piglit_report_result(result); }
// Constructor generates the shader on the fly Shader::Shader(const GLchar* vertexPath, const GLchar* fragmentPath) { // 1. Retrieve the vertex/fragment source code from filePath std::string vertexCode; std::string fragmentCode; std::ifstream vShaderFile; std::ifstream fShaderFile; // ensures ifstream objects can throw exceptions: vShaderFile.exceptions (std::ifstream::badbit); fShaderFile.exceptions (std::ifstream::badbit); try { // Open files vShaderFile.open(vertexPath); fShaderFile.open(fragmentPath); std::stringstream vShaderStream, fShaderStream; // Read file's buffer contents into streams vShaderStream << vShaderFile.rdbuf(); fShaderStream << fShaderFile.rdbuf(); // close file handlers vShaderFile.close(); fShaderFile.close(); // Convert stream into string vertexCode = vShaderStream.str(); fragmentCode = fShaderStream.str(); } catch (std::ifstream::failure e) { std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl; } const GLchar* vShaderCode = vertexCode.c_str(); const GLchar * fShaderCode = fragmentCode.c_str(); // 2. Compile shaders GLuint vertex, fragment; GLint success; GLchar infoLog[512]; // Vertex Shader vertex = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertex, 1, &vShaderCode, NULL); glCompileShader(vertex); // Print compile errors if any glGetShaderiv(vertex, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(vertex, 512, NULL, infoLog); std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl; } // Fragment Shader fragment = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragment, 1, &fShaderCode, NULL); glCompileShader(fragment); // Print compile errors if any glGetShaderiv(fragment, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(fragment, 512, NULL, infoLog); std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl; } // Shader Program this->Program = glCreateProgram(); glAttachShader(this->Program, vertex); glAttachShader(this->Program, fragment); glLinkProgram(this->Program); // Print linking errors if any glGetProgramiv(this->Program, GL_LINK_STATUS, &success); if (!success) { glGetProgramInfoLog(this->Program, 512, NULL, infoLog); std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl; } // Delete the shaders as they're linked into our program now and no longer necessery glDeleteShader(vertex); glDeleteShader(fragment); }
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., -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! std::string vs_string = shaderLoader("../bin/vs.txt"); std::string fs_string = shaderLoader("../bin/fs.txt"); const char* vs = vs_string.c_str(); const char* fs = fs_string.c_str(); //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; }
void shader_object::setShader(const char *vs, const char *fs, const char *gs, GLuint itype, GLuint otype, GLint osize) { //fprintf(stderr, "**** %s:%s() ****\n", __FILE__, __func__); v = glCreateShader(GL_VERTEX_SHADER); f = glCreateShader(GL_FRAGMENT_SHADER); if(gs) g = glCreateShader(GL_GEOMETRY_SHADER_EXT); glShaderSource(v, 1, &vs, NULL); glShaderSource(f, 1, &fs, NULL); if(g) { glShaderSource(g, 1, &gs, NULL); } //printf("compile vertex shader\n"); glCompileShader(v); GLint params; glGetShaderiv(v, GL_COMPILE_STATUS, ¶ms); if(params == GL_FALSE) { fprintf(stderr, "compile vertex shader error:\n"); printShaderInfoLog(v); exit(10); } //printf("compile fragment shader\n"); glCompileShader(f); glGetShaderiv(f, GL_COMPILE_STATUS, ¶ms); if(params == GL_FALSE) { fprintf(stderr, "compile fragment shader error:\n"); printShaderInfoLog(f); exit(10); } if(g) { //printf("compile geometry shader\n"); glCompileShader(g); glGetShaderiv(g, GL_COMPILE_STATUS, ¶ms); if(params == GL_FALSE) { fprintf(stderr, "compile geometry shader error:\n"); printShaderInfoLog(g); exit(10); } } //printf("create program\n"); p = glCreateProgram(); //printf("attach shaders to program\n"); glAttachShader(p, v); glAttachShader(p, f); if(g) { glAttachShader(p, g); setup_geometry_shader(itype, otype, osize); } //printf("link program\n"); glLinkProgram(p); glGetProgramiv(p, GL_LINK_STATUS, ¶ms); if(params == GL_FALSE) { fprintf(stderr, "link program error:\n"); printProgramInfoLog(p); exit(10); } if( printOpenGLError() ) exit(1); //glUseProgram(p); }
Shader::Shader(const GLchar *vsPath, const GLchar *fsPath) { // Read shaders from files std::ifstream vsStream(vsPath); std::stringstream vsBuffer; vsBuffer << vsStream.rdbuf(); std::string vsStr = vsBuffer.str(); const char* vertexShaderSource = vsStr.c_str(); std::ifstream fgStream(fsPath); std::stringstream fgBuffer; fgBuffer << fgStream.rdbuf(); std::string fgStr = fgBuffer.str(); const char* fragmentShaderSource = fgStr.c_str(); // Create a vertex shader and compile it GLuint vertexShader; vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glCompileShader(vertexShader); // Check if the vertex shader is compiled correctly GLint success; GLchar infoLog[512]; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success); if (success == false) { glGetShaderInfoLog(vertexShader, 512, NULL, infoLog); std::cout << "ERROR::SHADER::VERTEX:COMPILATION_FAILED\n" << infoLog << std::endl; } // Create a fragment shader and compile it GLuint fragmentShader; fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); glCompileShader(fragmentShader); // Check if the fragment shader is compiled correctly glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success); if (success == false) { glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog); std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl; } // Link two shaders with the shader program. this->program = glCreateProgram(); glAttachShader(this->program, vertexShader); glAttachShader(this->program, fragmentShader); glLinkProgram(this->program); // check if the linking is successful. glGetShaderiv(this->program, GL_LINK_STATUS, &success); if (success == false) { glGetShaderInfoLog(this->program, 512, NULL, infoLog); std::cout << "ERROR::SHADER::PROGRAM_LINKING_FAILED\n" << infoLog << std::endl; } // After linking, we don't need shader objects anymore glDeleteShader(vertexShader); glDeleteShader(fragmentShader); }
static VdpStatus compile_shaders(VdpDeviceData *deviceData) { VdpStatus retval = VDP_STATUS_ERROR; for (int k = 0; k < SHADER_COUNT; k ++) { struct shader_s *s = &glsl_shaders[k]; GLint errmsg_len; GLuint f_shader, program; int ok; f_shader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(f_shader, 1, &s->body, &s->len); glCompileShader(f_shader); glGetShaderiv(f_shader, GL_COMPILE_STATUS, &ok); if (!ok) { glGetShaderiv(f_shader, GL_INFO_LOG_LENGTH, &errmsg_len); char *errmsg = malloc(errmsg_len); glGetShaderInfoLog(f_shader, errmsg_len, NULL, errmsg); traceError("error (%s): compilation of shader #%d failed with '%s'\n", __func__, k, errmsg); free(errmsg); glDeleteShader(f_shader); goto err; } program = glCreateProgram(); glAttachShader(program, f_shader); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &ok); if (!ok) { glGetProgramiv(program, GL_INFO_LOG_LENGTH, &errmsg_len); char *errmsg = malloc(errmsg_len); glGetProgramInfoLog(program, errmsg_len, NULL, errmsg); traceError("error (%s): linking of shader #%d failed with '%s'\n", __func__, k, errmsg); free(errmsg); glDeleteProgram(program); glDeleteShader(f_shader); goto err; } deviceData->shaders[k].f_shader = f_shader; deviceData->shaders[k].program = program; switch (k) { case glsl_YV12_RGBA: case glsl_NV12_RGBA: deviceData->shaders[k].uniform.tex_0 = glGetUniformLocation(program, "tex[0]"); deviceData->shaders[k].uniform.tex_1 = glGetUniformLocation(program, "tex[1]"); break; case glsl_red_to_alpha_swizzle: deviceData->shaders[k].uniform.tex_0 = glGetUniformLocation(program, "tex_0"); break; } } retval = VDP_STATUS_OK; err: return retval; }
GLUSboolean GLUSAPIENTRY glusCreateProgramFromSource(GLUSshaderprogram* shaderProgram, const GLUSchar** vertexSource, const GLUSchar** controlSource, const GLUSchar** evaluationSource, const GLUSchar** geometrySource, const GLUSchar** fragmentSource) { GLUSint compiled; GLUSint logLength, charsWritten; char* log; if (!shaderProgram || !vertexSource || !fragmentSource) { return GLUS_FALSE; } shaderProgram->program = 0; shaderProgram->compute = 0; shaderProgram->vertex = 0; shaderProgram->control = 0; shaderProgram->evaluation = 0; shaderProgram->geometry = 0; shaderProgram->fragment = 0; shaderProgram->vertex = glCreateShader(GLUS_VERTEX_SHADER); glShaderSource(shaderProgram->vertex, 1, (const char**) vertexSource, 0); glCompileShader(shaderProgram->vertex); glGetShaderiv(shaderProgram->vertex, GL_COMPILE_STATUS, &compiled); if (!compiled) { glGetShaderiv(shaderProgram->vertex, GL_INFO_LOG_LENGTH, &logLength); log = (char*) malloc((size_t)logLength); if (!log) { return GLUS_FALSE; } glGetShaderInfoLog(shaderProgram->vertex, logLength, &charsWritten, log); glusLogPrint(GLUS_LOG_ERROR, "Vertex shader compile error:"); glusLogPrint(GLUS_LOG_ERROR, "%s", log); free(log); shaderProgram->vertex = 0; return GLUS_FALSE; } if (controlSource) { shaderProgram->control = glCreateShader(GLUS_TESS_CONTROL_SHADER); glShaderSource(shaderProgram->control, 1, (const char**) controlSource, 0); glCompileShader(shaderProgram->control); glGetShaderiv(shaderProgram->control, GL_COMPILE_STATUS, &compiled); if (!compiled) { glGetShaderiv(shaderProgram->control, GL_INFO_LOG_LENGTH, &logLength); log = (char*) malloc((size_t)logLength); if (!log) { glusDestroyProgram(shaderProgram); return GLUS_FALSE; } glGetShaderInfoLog(shaderProgram->control, logLength, &charsWritten, log); glusLogPrint(GLUS_LOG_ERROR, "Control shader compile error:"); glusLogPrint(GLUS_LOG_ERROR, "%s", log); free(log); shaderProgram->control = 0; glusDestroyProgram(shaderProgram); return GLUS_FALSE; } } if (evaluationSource) { shaderProgram->evaluation = glCreateShader(GLUS_TESS_EVALUATION_SHADER); glShaderSource(shaderProgram->evaluation, 1, (const char**) evaluationSource, 0); glCompileShader(shaderProgram->evaluation); glGetShaderiv(shaderProgram->evaluation, GL_COMPILE_STATUS, &compiled); if (!compiled) { glGetShaderiv(shaderProgram->evaluation, GL_INFO_LOG_LENGTH, &logLength); log = (char*) malloc((size_t)logLength); if (!log) { glusDestroyProgram(shaderProgram); return GLUS_FALSE; } glGetShaderInfoLog(shaderProgram->evaluation, logLength, &charsWritten, log); glusLogPrint(GLUS_LOG_ERROR, "Evaluation shader compile error:"); glusLogPrint(GLUS_LOG_ERROR, "%s", log); free(log); shaderProgram->evaluation = 0; glusDestroyProgram(shaderProgram); return GLUS_FALSE; } } if (geometrySource) { shaderProgram->geometry = glCreateShader(GLUS_GEOMETRY_SHADER); glShaderSource(shaderProgram->geometry, 1, (const char**) geometrySource, 0); glCompileShader(shaderProgram->geometry); glGetShaderiv(shaderProgram->geometry, GL_COMPILE_STATUS, &compiled); if (!compiled) { glGetShaderiv(shaderProgram->geometry, GL_INFO_LOG_LENGTH, &logLength); log = (char*) malloc((size_t)logLength); if (!log) { glusDestroyProgram(shaderProgram); return GLUS_FALSE; } glGetShaderInfoLog(shaderProgram->geometry, logLength, &charsWritten, log); glusLogPrint(GLUS_LOG_ERROR, "Geometry shader compile error:"); glusLogPrint(GLUS_LOG_ERROR, "%s", log); free(log); shaderProgram->geometry = 0; glusDestroyProgram(shaderProgram); return GLUS_FALSE; } } shaderProgram->fragment = glCreateShader(GLUS_FRAGMENT_SHADER); glShaderSource(shaderProgram->fragment, 1, (const char**) fragmentSource, 0); glCompileShader(shaderProgram->fragment); glGetShaderiv(shaderProgram->fragment, GL_COMPILE_STATUS, &compiled); if (!compiled) { glGetShaderiv(shaderProgram->fragment, GL_INFO_LOG_LENGTH, &logLength); log = (char*) malloc((size_t)logLength); if (!log) { glusDestroyProgram(shaderProgram); return GLUS_FALSE; } glGetShaderInfoLog(shaderProgram->fragment, logLength, &charsWritten, log); glusLogPrint(GLUS_LOG_ERROR, "Fragment shader compile error:"); glusLogPrint(GLUS_LOG_ERROR, "%s", log); free(log); shaderProgram->fragment = 0; glusDestroyProgram(shaderProgram); return GLUS_FALSE; } shaderProgram->program = glCreateProgram(); glAttachShader(shaderProgram->program, shaderProgram->vertex); if (shaderProgram->control) { glAttachShader(shaderProgram->program, shaderProgram->control); } if (shaderProgram->evaluation) { glAttachShader(shaderProgram->program, shaderProgram->evaluation); } if (shaderProgram->geometry) { glAttachShader(shaderProgram->program, shaderProgram->geometry); } glAttachShader(shaderProgram->program, shaderProgram->fragment); return GLUS_TRUE; }
bool Imgui::init(Engine *en) { #ifdef AGE_ENABLE_IMGUI GetMainThread()->registerCallback<ImGuiKeyEvent>([this](ImGuiKeyEvent &msg) { ImGuiIO& io = ImGui::GetIO(); io.KeysDown[int(msg.key)] = msg.down; if (msg.key == AgeKeys::AGE_LCTRL || msg.key == AgeKeys::AGE_RCTRL) io.KeyCtrl = msg.down; else if (msg.key == AgeKeys::AGE_LSHIFT || msg.key == AgeKeys::AGE_RSHIFT) io.KeyShift = msg.down; else if (msg.down) { char character = keyToAscii.find(msg.key)->second; if (character != UNDEFINED_CHARACTER) io.AddInputCharacter(character); } }); GetMainThread()->registerCallback<ImGuiEndOfFrame>([this](ImGuiEndOfFrame &msg) { SCOPE_profile_cpu_i("ImGui", "Render"); ImGui::Render(); }); GetMainThread()->registerCallback<ImGuiMouseStateEvent>([this](ImGuiMouseStateEvent &msg) { _lastMouseState = msg; }); _engine = en; //HARDCODED WINDOW TO FIX //auto window = di->getInstance<AGE::Threads::Render>()->getCommandQueue()->safePriorityFutureEmplace<RendCtxCommand::GetScreenSize, glm::uvec2>().get(); ImGuiIO& io = ImGui::GetIO(); //HARDCODED WINDOW TO FIX auto screenSize = en->getInstance<IRenderContext>()->getScreenSize(); io.DisplaySize = ImVec2((float)screenSize.x, (float)screenSize.y); // Display size, in pixels. For clamping windows positions. io.DeltaTime = 1.0f / 60.0f; // Time elapsed since last frame, in seconds (in this sample app we'll override this every frame because our timestep is variable) io.KeyMap[ImGuiKey_Tab] = int(AgeKeys::AGE_TAB); // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array. io.KeyMap[ImGuiKey_LeftArrow] = int(AgeKeys::AGE_LEFT); io.KeyMap[ImGuiKey_RightArrow] = int(AgeKeys::AGE_RIGHT); io.KeyMap[ImGuiKey_UpArrow] = int(AgeKeys::AGE_UP); io.KeyMap[ImGuiKey_DownArrow] = int(AgeKeys::AGE_DOWN); io.KeyMap[ImGuiKey_Home] = int(AgeKeys::AGE_HOME); io.KeyMap[ImGuiKey_End] = int(AgeKeys::AGE_END); io.KeyMap[ImGuiKey_Delete] = int(AgeKeys::AGE_DELETE); io.KeyMap[ImGuiKey_Backspace] = int(AgeKeys::AGE_BACKSPACE); io.KeyMap[ImGuiKey_Enter] = int(AgeKeys::AGE_RETURN); io.KeyMap[ImGuiKey_Escape] = int(AgeKeys::AGE_ESCAPE); io.KeyMap[ImGuiKey_A] = int(AgeKeys::AGE_a); io.KeyMap[ImGuiKey_C] = int(AgeKeys::AGE_c); io.KeyMap[ImGuiKey_V] = int(AgeKeys::AGE_v); io.KeyMap[ImGuiKey_X] = int(AgeKeys::AGE_x); io.KeyMap[ImGuiKey_Y] = int(AgeKeys::AGE_y); io.KeyMap[ImGuiKey_Z] = int(AgeKeys::AGE_z); io.RenderDrawListsFn = renderDrawLists; //io.SetClipboardTextFn = ImImpl_SetClipboardTextFn; //io.GetClipboardTextFn = ImImpl_GetClipboardTextFn; const GLchar *vertex_shader = "#version 330\n" "uniform mat4 ProjMtx;\n" "in vec2 Position;\n" "in vec2 UV;\n" "in vec4 Color;\n" "out vec2 Frag_UV;\n" "out vec4 Frag_Color;\n" "void main()\n" "{\n" " Frag_UV = UV;\n" " Frag_Color = Color;\n" " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n" "}\n"; const GLchar* fragment_shader = "#version 330\n" "uniform sampler2D Texture;\n" "in vec2 Frag_UV;\n" "in vec4 Frag_Color;\n" "out vec4 Out_Color;\n" "void main()\n" "{\n" " Out_Color = Frag_Color * texture( Texture, Frag_UV.st);\n" "}\n"; shader_handle = glCreateProgram(); vert_handle = glCreateShader(GL_VERTEX_SHADER); frag_handle = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(vert_handle, 1, &vertex_shader, 0); glShaderSource(frag_handle, 1, &fragment_shader, 0); glCompileShader(vert_handle); glCompileShader(frag_handle); glAttachShader(shader_handle, vert_handle); glAttachShader(shader_handle, frag_handle); glLinkProgram(shader_handle); texture_location = glGetUniformLocation(shader_handle, "Texture"); ortho_location = glGetUniformLocation(shader_handle, "ProjMtx"); position_location = glGetAttribLocation(shader_handle, "Position"); uv_location = glGetAttribLocation(shader_handle, "UV"); colour_location = glGetAttribLocation(shader_handle, "Color"); glGenBuffers(1, &vbo_handle); glBindBuffer(GL_ARRAY_BUFFER, vbo_handle); glBufferData(GL_ARRAY_BUFFER, vbo_max_size, NULL, GL_DYNAMIC_DRAW); glGenVertexArrays(1, &vao_handle); glBindVertexArray(vao_handle); glBindBuffer(GL_ARRAY_BUFFER, vbo_handle); glEnableVertexAttribArray(position_location); glEnableVertexAttribArray(uv_location); glEnableVertexAttribArray(colour_location); glVertexAttribPointer(position_location, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, pos)); glVertexAttribPointer(uv_location, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, uv)); glVertexAttribPointer(colour_location, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, col)); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); // Load font texture glGenTextures(1, &fontTex); glBindTexture(GL_TEXTURE_2D, fontTex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); unsigned char* pixels; int width, height; io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height); io.Fonts->TexID = &fontTex; glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels); // Cleanup (don't clear the input data if you want to append new fonts later) io.Fonts->ClearInputData(); io.Fonts->ClearTexData(); #else UNUSED(en); #endif //AGE_ENABLE_IMGUI return true; }
int main(int argc, char *argv[]) { EGLDisplay display; EGLint egl_major, egl_minor; EGLConfig config; EGLint num_config; EGLContext context; EGLSurface surface; GLuint vertex_shader; GLuint fragment_shader; GLuint program; GLint ret; GLint width, height; #ifdef HOOK the_hook("/mnt/sdcard/egl2.fdr"); #endif const char *vertex_shader_source = "uniform mat4 modelviewMatrix;\n" "uniform mat4 modelviewprojectionMatrix;\n" "uniform mat3 normalMatrix;\n" "\n" "attribute vec4 in_position; \n" "attribute vec3 in_normal; \n" "attribute vec2 in_texcoord; \n" "\n" "vec4 lightSource = vec4(2.0, 2.0, 20.0, 0.0);\n" " \n" "varying vec4 vColor; \n" "varying vec2 vTexCoord; \n" "uniform sampler2D s_texture; \n" " \n" "void main() \n" "{ \n" " float texvalue = texture2D(s_texture, in_texcoord).x;\n" " gl_Position = modelviewprojectionMatrix * (in_position + vec4(0.2 * texvalue * in_normal, 0));\n" " vec3 vEyeNormal = normalMatrix * in_normal;\n" " vec4 vPosition4 = modelviewMatrix * in_position;\n" " vec3 vPosition3 = vPosition4.xyz / vPosition4.w;\n" " vec3 vLightDir = normalize(lightSource.xyz - vPosition3);\n" " float diff = max(0.0, dot(vEyeNormal, vLightDir));\n" " vColor = vec4(diff, 0.0, 0.0, 1.0);\n" " vTexCoord = in_texcoord;\n" "} \n"; const char *fragment_shader_source = "precision mediump float; \n" " \n" "varying vec4 vColor; \n" "varying vec2 vTexCoord; \n" " \n" "void main() \n" "{ \n" " gl_FragColor = vColor;// * texture2D(s_texture, vTexCoord); \n" "} \n"; display = eglGetDisplay(EGL_DEFAULT_DISPLAY); if (display == EGL_NO_DISPLAY) { printf("Error: No display found!\n"); return -1; } if (!eglInitialize(display, &egl_major, &egl_minor)) { printf("Error: eglInitialise failed!\n"); return -1; } printf("Using display %p with EGL version %d.%d\n", display, egl_major, egl_minor); printf("EGL Version \"%s\"\n", eglQueryString(display, EGL_VERSION)); printf("EGL Vendor \"%s\"\n", eglQueryString(display, EGL_VENDOR)); printf("EGL Extensions \"%s\"\n", eglQueryString(display, EGL_EXTENSIONS)); /* get an appropriate EGL frame buffer configuration */ eglChooseConfig(display, config_attribute_list, &config, 1, &num_config); /* create an EGL rendering context */ context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list); if (context == EGL_NO_CONTEXT) { printf("Error: eglCreateContext failed: %d\n", eglGetError()); return -1; } surface = eglCreatePbufferSurface(display, config, pbuffer_attribute_list); if (surface == EGL_NO_SURFACE) { printf("Error: eglCreatePbufferSurface failed: %d (%s)\n", eglGetError(), eglStrError(eglGetError())); return -1; } if (!eglQuerySurface(display, surface, EGL_WIDTH, &width) || !eglQuerySurface(display, surface, EGL_HEIGHT, &height)) { printf("Error: eglQuerySurface failed: %d (%s)\n", eglGetError(), eglStrError(eglGetError())); return -1; } printf("PBuffer: %dx%d\n", width, height); printf("GL Extensions \"%s\"\n", glGetString(GL_EXTENSIONS)); /* connect the context to the surface */ if (!eglMakeCurrent(display, surface, surface, context)) { printf("Error: eglMakeCurrent() failed: %d (%s)\n", eglGetError(), eglStrError(eglGetError())); return -1; } vertex_shader = glCreateShader(GL_VERTEX_SHADER); if (!vertex_shader) { printf("Error: glCreateShader(GL_VERTEX_SHADER) failed: %d (%s)\n", eglGetError(), eglStrError(eglGetError())); return -1; } glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL); glCompileShader(vertex_shader); glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &ret); if (!ret) { char *log; printf("Error: vertex shader compilation failed!:\n"); glGetShaderiv(vertex_shader, GL_INFO_LOG_LENGTH, &ret); if (ret > 1) { log = malloc(ret); glGetShaderInfoLog(vertex_shader, ret, NULL, log); printf("%s", log); } return -1; } else printf("Vertex shader compilation succeeded!\n"); fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); if (!fragment_shader) { printf("Error: glCreateShader(GL_FRAGMENT_SHADER) failed: %d (%s)\n", eglGetError(), eglStrError(eglGetError())); return -1; } glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL); glCompileShader(fragment_shader); glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &ret); if (!ret) { char *log; printf("Error: fragment shader compilation failed!:\n"); glGetShaderiv(fragment_shader, GL_INFO_LOG_LENGTH, &ret); if (ret > 1) { log = malloc(ret); glGetShaderInfoLog(fragment_shader, ret, NULL, log); printf("%s", log); } return -1; } else printf("Fragment shader compilation succeeded!\n"); program = glCreateProgram(); if (!program) { printf("Error: failed to create program!\n"); return -1; } GLfloat *vVertices; GLfloat *vNormals; GLfloat *vTexCoords; GLushort *vIndices; int numIndices = esGenSphere(40, 1.0f, &vVertices, &vNormals, &vTexCoords, &vIndices, NULL); GLuint texId = createSimpleTexture(); glAttachShader(program, vertex_shader); glAttachShader(program, fragment_shader); glBindAttribLocation(program, 0, "in_position"); glBindAttribLocation(program, 1, "in_normal"); glBindAttribLocation(program, 2, "in_texcoord"); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &ret); if (!ret) { char *log; printf("Error: program linking failed!:\n"); glGetProgramiv(program, GL_INFO_LOG_LENGTH, &ret); if (ret > 1) { log = malloc(ret); glGetProgramInfoLog(program, ret, NULL, log); printf("%s", log); } return -1; } else printf("program linking succeeded!\n"); glUseProgram(program); glViewport(0, 0, width, height); /* clear the color buffer */ glClearColor(0.5, 0.5, 0.5, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, vNormals); glEnableVertexAttribArray(1); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, vTexCoords); glEnableVertexAttribArray(2); ESMatrix modelview; esMatrixLoadIdentity(&modelview); esTranslate(&modelview, 0.0f, 0.0f, -8.0f); esRotate(&modelview, 45.0f, 1.0f, 0.0f, 0.0f); esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f); esRotate(&modelview, 10.0f, 0.0f, 0.0f, 1.0f); GLfloat aspect = (GLfloat)(height) / (GLfloat)(width); ESMatrix projection; esMatrixLoadIdentity(&projection); esFrustum(&projection, -1.8f, +1.8f, -1.8f * aspect, +1.8f * aspect, 6.0f, 10.0f); ESMatrix modelviewprojection; esMatrixLoadIdentity(&modelviewprojection); esMatrixMultiply(&modelviewprojection, &modelview, &projection); float normal[9]; normal[0] = modelview.m[0][0]; normal[1] = modelview.m[0][1]; normal[2] = modelview.m[0][2]; normal[3] = modelview.m[1][0]; normal[4] = modelview.m[1][1]; normal[5] = modelview.m[1][2]; normal[6] = modelview.m[2][0]; normal[7] = modelview.m[2][1]; normal[8] = modelview.m[2][2]; GLint modelviewmatrix_handle = glGetUniformLocation(program, "modelviewMatrix"); GLint modelviewprojectionmatrix_handle = glGetUniformLocation(program, "modelviewprojectionMatrix"); GLint normalmatrix_handle = glGetUniformLocation(program, "normalMatrix"); GLint sampler_handle = glGetUniformLocation(program, "s_texture"); glUniformMatrix4fv(modelviewmatrix_handle, 1, GL_FALSE, &modelview.m[0][0]); glUniformMatrix4fv(modelviewprojectionmatrix_handle, 1, GL_FALSE, &modelviewprojection.m[0][0]); glUniformMatrix3fv(normalmatrix_handle, 1, GL_FALSE, normal); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texId); glUniform1i(sampler_handle, 0); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, vIndices); glFlush(); fflush(stdout); dump_gl_screen("/sdcard/egl2.bmp", width, height); #ifdef HOOK close_hook(); #endif return 0; }
GLuint npProgramLoader::loadProgram(string shader) { GLuint vertShader, fragShader; GLint logLength; program = glCreateProgram(); const GLchar *sourceV; sourceV=npTextFileLoader::loadChar (shader,"vsh"); vertShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertShader, 1, &sourceV, NULL); glCompileShader(vertShader); glGetShaderiv(vertShader, GL_INFO_LOG_LENGTH, &logLength); if (logLength > 1) { GLchar *log = (GLchar *)malloc(logLength); glGetShaderInfoLog(vertShader, logLength, &logLength, log); cout << "VertexShader compile log:"<< log<< "\n"; delete log; } const GLchar *sourceF; sourceF = npTextFileLoader::loadChar (shader,"fsh"); if (!sourceF) { cout << "fragment shader not found"; } fragShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragShader, 1, &sourceF, NULL); glCompileShader(fragShader); glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &logLength); if (logLength > 1) { GLchar *log = (GLchar *)malloc(logLength); glGetShaderInfoLog(fragShader, logLength, &logLength, log); cout << "FragmentShader compile log:"<< log<< "\n"; delete log; } glAttachShader(program, vertShader); glAttachShader(program, fragShader); glDeleteShader(vertShader); glDeleteShader(fragShader); // delete [] sourceF; // delete [] sourceV; return program; }
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); #ifdef __APPLE__ glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); #endif GLFWwindow* window = glfwCreateWindow(800, 600, "EX_GS_HT_2", nullptr, nullptr); if (window == nullptr) { std::cout << "Create window failed" << std::endl; glfwTerminate(); return -1; } glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { std::cout << "GLEW INIT failed" << std::endl; glfwTerminate(); return -1; } int width, height; glfwGetFramebufferSize(window, &width, &height); glViewport(0, 0, width, height); GLint success; GLchar infoLog[512]; GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr); glCompileShader(vertexShader); glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(vertexShader, sizeof(infoLog), nullptr, infoLog); std::cout << "Compile vertex shader failed\n" << infoLog << std::endl; glfwTerminate(); return -1; } GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, &fragmentShaderSource, nullptr); glCompileShader(fragmentShader); glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(fragmentShader, sizeof(infoLog), nullptr, infoLog); std::cout << "Compile fragment shader failed\n" << infoLog << std::endl; glfwTerminate(); return -1; } GLuint shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success); if (!success) { glGetProgramInfoLog(shaderProgram, sizeof(infoLog), nullptr, infoLog); std::cout << "Failed to Link Shaders\n" << infoLog << std::endl; glfwTerminate(); return -1; } glDeleteShader(vertexShader); glDeleteShader(fragmentShader); GLfloat vertices1[] = { 0.0f, -0.5f, 0.0f, -1.0f, -0.5f, 0.0f, -0.5f, 0.5f, 0.0f, }; GLfloat vertices2[] = { 1.0f, -0.5f, 0.0f, 0.0f, -0.5f, 0.0f, 0.5f, 0.5f, 0.0f, }; GLuint VBO[2], VAO[2]; glGenBuffers(2, VBO); glGenVertexArrays(2, VAO); glBindVertexArray(VAO[0]); glBindBuffer(GL_ARRAY_BUFFER, VBO[0]); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices1), vertices1, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0); // size glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); glBindVertexArray(VAO[1]); glBindBuffer(GL_ARRAY_BUFFER, VBO[1]); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices2), vertices2, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0); //size glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); while (!glfwWindowShouldClose(window)) { glfwPollEvents(); glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glUseProgram(shaderProgram); glBindVertexArray(VAO[0]); glDrawArrays(GL_TRIANGLES, 0, 3); glBindVertexArray(0); glBindVertexArray(VAO[1]); glDrawArrays(GL_TRIANGLES, 0, 3); glBindVertexArray(0); glfwSwapBuffers(window); } glDeleteBuffers(sizeof(VBO), VBO); glDeleteVertexArrays(sizeof(VAO), VAO); glfwTerminate(); return -1; }
void setSource(const char* src) { glShaderSource(m_nGLId, 1, &src, 0); }
int Renderer::initShader(std::string vsFileName, std::string fsFileName) { // Les opérations devant être faites pour pouvoir utiliser des shaders OpenGL dans notre application sont les suivantes : // 1 - Vertex shader : // 1.1 - Charger le source depuis le fichier "../shaders/vertexdefault.glsl" en utilisant la fonction loaders::text::loadFile() de lecture d'un fichier texte char* vertexShaderSource = loaders::text::loadFile(vsFileName.c_str()); // 1.2 - Créer un objet OpenGL VERTEX_SHADER et y associer le source int vertexShaderId; glAssert(vertexShaderId = glCreateShader(GL_VERTEX_SHADER)); glAssert(glShaderSource(vertexShaderId, 1, (const GLchar **)&vertexShaderSource, NULL)); // 1.3 - Compiler le shader glAssert(glCompileShader(vertexShaderId)); // 1.4 - Vérifier les erreurs de compilation GLint compiled; glAssert(glGetShaderiv(vertexShaderId, GL_COMPILE_STATUS, &compiled)); if (!compiled) { std::cerr << "[" << vsFileName << "] Vertex shader not compiled : " << std::endl; printShaderInfoLog(vertexShaderId); return 0; } // 2 - Fragment shader : // 2.1 - Charger le source depuis le fichier "../shaders/fragmentdefault.glsl" en utilisant la fonction loaders::text::loadFile() de lecture d'un fichier texte char *fragmentShaderSource; fragmentShaderSource = loaders::text::loadFile(fsFileName.c_str()); // 2.2 - Créer un objet OpenGL FRAGMENT_SHADER et y associer le source int fragmentShaderId; glAssert(fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER)); glAssert(glShaderSource(fragmentShaderId, 1, (const GLchar **)&fragmentShaderSource, NULL)); // 2.3 - Compiler le shader glAssert(glCompileShader(fragmentShaderId)); // 2.4 - Vérifier les erreurs de compilation glAssert(glGetShaderiv(fragmentShaderId, GL_COMPILE_STATUS, &compiled)); if (!compiled) { std::cerr << "[" << fsFileName << "] fragment shader not compiled : " << std::endl; printShaderInfoLog(fragmentShaderId); return 0; } // 3 - Programme : // 3.1 - Créer un programme OpenGL, stocker son identifiant dans g_Program et y associer les shaders int program; glAssert(program = glCreateProgram()); glAssert(glAttachShader(program, vertexShaderId)); glAssert(glAttachShader(program, fragmentShaderId)); // 3.2 - Fixer les positions des attributs géométriques en accord avec la classe MyGLMesh et les conventions // d'écriture du source GLSL inPosition --> index 0, inNormal --> index 1 et inTexCoord --> index 2. glAssert(glBindAttribLocation(program, 0, "inPosition")); glAssert(glBindAttribLocation(program, 1, "inNormal")); glAssert(glBindAttribLocation(program, 2, "inTexCoord")); // 3.3 - Lier le programme glAssert(glLinkProgram(program)); // 3.4 - Vérifier les erreurs d'édition de lien GLint linked; glAssert(glGetProgramiv(program, GL_LINK_STATUS, &linked)); if (!linked) { std::cerr << "Program not linked" << std::endl; printProgramInfoLog(program); } return program; }
int main(int argc, char *argv[]) { GLuint vao; GLuint vbo; GLfloat vertices[] = { 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, -0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f, }; GLint status; GLuint vertexShader; GLuint fragmentShader; GLuint program; GLchar *pbuffer; GLchar buffer[4096]; GLsizei bufferLen; GLchar logBuffer[256]; GLsizei logBufferLen; GLboolean running = GL_FALSE; SDL_Window* window = NULL; SDL_GLContext glContext = NULL; if( 0 > SDL_Init(SDL_INIT_VIDEO) ){ printf("SDL_Init(Video) failed: %s\n", SDL_GetError()); goto error_sdl_init; } SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); window = SDL_CreateWindow(argv[0], 100, 100, 800, 600, SDL_WINDOW_OPENGL); if( !window ){ printf("SDL_CreateWindow failed: %s\n", SDL_GetError()); goto error_sdl_create_window; } glContext = SDL_GL_CreateContext(window); if( !glContext ){ printf("SDL_GL_CreateContext failed: %s\n", SDL_GetError()); goto error_sdl_gl_create_context; } if( 0 == gladLoadGLLoader(SDL_GL_GetProcAddress) ){ printf("gladLoadGLLoader failed\n"); goto error_glad_load_error; } /* load vertex data */ glGenVertexArrays(1, &vao); if( 0 == vao ){ printf("glGenVertexArrays failed: %d\n", glGetError()); goto error_gl_gen_vertex_arrays; } glBindVertexArray(vao); glGenBuffers(1, &vbo); if( 0 == vbo ){ printf("glGenBuffers failed: %d\n", glGetError()); goto error_gl_gen_buffers; } glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), NULL); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); glBindVertexArray(0); program = glCreateProgram(); if( 0 == program ){ printf("glCreateProgram failed: %d\n", glGetError()); goto error_gl_create_program; } /* load vertex shader */ bufferLen = sizeof(buffer); if( 0 == loadFile("../03_01_ShaderColorfulTriangle/shader.vert", buffer, &bufferLen) ){ goto error_load_vertex_source; } vertexShader = glCreateShader(GL_VERTEX_SHADER); if( 0 == vertexShader ){ goto error_gl_create_vertex_shader; } pbuffer = buffer; glShaderSource(vertexShader, 1, &pbuffer, &bufferLen); glCompileShader(vertexShader); glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status); if( 0 == status ){ glGetShaderInfoLog(vertexShader, sizeof(logBuffer), &logBufferLen, logBuffer); printf("compile shader failed:\n%s\nerror: %s\n", buffer, logBuffer); goto error_gl_compile_shader; } glAttachShader(program, vertexShader); glDeleteShader(vertexShader); vertexShader = 0; /* load fragment shader */ bufferLen = sizeof(buffer); if( 0 == loadFile("../03_01_ShaderColorfulTriangle/shader.frag", buffer, &bufferLen) ){ goto error_load_fragment_source; } fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); if( 0 == fragmentShader ){ goto error_gl_create_fragment_shader; } pbuffer = buffer; glShaderSource(fragmentShader, 1, &pbuffer, &bufferLen); glCompileShader(fragmentShader); glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status); if( 0 == status ){ glGetShaderInfoLog(fragmentShader, sizeof(logBuffer), &logBufferLen, logBuffer); printf("compile shader failed:\n%s\nerror: %s\n", buffer, logBuffer); goto error_gl_compile_fragment_shader; } glAttachShader(program, fragmentShader); /* link program */ glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &status); if( 0 == status ){ glGetProgramInfoLog(program, sizeof(logBuffer), &logBufferLen, logBuffer); printf("link program failed: %s\n", logBuffer); goto error_link_program; } running = GL_TRUE; while( running ){ SDL_Event event; while( SDL_PollEvent(&event)){ if( event.type == SDL_KEYDOWN ){ printf("quit\n"); running = GL_FALSE; break; } } glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glBindVertexArray(vao); glUseProgram(program); glDrawArrays(GL_TRIANGLES, 0, 3); glUseProgram(0); glBindVertexArray(0); SDL_GL_SwapWindow(window); } glDeleteProgram(program); glDeleteBuffers(1, &vbo); glDeleteVertexArrays(1, &vao); SDL_GL_DeleteContext(glContext); SDL_DestroyWindow(window); SDL_Quit(); return 0; error_link_program: error_gl_compile_fragment_shader: if( fragmentShader ) glDeleteShader(fragmentShader); error_gl_create_fragment_shader: error_load_fragment_source: error_gl_compile_shader: if( vertexShader ) glDeleteShader(vertexShader); error_gl_create_vertex_shader: error_load_vertex_source: glDeleteProgram(program); error_gl_create_program: glDeleteBuffers(1, &vbo); error_gl_gen_buffers: glDeleteVertexArrays(1, &vao); error_gl_gen_vertex_arrays: error_glad_load_error: SDL_GL_DeleteContext(glContext); error_sdl_gl_create_context: SDL_DestroyWindow(window); error_sdl_create_window: SDL_Quit(); error_sdl_init: return -1; }
// Read/compile/link shaders static bool loadShaders(GLuint *program, const char *definitions, const char *vertexPath, const char *fragmentPath) { GLint status; bool success = true; // Assume overall success char *buffer[2]; *program = glCreateProgram(); ASSERT_OR_RETURN(false, definitions != NULL, "Null in preprocessor definitions!"); ASSERT_OR_RETURN(false, *program, "Could not create shader program!"); *buffer = (char *)definitions; if (vertexPath) { success = false; // Assume failure before reading shader file if ((*(buffer + 1) = readShaderBuf(vertexPath))) { GLuint shader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(shader, 2, (const char **)buffer, NULL); glCompileShader(shader); // Check for compilation errors glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (!status) { debug(LOG_ERROR, "Vertex shader compilation has failed [%s]", vertexPath); printShaderInfoLog(LOG_ERROR, shader); } else { printShaderInfoLog(LOG_3D, shader); glAttachShader(*program, shader); success = true; } free(*(buffer + 1)); } } if (success && fragmentPath) { success = false; // Assume failure before reading shader file if ((*(buffer + 1) = readShaderBuf(fragmentPath))) { GLuint shader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(shader, 2, (const char **)buffer, NULL); glCompileShader(shader); // Check for compilation errors glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (!status) { debug(LOG_ERROR, "Fragment shader compilation has failed [%s]", fragmentPath); printShaderInfoLog(LOG_ERROR, shader); } else { printShaderInfoLog(LOG_3D, shader); glAttachShader(*program, shader); success = true; } free(*(buffer + 1)); } } if (success) { glLinkProgram(*program); // Check for linkage errors glGetProgramiv(*program, GL_LINK_STATUS, &status); if (!status) { debug(LOG_ERROR, "Shader program linkage has failed [%s, %s]", vertexPath, fragmentPath); printProgramInfoLog(LOG_ERROR, *program); success = false; } else { printProgramInfoLog(LOG_3D, *program); } } return success; }
ShaderProgram::operator GLuint() const { if (!name) { GLint success; GLint length; name = glCreateProgram(); typedef shader_set_t::const_iterator iter; for (iter i = shaders.begin(); i != shaders.end(); ++i) { GLenum type = i->first; const GLchar* source = i->second; GLuint shader = glCreateShader(type); glShaderSource(shader, 1, &source, 0); glCompileShader(shader); glGetShaderiv(shader, GL_COMPILE_STATUS, &success); glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length); if (length > 0) { std::string log(length, 0); glGetShaderInfoLog(shader, length, 0, &log[0]); std::clog << log << std::endl; } if (!success) { std::cerr << "error compiling shader" << std::endl; return 0; } glAttachShader(name, shader); glDeleteShader(shader); } glLinkProgram(name); glGetProgramiv(name, GL_LINK_STATUS, &success); if (!success) std::cerr << "error linking program" << std::endl; glGetProgramiv(name, GL_INFO_LOG_LENGTH, &length); if (length > 0) { std::string log(length, 0); glGetProgramInfoLog(name, length, 0, &log[0]); std::clog << log << std::endl; } // //print uniforms // { // GLint uniforms; // GLint maxlength; // // glGetProgramiv(name, GL_ACTIVE_UNIFORMS, &uniforms); // glGetProgramiv(name, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxlength); // // std::vector<GLchar> uname(maxlength); // // for (GLint i = 0; i < uniforms; ++i) // { // GLsizei length; // GLint size; // GLenum type; // // glGetActiveUniform(name, i, uname.size(), &length, &size, // &type, &uname[0]); // // std::cout << type << " [" << size << "]: " << &uname[0] // << std::endl; // } // } } return name; }
static unsigned int setup_shader(const char *vertex_shader, const char *fragment_shader) { GLuint vs=glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs, 1, (const GLchar**)&vertex_shader, nullptr); glCompileShader(vs); //compile vertex shader int status, maxLength; char *infoLog=nullptr; glGetShaderiv(vs, GL_COMPILE_STATUS, &status); //get compile status if(status==GL_FALSE) //if compile error { glGetShaderiv(vs, GL_INFO_LOG_LENGTH, &maxLength); //get error message length /* The maxLength includes the NULL character */ infoLog = new char[maxLength]; glGetShaderInfoLog(vs, maxLength, &maxLength, infoLog); //get error message fprintf(stderr, "Vertex Shader Error: %s\n", infoLog); /* Handle the error in an appropriate way such as displaying a message or writing to a log file. */ /* In this simple program, we'll just leave */ delete [] infoLog; return 0; } // for fragment shader --> same as vertex shader GLuint fs=glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs, 1, (const GLchar**)&fragment_shader, nullptr); glCompileShader(fs); glGetShaderiv(fs, GL_COMPILE_STATUS, &status); if(status==GL_FALSE) { glGetShaderiv(fs, GL_INFO_LOG_LENGTH, &maxLength); /* The maxLength includes the NULL character */ infoLog = new char[maxLength]; glGetShaderInfoLog(fs, maxLength, &maxLength, infoLog); fprintf(stderr, "Fragment Shader Error: %s\n", infoLog); /* Handle the error in an appropriate way such as displaying a message or writing to a log file. */ /* In this simple program, we'll just leave */ delete [] infoLog; return 0; } unsigned int program=glCreateProgram(); // Attach our shaders to our program glAttachShader(program, vs); glAttachShader(program, fs); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &status); if(status==GL_FALSE) { glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); /* The maxLength includes the NULL character */ infoLog = new char[maxLength]; glGetProgramInfoLog(program, maxLength, NULL, infoLog); glGetProgramInfoLog(program, maxLength, &maxLength, infoLog); fprintf(stderr, "Link Error: %s\n", infoLog); /* Handle the error in an appropriate way such as displaying a message or writing to a log file. */ /* In this simple program, we'll just leave */ delete [] infoLog; return 0; } return program; }
void setShaders() { const char * vv; const char * ff; char *vs,*fs; GLint status; GLhandleARB vertex_program,fragment_program; GLint sourceSize, shader_texture_source; vertex_program = glCreateShader(GL_VERTEX_SHADER); fragment_program = glCreateShader(GL_FRAGMENT_SHADER); vs = textFileRead(SHADER_DIR "demosaic.vrt"); if (vs==NULL) { fprintf(stderr,"ERROR: failed to read vertex shader %s\n", SHADER_DIR "demosaic.vrt"); use_shaders = 0; return; } fs = textFileRead(SHADER_DIR "demosaic.frg"); if (fs==NULL) { fprintf(stderr,"ERROR: failed to read fragment shader %s\n", SHADER_DIR "demosaic.frg"); use_shaders = 0; return; } vv = vs; ff = fs; glShaderSource(vertex_program, 1, &vv,NULL); glShaderSource(fragment_program, 1, &ff,NULL); free(vs);free(fs); glCompileShader(vertex_program); glGetShaderiv(vertex_program,GL_COMPILE_STATUS,&status); if (status!=GL_TRUE) { fprintf(stderr, "ERROR: GLSL vertex shader compile error, disabling shaders\n"); use_shaders = 0; return; } glCompileShader(fragment_program); glGetShaderiv(fragment_program,GL_COMPILE_STATUS,&status); if (status!=GL_TRUE) { fprintf(stderr, "ERROR: GLSL fragment shader compile error, disabling shaders\n"); use_shaders = 0; return; } printShaderInfoLog(vertex_program); printShaderInfoLog(fragment_program); glsl_program = glCreateProgram(); glAttachShader(glsl_program,vertex_program); glAttachShader(glsl_program,fragment_program); glLinkProgram(glsl_program); printProgramInfoLog(glsl_program); glGetProgramiv(glsl_program,GL_LINK_STATUS,&status); if (status!=GL_TRUE) { fprintf(stderr,"ERROR: GLSL link error, disabling shaders\n"); use_shaders = 0; return; } glUseProgram(glsl_program); printf("GLSL shaders in use\n"); sourceSize = glGetUniformLocation(glsl_program,"sourceSize"); shader_texture_source = glGetUniformLocation(glsl_program,"source"); glUniform4f(sourceSize, PBO_stride,height, 1.0/PBO_stride,1.0/height); glUniform1i(shader_texture_source, 0); }
static void initShader(const GLchar* vShaderFile, const GLchar* fShaderFile) { GLint status = glGetError()==GL_NO_ERROR; GLchar *vSource, *fSource; GLuint vShader, fShader; GLuint texMapLocation; /* read shader files */ vSource = readShaderSource(vShaderFile); if(vSource==NULL) { printf( "Failed to read vertex shaderi\n"); exit(EXIT_FAILURE); } fSource = readShaderSource(fShaderFile); if(fSource==NULL) { printf("Failed to read fragment shader"); exit(EXIT_FAILURE); } /* create program and shader objects */ vShader = glCreateShader(GL_VERTEX_SHADER); fShader = glCreateShader(GL_FRAGMENT_SHADER); program = glCreateProgram(); /* attach shaders to the program object */ glAttachShader(program, vShader); glAttachShader(program, fShader); /* read shaders */ glShaderSource(vShader, 1, (const GLchar**) &vSource, NULL); glShaderSource(fShader, 1, (const GLchar**) &fSource, NULL); /* compile vertex shader */ glCompileShader(vShader); /* error check */ glGetShaderiv(vShader, GL_COMPILE_STATUS, &status); if(status==GL_FALSE) { printf("Failed to compile the vertex shader.\n"); glGetShaderiv(vShader, GL_INFO_LOG_LENGTH, &elength); ebuffer = (GLchar *) malloc(elength*sizeof(char)); glGetShaderInfoLog(vShader, elength, NULL, ebuffer); printf("%s\n", ebuffer); exit(EXIT_FAILURE); } /* compile fragment shader */ glCompileShader(fShader); glGetShaderiv(fShader, GL_COMPILE_STATUS, &status); if(status==GL_FALSE) { printf("Failed to compile the fragment shader.\n"); glGetShaderiv(fShader, GL_INFO_LOG_LENGTH, &elength); ebuffer = (GLchar *) malloc(elength*sizeof(char)); glGetShaderInfoLog(fShader, elength, NULL, ebuffer); printf("%s\n", ebuffer); exit(EXIT_FAILURE); } /* link */ glLinkProgram(program); glGetShaderiv(program, GL_LINK_STATUS, &status); if(status==GL_FALSE) { printf("Failed to link program object.\n"); glGetProgramiv(program, GL_INFO_LOG_LENGTH, &elength); ebuffer = (GLchar *) malloc(elength*sizeof(char)); glGetProgramInfoLog(program, elength, &elength, ebuffer); printf("%s\n", ebuffer); exit(EXIT_FAILURE); } /* use program object */ glUseProgram(program); /* set up uniform parameter */ texMapLocation = glGetUniformLocation(program, "texMap"); glUniform1i(texMapLocation,0); }
static void device_init(struct device *dev) { GLint status; static const GLchar *vertex_shader = NK_SHADER_VERSION "uniform mat4 ProjMtx;\n" "in vec2 Position;\n" "in vec2 TexCoord;\n" "in vec4 Color;\n" "out vec2 Frag_UV;\n" "out vec4 Frag_Color;\n" "void main() {\n" " Frag_UV = TexCoord;\n" " Frag_Color = Color;\n" " gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n" "}\n"; static const GLchar *fragment_shader = NK_SHADER_VERSION "precision mediump float;\n" "uniform sampler2D Texture;\n" "in vec2 Frag_UV;\n" "in vec4 Frag_Color;\n" "out vec4 Out_Color;\n" "void main(){\n" " Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n" "}\n"; nk_buffer_init_default(&dev->cmds); dev->prog = glCreateProgram(); dev->vert_shdr = glCreateShader(GL_VERTEX_SHADER); dev->frag_shdr = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(dev->vert_shdr, 1, &vertex_shader, 0); glShaderSource(dev->frag_shdr, 1, &fragment_shader, 0); glCompileShader(dev->vert_shdr); glCompileShader(dev->frag_shdr); glGetShaderiv(dev->vert_shdr, GL_COMPILE_STATUS, &status); assert(status == GL_TRUE); glGetShaderiv(dev->frag_shdr, GL_COMPILE_STATUS, &status); assert(status == GL_TRUE); glAttachShader(dev->prog, dev->vert_shdr); glAttachShader(dev->prog, dev->frag_shdr); glLinkProgram(dev->prog); glGetProgramiv(dev->prog, GL_LINK_STATUS, &status); assert(status == GL_TRUE); dev->uniform_tex = glGetUniformLocation(dev->prog, "Texture"); dev->uniform_proj = glGetUniformLocation(dev->prog, "ProjMtx"); dev->attrib_pos = glGetAttribLocation(dev->prog, "Position"); dev->attrib_uv = glGetAttribLocation(dev->prog, "TexCoord"); dev->attrib_col = glGetAttribLocation(dev->prog, "Color"); { /* buffer setup */ GLsizei vs = sizeof(struct nk_glfw_vertex); size_t vp = offsetof(struct nk_glfw_vertex, position); size_t vt = offsetof(struct nk_glfw_vertex, uv); size_t vc = offsetof(struct nk_glfw_vertex, col); glGenBuffers(1, &dev->vbo); glGenBuffers(1, &dev->ebo); glGenVertexArrays(1, &dev->vao); glBindVertexArray(dev->vao); glBindBuffer(GL_ARRAY_BUFFER, dev->vbo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dev->ebo); glEnableVertexAttribArray((GLuint)dev->attrib_pos); glEnableVertexAttribArray((GLuint)dev->attrib_uv); glEnableVertexAttribArray((GLuint)dev->attrib_col); glVertexAttribPointer((GLuint)dev->attrib_pos, 2, GL_FLOAT, GL_FALSE, vs, (void*)vp); glVertexAttribPointer((GLuint)dev->attrib_uv, 2, GL_FLOAT, GL_FALSE, vs, (void*)vt); glVertexAttribPointer((GLuint)dev->attrib_col, 4, GL_UNSIGNED_BYTE, GL_TRUE, vs, (void*)vc); } glBindTexture(GL_TEXTURE_2D, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindVertexArray(0); }
int main() { sf::ContextSettings settings; settings.depthBits = 24; settings.stencilBits = 8; settings.antialiasingLevel = 2; sf::Window window(sf::VideoMode(800, 600), "My triangle", sf::Style::Close, settings); glewExperimental = GL_TRUE; glewInit(); GLfloat vertices[] = { // Position Color Texcoords -0.5f, 0.5f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, // Top-left 0.5f, 0.5f, 1.0f, 0.6f, 0.3f, 1.0f, 0.0f, // Top-right 0.5f, -0.5f, 1.0f, 0.2f, 0.5f, 1.0f, 1.0f, // Bottom-right -0.5f, -0.5f, 1.0f, 1.0f, 0.1f, 0.0f, 1.0f // Bottom-left }; GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); GLuint ebo; 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_STATIC_DRAW); const GLchar* vs_source = "#version 430 core \n" "in vec2 vertex; \n" "in vec3 vertex_color; \n" "in vec2 texcoord; \n" " \n" "out vec3 color; \n" "out vec2 Texcoord; \n" " \n" "void main(void) \n" "{ \n" " gl_Position = vec4(vertex, 0.0, 1.0); \n" " Texcoord = texcoord; \n" " color = vertex_color; \n" "} \n"; const GLchar* fs_source = "#version 430 core \n" "in vec3 color; \n" "in vec2 Texcoord; \n" " \n" "out vec4 outColor; \n" "uniform sampler2D tex; \n" "void main(void) \n" "{ \n" " outColor = texture(tex, Texcoord) * vec4(color, 1.0); \n" "} \n"; GLuint vs = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs, 1, &vs_source, NULL); glCompileShader(vs); GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs, 1, &fs_source, NULL); glCompileShader(fs); //Shader compile status checker. GLint status; glGetShaderiv(vs, GL_COMPILE_STATUS, &status); char buffer[512]; glGetShaderInfoLog(vs, 512, NULL, buffer); std::cout << status << std::endl; std::cout << buffer << std::endl; glGetShaderiv(fs, GL_COMPILE_STATUS, &status); glGetShaderInfoLog(fs, 512, NULL, buffer); std::cout << status << std::endl; std::cout << buffer << std::endl; GLuint shader_program = glCreateProgram(); glAttachShader(shader_program, vs); glAttachShader(shader_program, fs); glLinkProgram(shader_program); glUseProgram(shader_program); GLint vertex_attrib = glGetAttribLocation(shader_program, "vertex"); glEnableVertexAttribArray(vertex_attrib); glVertexAttribPointer(vertex_attrib, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 7, 0); GLint color_attrib = glGetAttribLocation(shader_program, "vertex_color"); glEnableVertexAttribArray(color_attrib); glVertexAttribPointer(color_attrib, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 7, (void*)(sizeof(GLfloat) * 2)); GLint texture_attrib = glGetAttribLocation(shader_program, "texcoord"); glEnableVertexAttribArray(texture_attrib); glVertexAttribPointer(texture_attrib, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 7, (void*)(sizeof(GLfloat)*5)); GLuint tex; glGenTextures(1, &tex); int width, height; unsigned char* image = SOIL_load_image("sample.png", &width, &height, 0, SOIL_LOAD_RGB); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); SOIL_free_image_data(image); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); while(window.isOpen()) { sf::Event windowEvent; while(window.pollEvent(windowEvent)) { switch(windowEvent.type) { case sf::Event::Closed: window.close(); break; case sf::Event::KeyPressed: if(windowEvent.key.code == sf::Keyboard::Escape) window.close(); break; } } glClearColor(0.0f, 0.3f, 0.5f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); window.display(); } glDeleteProgram(shader_program); glDeleteShader(fs); glDeleteShader(vs); glDeleteBuffers(1, &ebo); glDeleteBuffers(1, &vbo); return 0; }
bool Shader::initInContext(unsigned int contextId) { // handler for the single shaders GLuint vs = 0; GLuint fs = 0; GLuint gs = 0; // return values for the compile process GLint vsCompiled = 0; GLint fsCompiled = 0; GLint gsCompiled = 0; // iterator for program parameter std::map<GLenum,int>::iterator params; #ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_MESSAGES std::cerr << std::endl; std::cerr << std::endl << "Message from Message from Shader::initInContext() on SharedResource " << getSharedResourceId() << ":"; std::cerr << std::endl << " Building for context " << contextId << "."; std::cerr << std::endl; #endif // remove this resource if it allready exists removeFromContext(contextId); /// create a vertex, a fragment and a geometry shader handle vs = glCreateShader( GL_VERTEX_SHADER ); fs = glCreateShader( GL_FRAGMENT_SHADER ); if (_geometryShaderSource) { gs = glCreateShader( GL_GEOMETRY_SHADER ); } /// send shader source to the driver glShaderSource(vs, 1, &_vertexShaderSource, NULL); glShaderSource(fs, 1, &_fragmentShaderSource, NULL); if (_geometryShaderSource) { glShaderSource(gs, 1, &_geometryShaderSource, NULL); } // vertex shader glCompileShader(vs); glGetShaderiv(vs, GL_COMPILE_STATUS, &vsCompiled); if (vsCompiled == GL_FALSE) { #ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_ERRORS std::cerr << std::endl; std::cerr << std::endl << "ERROR in shader::create() on SharedResource " << getSharedResourceId() << ":"; std::cerr << std::endl << " Can't compile vertexshader \"" << _vertexShaderFileName << "\""; std::cerr << std::endl; #endif } // validate the vertex shader and print compiler log validateShader(vs, _vertexShaderFileName); // fragment shader glCompileShader( fs ); glGetShaderiv(fs, GL_COMPILE_STATUS, &fsCompiled); if (fsCompiled == GL_FALSE) { #ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_ERRORS std::cerr << std::endl; std::cerr << std::endl << "ERROR in shader::create() on SharedResource " << getSharedResourceId() << ":"; std::cerr << std::endl << " Cant't compile fragmentshader \"" << _fragmentShaderFileName << "\""; std::cerr << std::endl; #endif } // validate the fragment shader and print compiler log validateShader(fs, _fragmentShaderFileName); // geometry shader if (gs) { glCompileShader( gs ); glGetShaderiv(gs, GL_COMPILE_STATUS, &gsCompiled); if (gsCompiled == GL_FALSE) { #ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_ERRORS std::cerr << std::endl; std::cerr << std::endl << "ERROR in shader::create() on SharedResource " << getSharedResourceId() << ":"; std::cerr << std::endl << " Cant't compile geometryshader \"" << _geometryShaderFileName << "\""; std::cerr << std::endl; #endif } // validate the fragment shader and print compiler log validateShader(gs, _geometryShaderFileName); } else { // shader not used - set compile flag anyway gsCompiled = GL_TRUE; }// if (geometry shader exist) /// create a shader program and attache the compiled vertex, fragment and geometry binaries unsigned int shaderHandle = glCreateProgram(); /// make a association between the context and the GL handle of this shader setResourceHandleForContext(shaderHandle, contextId); /// attache programs to shaderh handle glAttachShader( shaderHandle, fs ); glAttachShader( shaderHandle, vs ); if (gs) { glAttachShader( shaderHandle, gs ); CheckErrorsGL(("Shader::initInContext() after attaching geometry shader for Shared Resource " + gloost::toString(getSharedResourceId())).c_str()); for ( params =_programParameter.begin(); params != _programParameter.end(); params++ ) { glProgramParameteriEXT(shaderHandle, (*params).first, (*params).second); CheckErrorsGL(("Shader::initInContext() after setting for Shared Resource " + gloost::toString(getSharedResourceId())).c_str()); } } /// link programs glLinkProgram(shaderHandle); // int temp; // glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT,&temp); // std::cerr << std::endl << "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT: " << temp; #ifndef GLOOST_SYSTEM_DISABLE_OUTPUT_MESSAGES if (vsCompiled == GL_TRUE && fsCompiled == GL_TRUE && gsCompiled == GL_TRUE) { std::cerr << std::endl; std::cerr << std::endl << "Message from Shader::compileToProgram() on SharedResource " << getSharedResourceId() << ":"; std::cerr << std::endl << " Successfully compiled and linked."; std::cerr << std::endl << " \"" << _vertexShaderFileName << "\", "; std::cerr << std::endl << " \"" << _fragmentShaderFileName << "\""; if (gs) { std::cerr << ", "<< std::endl << " \"" << _geometryShaderFileName << "\""; } std::cerr << std::endl; return true; } #endif return false; }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglShaderSource(JNIEnv *env, jclass clazz, jint shader, jint count, jlong string, jint length, jlong function_pointer) { const GLchar *string_address = (const GLchar *)(intptr_t)string; glShaderSourcePROC glShaderSource = (glShaderSourcePROC)((intptr_t)function_pointer); glShaderSource(shader, count, (const GLchar **)&string_address, (const GLint*)&length); }