Program::~Program() { glDeleteProgram(instance); }
void ShaderProgram::free_program() { glDeleteProgram(_program_id); }
static GLboolean test() { GLboolean pass = GL_TRUE; /* Prepare the shaders */ GLint prog = setup_shaders(); GLint uPixelSize = glGetUniformLocation(prog, "pixelSize"); GLint uTexUnit = glGetUniformLocation(prog, "texUnit"); GLuint scratchTex; int i; /* Pixel sizes in texture coordinates for the horizontal and vertical passes */ const float horizontal[2] = { 1.0 / WIDTH, 0 }; const float vertical[2] = { 0, 1.0 / HEIGHT }; /* Texture and vertex coordinates */ const float tc[] = { 0,1, 1,1, 0,0, 0,0, 1,1, 1,0 }; const float vc[] = { -1,1, 1,1, -1,-1, -1,-1, 1,1, 1,-1 }; /* Draw the rectangle that we're going to blur */ piglit_draw_rect(-.5, -.5, 1, 1); /* Create a scratch texture */ glGenTextures(1, &scratchTex); glBindTexture(GL_TEXTURE_2D, scratchTex); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(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); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, WIDTH, HEIGHT, 0, GL_BGRA, GL_UNSIGNED_BYTE, 0); glUseProgram(prog); glUniform1i(uTexUnit, 0); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, 0, tc); glVertexPointer(2, GL_FLOAT, 0, vc); /* Horizontal pass */ glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, WIDTH, HEIGHT); glUniform2fv(uPixelSize, 1, horizontal); glDrawArrays(GL_TRIANGLES, 0, 6); /* Vertical pass */ glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, WIDTH, HEIGHT); glUniform2fv(uPixelSize, 1, vertical); glDrawArrays(GL_TRIANGLES, 0, 6); /* Clean up */ glUseProgram(0); glBindTexture(GL_TEXTURE_2D, 0); glDeleteTextures(1, &scratchTex); glDeleteProgram(prog); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); /* Test the sides */ for (i = 0; i < 26; i++) { float color[3]; color[0] = expected_edge[i] / 255.; color[1] = color[0]; color[2] = color[0]; pass = piglit_probe_pixel_rgb(50, 12 + i, color) && pass; pass = piglit_probe_pixel_rgb(50, HEIGHT - 13 - i, color) && pass; pass = piglit_probe_pixel_rgb(12 + i, 50, color) && pass; pass = piglit_probe_pixel_rgb(WIDTH - 13 - i, 50, color) && pass; } /* Test the corners */ for (i = 0; i < 22; i++) { float color[3]; color[0] = expected_corner[i] / 255.; color[1] = color[0]; color[2] = color[0]; pass = piglit_probe_pixel_rgb(16 + i, 16 + i, color) && pass; pass = piglit_probe_pixel_rgb(16 + i, HEIGHT - 17 - i, color) && pass; pass = piglit_probe_pixel_rgb(WIDTH - 17 - i, 16 + i, color) && pass; pass = piglit_probe_pixel_rgb(WIDTH - 17 - i, HEIGHT - 17 - i, color) && pass; } return pass; }
void GlProgram::deleteProgram(const GLuint& program) { glDeleteProgram(program); }
void main() { glfwInit(); // Creates a window window = glfwCreateWindow(800, 800, "Point - Sphere Collision Detection", nullptr, nullptr); glfwMakeContextCurrent(window); glfwSwapInterval(0); // Initializes most things needed before the main loop init(); //Generate sphere mesh float radius = 1.0f; float scale = 0.25f; GenerateSphereMesh(radius, 40); //Translate the sphere sphere->translation = glm::translate(sphere->translation, glm::vec3(0.15f, 0.0f, 0.0f)); //Scale the sphere sphere->scale = glm::scale(sphere->scale, glm::vec3(scale)); //Generate point mesh struct Vertex pointVert = { 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f }; point = new struct Mesh(1, &pointVert, GL_POINTS); //Translate the point point->translation = glm::translate(point->translation, glm::vec3(-0.15f, 0.0f, 0.0f)); //Set the selected shape selectedShape = sphere; //Generate Sphere collider sphereCollider = new struct Sphere(radius * scale); //Print controls std::cout << "Use WASD to move the selected shape in the XY plane.\nUse left CTRL & left shift to move the selected shape along Z axis.\n"; std::cout << "Use spacebar to swap the selected shape.\n"; // Enter the main loop. while (!glfwWindowShouldClose(window)) { // Call to update() which will update the gameobjects. update(); // Call the render function. renderScene(); // Swaps the back buffer to the front buffer glfwSwapBuffers(window); // Checks to see if any events are pending and then processes them. glfwPollEvents(); } // After the program is over, cleanup your data! glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); glDeleteProgram(program); // Note: If at any point you stop using a "program" or shaders, you should free the data up then and there. delete sphere; delete point; //Delete Colliders delete sphereCollider; // Frees up GLFW memory glfwTerminate(); }
int main() { int width = 640; int height = 480; UserData userdata; userdata.running = true; GLWTConfig glwt_config; glwt_config.red_bits = 8; glwt_config.green_bits = 8; glwt_config.blue_bits = 8; glwt_config.alpha_bits = 8; glwt_config.depth_bits = 24; glwt_config.stencil_bits = 8; glwt_config.samples = 0; glwt_config.sample_buffers = 0; glwt_config.api = GLWT_API_OPENGL | GLWT_PROFILE_CORE; glwt_config.api_version_major = 3; glwt_config.api_version_minor = 3; GLWTAppCallbacks app_callbacks; app_callbacks.error_callback = error_callback; app_callbacks.userdata = &userdata; if(glwtInit(&glwt_config, &app_callbacks) != 0) { std::cerr << "failed to init GLWT" << std::endl; return 1; } GLWTWindowCallbacks win_callbacks; win_callbacks.close_callback = close_callback; win_callbacks.expose_callback = 0; win_callbacks.resize_callback = 0; win_callbacks.show_callback = 0; win_callbacks.focus_callback = 0; win_callbacks.key_callback = key_callback, win_callbacks.motion_callback = 0; win_callbacks.button_callback = 0; win_callbacks.mouseover_callback = 0; win_callbacks.userdata = &userdata; // create a window GLWTWindow *window = glwtWindowCreate("", width, height, &win_callbacks, 0); if(window == 0) { std::cerr << "failed to open window" << std::endl; glwtQuit(); return 1; } if (glxwInit()) { std::cerr << "failed to init GLXW" << std::endl; glwtWindowDestroy(window); glwtQuit(); return 1; } glwtWindowShow(window, 1); glwtMakeCurrent(window); glwtSwapInterval(window, 1); // shader source code std::string vertex_source = "#version 330\n" "uniform mat4 ViewProjection;\n" // the projection matrix uniform "layout(location = 0) in vec4 vposition;\n" "layout(location = 1) in vec4 vcolor;\n" "layout(location = 2) in vec3 voffset;\n" // the per instance offset "out vec4 fcolor;\n" "void main() {\n" " fcolor = vcolor;\n" " gl_Position = ViewProjection*(vposition + vec4(voffset, 0));\n" "}\n"; std::string fragment_source = "#version 330\n" "in vec4 fcolor;\n" "layout(location = 0) out vec4 FragColor;\n" "void main() {\n" " FragColor = 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 ViewProjection_location = glGetUniformLocation(shader_program, "ViewProjection"); // vao and vbo handles GLuint vao, vbo, tbo, ibo; // generate and bind the vao glGenVertexArrays(1, &vao); glBindVertexArray(vao); // generate and bind the vertex buffer object glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); // data for a cube GLfloat vertexData[] = { // X Y Z R G B // face 0: 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, // vertex 0 -1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, // vertex 1 1.0f,-1.0f, 1.0f, 1.0f, 0.0f, 0.0f, // vertex 2 -1.0f,-1.0f, 1.0f, 1.0f, 0.0f, 0.0f, // vertex 3 // face 1: 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, // vertex 0 1.0f,-1.0f, 1.0f, 0.0f, 1.0f, 0.0f, // vertex 1 1.0f, 1.0f,-1.0f, 0.0f, 1.0f, 0.0f, // vertex 2 1.0f,-1.0f,-1.0f, 0.0f, 1.0f, 0.0f, // vertex 3 // face 2: 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, // vertex 0 1.0f, 1.0f,-1.0f, 0.0f, 0.0f, 1.0f, // vertex 1 -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, // vertex 2 -1.0f, 1.0f,-1.0f, 0.0f, 0.0f, 1.0f, // vertex 3 // face 3: 1.0f, 1.0f,-1.0f, 1.0f, 1.0f, 0.0f, // vertex 0 1.0f,-1.0f,-1.0f, 1.0f, 1.0f, 0.0f, // vertex 1 -1.0f, 1.0f,-1.0f, 1.0f, 1.0f, 0.0f, // vertex 2 -1.0f,-1.0f,-1.0f, 1.0f, 1.0f, 0.0f, // vertex 3 // face 4: -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, // vertex 0 -1.0f, 1.0f,-1.0f, 0.0f, 1.0f, 1.0f, // vertex 1 -1.0f,-1.0f, 1.0f, 0.0f, 1.0f, 1.0f, // vertex 2 -1.0f,-1.0f,-1.0f, 0.0f, 1.0f, 1.0f, // vertex 3 // face 5: 1.0f,-1.0f, 1.0f, 1.0f, 0.0f, 1.0f, // vertex 0 -1.0f,-1.0f, 1.0f, 1.0f, 0.0f, 1.0f, // vertex 1 1.0f,-1.0f,-1.0f, 1.0f, 0.0f, 1.0f, // vertex 2 -1.0f,-1.0f,-1.0f, 1.0f, 0.0f, 1.0f, // vertex 3 }; // 6 faces with 4 vertices with 6 components (floats) // fill with data glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*6*4*6, vertexData, 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, &ibo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); GLuint indexData[] = { // face 0: 0,1,2, // first triangle 2,1,3, // second triangle // face 1: 4,5,6, // first triangle 6,5,7, // second triangle // face 2: 8,9,10, // first triangle 10,9,11, // second triangle // face 3: 12,13,14, // first triangle 14,13,15, // second triangle // face 4: 16,17,18, // first triangle 18,17,19, // second triangle // face 5: 20,21,22, // first triangle 22,21,23, // second triangle }; // fill with data glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*6*2*3, indexData, GL_STATIC_DRAW); // generate and bind the vertex buffer object containing the // instance offsets glGenBuffers(1, &tbo); glBindBuffer(GL_ARRAY_BUFFER, tbo); // the offsets GLfloat translationData[] = { 2.0f, 2.0f, 2.0f, // cube 0 2.0f, 2.0f,-2.0f, // cube 1 2.0f,-2.0f, 2.0f, // cube 2 2.0f,-2.0f,-2.0f, // cube 3 -2.0f, 2.0f, 2.0f, // cube 4 -2.0f, 2.0f,-2.0f, // cube 5 -2.0f,-2.0f, 2.0f, // cube 6 -2.0f,-2.0f,-2.0f, // cube 7 }; // 8 offsets with 3 components each // fill with data glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*3*8, translationData, GL_STATIC_DRAW); // set up generic attrib pointers glEnableVertexAttribArray(2); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), (char*)0 + 0*sizeof(GLfloat)); // a attrib divisor of 1 means that attribute 2 will advance once // every instance (0 would mean once per vertex) glVertexAttribDivisor(2, 1); // "unbind" vao glBindVertexArray(0); // we are drawing 3d objects so we want depth testing glEnable(GL_DEPTH_TEST); while(userdata.running) { // get the time in seconds float t = glwtGetNanoTime()*1.e-9f; // update events glwtEventHandle(0); // clear first glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // use the shader program glUseProgram(shader_program); // calculate ViewProjection matrix glm::mat4 Projection = glm::perspective(90.0f, 4.0f / 3.0f, 0.1f, 100.f); // translate the world/view position glm::mat4 View = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -5.0f)); // make the camera rotate around the origin View = glm::rotate(View, 90.0f*t, glm::vec3(1.0f, 1.0f, 1.0f)); glm::mat4 ViewProjection = Projection*View; // set the uniform glUniformMatrix4fv(ViewProjection_location, 1, GL_FALSE, glm::value_ptr(ViewProjection)); // bind the vao glBindVertexArray(vao); // draw // the additional parameter indicates how many instances to render glDrawElementsInstanced(GL_TRIANGLES, 6*6, GL_UNSIGNED_INT, 0, 8); // check for errors GLenum error = glGetError(); if(error != GL_NO_ERROR) { userdata.running = false; } // finally swap buffers glwtSwapBuffers(window); } // delete the created objects glDeleteVertexArrays(1, &vao); glDeleteBuffers(1, &vbo); glDeleteBuffers(1, &ibo); glDeleteBuffers(1, &tbo); glDetachShader(shader_program, vertex_shader); glDetachShader(shader_program, fragment_shader); glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); glDeleteProgram(shader_program); glwtWindowDestroy(window); glwtQuit(); return 0; }
Scene::~Scene() { glDeleteProgram(_shaderProgram); glDeleteBuffers(1, &_vertexBufferObject); printOpenGLError(); }
Shader::~Shader() { if (getEngineMode() == EngineMode::Normal) glDeleteProgram(shaderProgram); }
int main(int argc, char *argv[]) { GLuint vao; GLuint vbo; GLfloat vertices[] = { 0.5f, -0.5f, 0.0f, -0.5f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f, }; GLfloat colorUniform[3]; GLint colorUniformLocation; 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, 3 * sizeof(GLfloat), NULL); glEnableVertexAttribArray(0); 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_02_UseUniformVariable/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_02_UseUniformVariable/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; } colorUniformLocation = glGetUniformLocation(program, "vertColor"); if( -1 == colorUniformLocation ){ printf("get uniformm location failed: %d\n", glGetError()); goto error_get_uniform_vertColor_location; } glGetUniformfv(program, colorUniformLocation, colorUniform); running = GL_TRUE; while( running ){ SDL_Event event; while( SDL_PollEvent(&event)){ if( event.type == SDL_KEYDOWN ){ switch(event.key.keysym.sym){ case SDLK_1: if( colorUniform[0] > 0.0f ) colorUniform[0] -= 0.05f; break; case SDLK_2: if( colorUniform[0] < 1.0f ) colorUniform[0] += 0.05f; break; case SDLK_3: if( colorUniform[1] > 0.0f ) colorUniform[1] -= 0.05f; break; case SDLK_4: if( colorUniform[1] < 1.0f ) colorUniform[1] += 0.05f; break; case SDLK_5: if( colorUniform[2] > 0.0f ) colorUniform[2] -= 0.05f; break; case SDLK_6: if( colorUniform[2] < 1.0f ) colorUniform[2] += 0.05f; break; default: 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); glUniform3fv(colorUniformLocation, 1, colorUniform); //glUniform3f(colorUniformLocation, colorUniform[0], colorUniform[1], colorUniform[2]); 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_get_uniform_vertColor_location: 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; }
GlslProg::Obj::~Obj() { if( mHandle ) glDeleteProgram( (GLuint)mHandle ); }
void piglit_init(int argc, char **argv) { int i, j, num_xfb_buffers; GLuint prog, vao, xfb_buf[2]; const GLint *readback; char *gstext; bool pass = true; bool test_gl_ViewportIndex = piglit_is_extension_supported("GL_ARB_viewport_array"); num_xfb_buffers = ARRAY_SIZE(xfb_buf); if (test_gl_ViewportIndex) { asprintf(&gstext, gs_template, "#extension GL_ARB_viewport_array : require\n", " gl_ViewportIndex = i + 1;\n"); } else { printf("Skip testing 'gl_ViewportIndex'\n"); asprintf(&gstext, gs_template, "", ""); num_xfb_buffers -= 1; } prog = piglit_build_simple_program_unlinked_multiple_shaders( GL_VERTEX_SHADER, vstext, GL_GEOMETRY_SHADER, gstext, 0, NULL); glTransformFeedbackVaryings(prog, num_xfb_buffers, varyings, GL_SEPARATE_ATTRIBS); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } glUseProgram(prog); glGenVertexArrays(1, &vao); glBindVertexArray(vao); /* Setup transform feedback buffers */ glGenBuffers(num_xfb_buffers, xfb_buf); for (i = 0; i < num_xfb_buffers; i++) { glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, i, xfb_buf[i]); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, NUM_OUTPUT_INTS * sizeof(GLint), NULL, GL_STATIC_READ); } glEnable(GL_RASTERIZER_DISCARD); /* Do drawing */ glBeginTransformFeedback(GL_TRIANGLES); glDrawArrays(GL_TRIANGLES, 0, 3); glEndTransformFeedback(); /* Check if the correct data was written into the transform feedback * buffers. */ for (i = 0; i < num_xfb_buffers; i++) { glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf[i], 0, NUM_OUTPUT_INTS * sizeof(GLint)); readback = glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, NUM_OUTPUT_INTS * sizeof(GLint), GL_MAP_READ_BIT); for (j = 0; j < NUM_OUTPUT_INTS; j++) { if (readback[j] != expected[i][j]) { printf("Incorrect data for '%s' output %d." " Expected %d, got %d.\n", varyings[i], j, expected[i][j], readback[j]); pass = false; } } glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); } glDeleteBuffers(num_xfb_buffers, xfb_buf); /* Check for the errors */ pass = piglit_check_gl_error(GL_NO_ERROR) && pass; piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
int main(int argc, char **argv) { EGLDisplay sEGLDisplay; EGLContext sEGLContext; EGLSurface sEGLSurface; /* EGL Configuration */ EGLint aEGLAttributes[] = { EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_DEPTH_SIZE, 16, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NONE }; EGLint aEGLContextAttributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; EGLConfig aEGLConfigs[1]; EGLint cEGLConfigs; #ifdef _WIN32 MSG sMessage; #else XSetWindowAttributes win_attrs; int attrs[64], idx = 0, num_config = 0; int major, minor; Colormap colormap; XVisualInfo *pVisual; XEvent e; #endif GLint iLocPosition = 0; GLint iLocColour, iLocTexCoord, iLocNormal, iLocMVP; GLint iLocXangle, iLocYangle, iLocZangle; GLint iLocAspect, iLocLightPos, iLocSampler, iLocSampler2; GLuint uiProgram, uiFragShader, uiVertShader; GLenum myTex, myTex2; int bDone = 0; const unsigned int uiWidth = 640; const unsigned int uiHeight = 480; int iXangle = 0, iYangle = 0, iZangle = 0; float aTBNmatrix1[9], aTBNmatrix2[9]; float aLightPos[] = { 0.0f, 0.0f, -1.0f }; // Light is nearest camera. unsigned char *myPixels = calloc(1, 128*128*4); // Holds texture data. unsigned char *myPixels2 = calloc(1, 128*128*4); // Holds texture data. float aRotate[16], aModelView[16], aPerspective[16], aMVP[16]; int i; /* EGL Init */ #ifdef _WIN32 hDisplay = EGL_DEFAULT_DISPLAY; #else hDisplay = XOpenDisplay(NULL); if (!hDisplay) { printf("Could not open display\n"); exit(-1); } #endif sEGLDisplay = EGL_CHECK(eglGetDisplay(hDisplay)); EGL_CHECK(eglInitialize(sEGLDisplay, NULL, NULL)); EGL_CHECK(eglChooseConfig(sEGLDisplay, aEGLAttributes, aEGLConfigs, 1, &cEGLConfigs)); if (cEGLConfigs == 0) { printf("No EGL configurations were returned.\n"); exit(-1); } #ifdef _WIN32 hWindow = create_window(uiWidth, uiHeight); #else hWindow = create_window("OpenGL ES 2.0 Example on a Linux Desktop", uiWidth, uiHeight, hDisplay, sEGLDisplay, aEGLConfigs[0], &colormap, &pVisual); #endif sEGLSurface = EGL_CHECK(eglCreateWindowSurface(sEGLDisplay, aEGLConfigs[0], (EGLNativeWindowType)hWindow, NULL)); if (sEGLSurface == EGL_NO_SURFACE) { printf("Failed to create EGL surface.\n"); exit(-1); } sEGLContext = EGL_CHECK(eglCreateContext(sEGLDisplay, aEGLConfigs[0], EGL_NO_CONTEXT, aEGLContextAttributes)); if (sEGLContext == EGL_NO_CONTEXT) { printf("Failed to create EGL context.\n"); exit(-1); } EGL_CHECK(eglMakeCurrent(sEGLDisplay, sEGLSurface, sEGLSurface, sEGLContext)); /* Shader Initialisation */ process_shader(&uiVertShader, "shader.vert", GL_VERTEX_SHADER); process_shader(&uiFragShader, "shader.frag", GL_FRAGMENT_SHADER); /* Create uiProgram (ready to attach shaders) */ uiProgram = GL_CHECK(glCreateProgram()); /* Attach shaders and link uiProgram */ GL_CHECK(glAttachShader(uiProgram, uiVertShader)); GL_CHECK(glAttachShader(uiProgram, uiFragShader)); GL_CHECK(glLinkProgram(uiProgram)); /* Get attribute locations of non-fixed attributes like colour and texture coordinates. */ iLocPosition = GL_CHECK(glGetAttribLocation(uiProgram, "av4position")); iLocColour = GL_CHECK(glGetAttribLocation(uiProgram, "av3colour")); #ifdef DEBUG printf("iLocPosition = %i\n", iLocPosition); printf("iLocColour = %i\n", iLocColour); #endif /* Get uniform locations */ iLocMVP = GL_CHECK(glGetUniformLocation(uiProgram, "mvp")); #ifdef DEBUG printf("iLocMVP = %i\n", iLocMVP); #endif GL_CHECK(glUseProgram(uiProgram)); /* Enable attributes for position, colour and texture coordinates etc. */ GL_CHECK(glEnableVertexAttribArray(iLocPosition)); GL_CHECK(glEnableVertexAttribArray(iLocColour)); /* Populate attributes for position, colour and texture coordinates etc. */ GL_CHECK(glVertexAttribPointer(iLocPosition, 3, GL_FLOAT, GL_FALSE, 0, aVertices)); GL_CHECK(glVertexAttribPointer(iLocColour, 3, GL_FLOAT, GL_FALSE, 0, aColours)); GL_CHECK(glEnable(GL_CULL_FACE)); GL_CHECK(glEnable(GL_DEPTH_TEST)); #ifndef _WIN32 XSelectInput(hDisplay, hWindow, KeyPressMask | ExposureMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | VisibilityChangeMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask); #endif /* Enter event loop */ while (!bDone) { #ifdef _WIN32 if(PeekMessage(&sMessage, NULL, 0, 0, PM_REMOVE)) { if(sMessage.message == WM_QUIT) { bDone = 1; } else { TranslateMessage(&sMessage); DispatchMessage(&sMessage); } } #else while (XPending(hDisplay) > 0) { XNextEvent(hDisplay, &e); if (e.type == ButtonPress) { bDone = 1; } } #endif /* * Do some rotation with Euler angles. It is not a fixed axis as * quaterions would be, but the effect is cool. */ rotate_matrix(iXangle, 1.0, 0.0, 0.0, aModelView); rotate_matrix(iYangle, 0.0, 1.0, 0.0, aRotate); multiply_matrix(aRotate, aModelView, aModelView); rotate_matrix(iZangle, 0.0, 1.0, 0.0, aRotate); multiply_matrix(aRotate, aModelView, aModelView); /* Pull the camera back from the cube */ aModelView[14] -= 2.5; perspective_matrix(45.0, (double)uiWidth/(double)uiHeight, 0.01, 100.0, aPerspective); multiply_matrix(aPerspective, aModelView, aMVP); GL_CHECK(glUniformMatrix4fv(iLocMVP, 1, GL_FALSE, aMVP)); iXangle += 3; iYangle += 2; iZangle += 1; if(iXangle >= 360) iXangle -= 360; if(iXangle < 0) iXangle += 360; if(iYangle >= 360) iYangle -= 360; if(iYangle < 0) iYangle += 360; if(iZangle >= 360) iZangle -= 360; if(iZangle < 0) iZangle += 360; GL_CHECK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)); GL_CHECK(glDrawArrays(GL_TRIANGLES, 0, 36)); if (!eglSwapBuffers(sEGLDisplay, sEGLSurface)) { printf("Failed to swap buffers.\n"); } #ifdef _WIN32 Sleep(20); #else usleep(20000); #endif } /* Cleanup shaders */ GL_CHECK(glUseProgram(0)); GL_CHECK(glDeleteShader(uiVertShader)); GL_CHECK(glDeleteShader(uiFragShader)); GL_CHECK(glDeleteProgram(uiProgram)); /* EGL clean up */ EGL_CHECK(eglMakeCurrent(sEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); EGL_CHECK(eglDestroySurface(sEGLDisplay, sEGLSurface)); EGL_CHECK(eglDestroyContext(sEGLDisplay, sEGLContext)); EGL_CHECK(eglTerminate(sEGLDisplay)); #ifndef _WIN32 /* X windows clean up */ XDestroyWindow(hDisplay, hWindow); XFreeColormap(hDisplay, colormap); XFree(pVisual); XCloseDisplay(hDisplay); #endif return 0; }
void Uninit(void) { glDeleteBuffers(1, &vertexbuffer); glDeleteBuffers(1, &colorbuffer); glDeleteVertexArrays(1, &VertexArrayID); glDeleteProgram(programID); }
LinkedShader::~LinkedShader() { glDeleteProgram(program); }
void main() { glfwInit(); // Creates a window window = glfwCreateWindow(800, 800, "Point - AABB (3D) Collision Detection", nullptr, nullptr); // Makes the OpenGL context current for the created window. glfwMakeContextCurrent(window); // Sets the number of screen updates to wait before swapping the buffers. // Setting this to zero will disable VSync, which allows us to actually get a read on our FPS. Otherwise we'd be consistently getting 60FPS or lower, // since it would match our FPS to the screen refresh rate. // Set to 1 to enable VSync. glfwSwapInterval(0); // Initializes most things needed before the main loop init(); //Generate the box mesh struct Vertex boxVerts[24]; //Bottom face boxVerts[0] = { -1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[1] = { 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[2] = { 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[3] = { 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[4] = { 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[5] = { -1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[6] = { -1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[7] = { -1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; //Walls boxVerts[8] = { -1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[9] = { -1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[10] = { 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[11] = { 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[12] = { 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[13] = { 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[14] = { -1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[15] = { -1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; //Top boxVerts[16] = { -1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[17] = { 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[18] = { 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[19] = { 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[20] = { 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[21] = { -1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[22] = { -1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; boxVerts[23] = { -1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f }; box = new struct Mesh(24, boxVerts, GL_LINES); //Translate the box box->translation = glm::translate(box->translation, glm::vec3(0.15f, 0.0f, 0.0f)); //Scale the box box->scale = glm::scale(box->scale, glm::vec3(0.1f)); //Generate point mesh struct Vertex pointVert = { 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f }; point = new struct Mesh(1, &pointVert, GL_POINTS); //Translate the point point->translation = glm::translate(point->translation, glm::vec3(-0.15f, 0.0f, 0.0f)); //Set the selected shape selectedShape = box; //Generate AABB collider aabbCollider = new struct AABB(boxVerts[1].x - boxVerts[0].x, boxVerts[9].y - boxVerts[8].y, boxVerts[3].z - boxVerts[2].z); //Print controls std::cout << "Use WASD to move the selected shape in the XY plane.\nUse left CTRL & left shift to move the selected shape along Z axis.\n"; std::cout << "Use spacebar to swap the selected shape.\n"; // Enter the main loop. while (!glfwWindowShouldClose(window)) { // Call to update() which will update the gameobjects. update(); // Call the render function. renderScene(); // Swaps the back buffer to the front buffer glfwSwapBuffers(window); // Checks to see if any events are pending and then processes them. glfwPollEvents(); } // After the program is over, cleanup your data! glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); glDeleteProgram(program); delete box; delete point; delete aabbCollider; // Frees up GLFW memory glfwTerminate(); }
GLuint CreateShaderProgram(const std::string &vsSource, const std::string &gsSource, const std::string &fsSource) { GLuint programID = glCreateProgram(); GLuint vsID = glCreateShader(GL_VERTEX_SHADER); GLuint gsID = glCreateShader(GL_GEOMETRY_SHADER); GLuint fsID = glCreateShader(GL_FRAGMENT_SHADER); if (programID == 0 || vsID == 0 || gsID == 0 || fsID == 0) { // Clean up others that were created glDeleteProgram(programID); glDeleteShader(vsID); glDeleteShader(gsID); glDeleteShader(fsID); std::cerr << "Cannot create Shaders or Program" << std::endl; return 0; // invalid ID } // glShaderSource() expects char**, so these are helper variables const char *vsSourceArray = vsSource.c_str(); const char *gsSourceArray = gsSource.c_str(); const char *fsSourceArray = fsSource.c_str(); // https://www.opengl.org/sdk/docs/man4/xhtml/glShaderSource.xml glShaderSource(vsID, 1, &vsSourceArray, NULL); glShaderSource(gsID, 1, &gsSourceArray, NULL); glShaderSource(fsID, 1, &fsSourceArray, NULL); // Compile the Shader Sources, check for errors glCompileShader(vsID); glCompileShader(gsID); glCompileShader(fsID); if (!checkCompileStatus(vsID) || !checkCompileStatus(fsID) || !checkCompileStatus(gsID)) { // Clean up others that were created glDeleteProgram(programID); glDeleteShader(vsID); glDeleteShader(gsID); glDeleteShader(fsID); std::cerr << "Cannot Compile Shaders or Program" << std::endl; return 0; // invalid ID } glAttachShader(programID, vsID); glAttachShader(programID, gsID); glAttachShader(programID, fsID); glLinkProgram(programID); if (!checkLinkStatus(programID)) { // Clean up others that were created glDeleteProgram(programID); glDeleteShader(vsID); glDeleteShader(gsID); glDeleteShader(fsID); std::cerr << "Cannot Link Shaders or Program" << std::endl; return 0; // invalid ID } return programID; }
GLuint OsmAnd::RenderAPI_OpenGL_Common::linkProgram( GLuint shadersCount, GLuint *shaders ) { GL_CHECK_PRESENT(glCreateProgram); GL_CHECK_PRESENT(glAttachShader); GL_CHECK_PRESENT(glLinkProgram); GL_CHECK_PRESENT(glGetProgramiv); GL_CHECK_PRESENT(glGetProgramInfoLog); GL_CHECK_PRESENT(glDeleteProgram); GLuint program = 0; program = glCreateProgram(); GL_CHECK_RESULT; for(auto shaderIdx = 0u; shaderIdx < shadersCount; shaderIdx++) { glAttachShader(program, shaders[shaderIdx]); GL_CHECK_RESULT; } glLinkProgram(program); GL_CHECK_RESULT; GLint linkSuccessful; glGetProgramiv(program, GL_LINK_STATUS, &linkSuccessful); GL_CHECK_RESULT; if(linkSuccessful != GL_TRUE) { GLint logBufferLen = 0; GLsizei logLen = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logBufferLen); GL_CHECK_RESULT; if (logBufferLen > 1) { GLchar* log = (GLchar*)malloc(logBufferLen); glGetProgramInfoLog(program, logBufferLen, &logLen, log); GL_CHECK_RESULT; assert(logLen + 1 == logBufferLen); LogPrintf(LogSeverityLevel::Error, "Failed to link GLSL program:\n%s", log); free(log); } glDeleteProgram(program); GL_CHECK_RESULT; program = 0; return program; } // Show some info GLint attributesCount; glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &attributesCount); GL_CHECK_RESULT; LogPrintf(LogSeverityLevel::Info, "GLSL program %d has %d input variable(s)", program, attributesCount); GLint uniformsCount; glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &uniformsCount); GL_CHECK_RESULT; LogPrintf(LogSeverityLevel::Info, "GLSL program %d has %d parameter variable(s)", program, uniformsCount); return program; }
void SimpleTriangleCase::Close() { glDeleteProgram(_programId); glDeleteBuffers(1, &_vboTriangle); }
enum piglit_result piglit_display(void) { const char *vs_ssbo_template = "#version 130\n" "#extension GL_ARB_shader_storage_buffer_object : enable\n" "#extension GL_ARB_uniform_buffer_object : enable\n" "\n" "varying vec4 vary;" "in vec4 piglit_vertex;\n" "\n" "layout(std140) buffer ssbo {\n" " vec4 v[%d];\n" "};\n" "uniform int i;\n" "\n" "void main() {\n" " gl_Position = piglit_vertex;\n" " vary = v[i];\n" "}\n"; const char *fs_template = "#version 130\n" "#extension GL_ARB_shader_storage_buffer_object : enable\n" "\n" "varying vec4 vary;" "\n" "void main() {\n" " gl_FragColor = vary;\n" "}\n"; const char *vs_template = "#version 130\n" "#extension GL_ARB_shader_storage_buffer_object : enable\n" "in vec4 piglit_vertex;\n" "\n" "void main() {\n" " gl_Position = piglit_vertex;\n" "}\n"; const char *fs_ssbo_template = "#version 130\n" "#extension GL_ARB_shader_storage_buffer_object : enable\n" "#extension GL_ARB_uniform_buffer_object : enable\n" "\n" "layout(std140) buffer ssbo {\n" " vec4 v[%d];\n" "};\n" "uniform int i;\n" "\n" "void main() {\n" " gl_FragColor = v[i];\n" "}\n"; char *vs_source, *fs_source; GLint max_size, vec4s, i_location; GLuint vs, fs, prog, bo; GLenum target; float *data; size_t size; bool pass = true; bool link_should_fail; const float green[4] = { 0, 1, 0, 0 }; int test_index; piglit_require_extension("GL_ARB_shader_storage_buffer_object"); piglit_require_extension("GL_ARB_uniform_buffer_object"); glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &max_size); printf("Max shader storage block size: %d\n", max_size); vec4s = max_size / 4 / 4; switch (mode) { case VS: target = GL_VERTEX_SHADER; link_should_fail = false; test_index = vec4s - 1; break; case VS_EXCEED: target = GL_VERTEX_SHADER; link_should_fail = true; vec4s++; test_index = vec4s - 2; break; case FS: target = GL_FRAGMENT_SHADER; link_should_fail = false; test_index = vec4s - 1; break; case FS_EXCEED: target = GL_FRAGMENT_SHADER; link_should_fail = true; vec4s++; test_index = vec4s - 2; break; default: assert(false); target = GL_NONE; link_should_fail = false; } switch (target) { case GL_VERTEX_SHADER: (void)!asprintf(&vs_source, vs_ssbo_template, vec4s); (void)!asprintf(&fs_source, "%s", fs_template); printf("Testing VS with shader storage block vec4 v[%d]\n", vec4s); break; case GL_FRAGMENT_SHADER: (void)!asprintf(&vs_source, "%s", vs_template); (void)!asprintf(&fs_source, fs_ssbo_template, vec4s); printf("Testing FS with shader storage block vec4 v[%d]\n", vec4s); break; default: piglit_report_result(PIGLIT_FAIL); } vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source); fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_source); prog = glCreateProgram(); glAttachShader(prog, vs); glAttachShader(prog, fs); glLinkProgram(prog); if (link_should_fail) { if (!piglit_link_check_status_quiet(prog)) { printf("Failed to link with shader storage block vec4 " "v[%d]\n", vec4s); piglit_report_result(PIGLIT_PASS); } } else { if (!piglit_link_check_status_quiet(prog)) { fprintf(stderr, "Failed to link with shader storage block vec4 " "v[%d]\n", vec4s); return PIGLIT_FAIL; } } size = vec4s * 4 * sizeof(float); glGenBuffers(1, &bo); glBindBuffer(GL_SHADER_STORAGE_BUFFER, bo); glBufferData(GL_SHADER_STORAGE_BUFFER, size, NULL, GL_DYNAMIC_DRAW); data = glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_WRITE); memset(data, 0, size); /* The whole shader storage buffer will be zeros, except for the * entry at v[test_index] which will be green. */ data[test_index * 4 + 0] = green[0]; data[test_index * 4 + 1] = green[1]; data[test_index * 4 + 2] = green[2]; data[test_index * 4 + 3] = green[3]; glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); glUseProgram(prog); i_location = glGetUniformLocation(prog, "i"); glUniform1i(i_location, test_index); glShaderStorageBlockBinding(prog, 0, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, bo); piglit_draw_rect(-1, -1, 2, 2); pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green); glDeleteProgram(prog); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void Instance::Shutdown() { glDeleteProgram(program); }
static int gub_create_program() { GLbyte vShaderStr[] = "attribute vec4 aPosition; \n" "attribute vec2 aTexCoord; \n" "varying vec2 vTexCoord; \n" "void main() \n" "{ \n" " gl_Position = aPosition; \n" " vTexCoord = aTexCoord; \n" "} \n"; GLbyte fShaderStr[] = "precision mediump float; \n" "varying vec2 vTexCoord; \n" "uniform sampler2D sTexture; \n" "void main() \n" "{ \n" " gl_FragColor = texture2D(sTexture, vTexCoord); \n" "} \n"; GLuint vertexShader; GLuint fragmentShader; GLuint programObject; GLint linked; // Load the vertex/fragment shaders vertexShader = gub_load_shader(GL_VERTEX_SHADER, vShaderStr); fragmentShader = gub_load_shader(GL_FRAGMENT_SHADER, fShaderStr); // Create the program object programObject = glCreateProgram(); if (programObject == 0) return 0; glAttachShader(programObject, vertexShader); glAttachShader(programObject, fragmentShader); // Bind aPosition to attribute 0 and aTexCoord to attribute 1 glBindAttribLocation(programObject, 0, "aPosition"); glBindAttribLocation(programObject, 1, "aTexCoord"); // Link the program glLinkProgram(programObject); // Check the link status glGetProgramiv(programObject, GL_LINK_STATUS, &linked); if (!linked) { GLint infoLen = 0; glGetProgramiv(programObject, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen > 1) { char* infoLog = malloc(sizeof(char) * infoLen); glGetProgramInfoLog(programObject, infoLen, NULL, infoLog); gub_log("Error linking program: %s", infoLog); free(infoLog); } glDeleteProgram(programObject); return 0; } // Store the program object return programObject; }
static void CleanUp(void) { glDeleteShader(fragShader); glDeleteShader(vertShader); glDeleteProgram(program); }
void GraphicsContext3D::deleteProgram(Platform3DObject program) { makeContextCurrent(); glDeleteProgram(program); }
// Cleanup void ShutdownRC(void) { glDeleteProgram(cullingShader); }
~YUV2RGBShader() { glDeleteShader(vert); glDeleteShader(frag); glDeleteProgram(prog); }
///////////////////////////////////////////////////////////////// // Load a pair of shaders, compile, and link together. Specify the complete // file path for each shader. Note, there is no support for // just loading say a vertex program... you have to do both. GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg, bool loadFromFile) { // Temporary Shader objects GLuint hVertexShader; GLuint hFragmentShader; GLuint hReturn = 0; GLint testVal; // Create shader objects hVertexShader = glCreateShader(GL_VERTEX_SHADER); hFragmentShader = glCreateShader(GL_FRAGMENT_SHADER); if (loadFromFile) { if(gltLoadShaderFile(szVertexProg, hVertexShader) == false) { glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } if(gltLoadShaderFile(szFragmentProg, hFragmentShader) == false) { glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } } else { gltLoadShaderSrc(vertexShader, hVertexShader); gltLoadShaderSrc(fragmentShader, hFragmentShader); } // Compile them glCompileShader(hVertexShader); glCompileShader(hFragmentShader); // Check for errors glGetShaderiv(hVertexShader, GL_COMPILE_STATUS, &testVal); if(testVal == GL_FALSE) { char temp[256] = ""; glGetShaderInfoLog( hVertexShader, 256, NULL, temp); fprintf( stderr, "Compile failed:\n%s\n", temp); assert(0); exit(0); glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } glGetShaderiv(hFragmentShader, GL_COMPILE_STATUS, &testVal); if(testVal == GL_FALSE) { char temp[256] = ""; glGetShaderInfoLog( hFragmentShader, 256, NULL, temp); fprintf( stderr, "Compile failed:\n%s\n", temp); assert(0); exit(0); glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); return (GLuint)NULL; } // Link them - assuming it works... hReturn = glCreateProgram(); glAttachShader(hReturn, hVertexShader); glAttachShader(hReturn, hFragmentShader); glLinkProgram(hReturn); // These are no longer needed glDeleteShader(hVertexShader); glDeleteShader(hFragmentShader); // Make sure link worked too glGetProgramiv(hReturn, GL_LINK_STATUS, &testVal); if(testVal == GL_FALSE) { glDeleteProgram(hReturn); return (GLuint)NULL; } return hReturn; }
GLuint create_program() { const char* fragment_shader_source = R""( #version 330 uniform sampler2D sampler; uniform float scale; in vec2 texcoord; out vec4 color; void main() { vec4 sample = texture2D(sampler, texcoord); color = clamp(vec4(sample.rgb / sample.a, 1) * scale, 0, 1); } )""; const char* vertex_shader_source = R""( #version 330 layout(location = 0)in vec3 position; out vec2 texcoord; void main() { texcoord = (position.xy + vec2(1, 1)) * .5f; gl_Position = vec4(position, 1.f); } )""; GLuint fragment_shader = create_shader(GL_FRAGMENT_SHADER, fragment_shader_source); GLuint vertex_shader = create_shader(GL_VERTEX_SHADER, vertex_shader_source); GLuint program = glCreateProgram(); glAttachShader(program, fragment_shader); glAttachShader(program, vertex_shader); glBindAttribLocation(program, 0, "position"); glLinkProgram(program); GLint is_linked = 0; glGetProgramiv(program, GL_LINK_STATUS, (int *)&is_linked); if(is_linked == GL_FALSE) { GLint length = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); std::vector<GLchar> info(length); glGetProgramInfoLog(program, length, &length, info.data()); glDeleteProgram(program); glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); std::cerr << "Failed to link program. Info log:\n" << info.data() << std::endl; return 0; } glDetachShader(program, fragment_shader); glDetachShader(program, vertex_shader); glDeleteShader(fragment_shader); glDeleteShader(vertex_shader); return program; }
PVShader::~PVShader() { glDeleteProgram(program); }
bool TeapotRenderer::LoadShaders( SHADER_PARAMS* params, const char* strVsh, const char* strFsh ) { GLuint program; GLuint vert_shader, frag_shader; char *vert_shader_pathname, *frag_shader_pathname; // Create shader program program = glCreateProgram(); LOGI( "Created Shader %d", program ); // Create and compile vertex shader if( !ndk_helper::shader::CompileShader( &vert_shader, GL_VERTEX_SHADER, strVsh ) ) { LOGI( "Failed to compile vertex shader" ); glDeleteProgram( program ); return false; } // Create and compile fragment shader if( !ndk_helper::shader::CompileShader( &frag_shader, GL_FRAGMENT_SHADER, strFsh ) ) { LOGI( "Failed to compile fragment shader" ); glDeleteProgram( program ); return false; } // Attach vertex shader to program glAttachShader( program, vert_shader ); // Attach fragment shader to program glAttachShader( program, frag_shader ); // Bind attribute locations // this needs to be done prior to linking glBindAttribLocation( program, ATTRIB_VERTEX, "myVertex" ); glBindAttribLocation( program, ATTRIB_NORMAL, "myNormal" ); glBindAttribLocation( program, ATTRIB_UV, "myUV" ); // Link program if( !ndk_helper::shader::LinkProgram( program ) ) { LOGI( "Failed to link program: %d", program ); if( vert_shader ) { glDeleteShader( vert_shader ); vert_shader = 0; } if( frag_shader ) { glDeleteShader( frag_shader ); frag_shader = 0; } if( program ) { glDeleteProgram( program ); } return false; } // Get uniform locations params->matrix_projection_ = glGetUniformLocation( program, "uPMatrix" ); params->matrix_view_ = glGetUniformLocation( program, "uMVMatrix" ); params->light0_ = glGetUniformLocation( program, "vLight0" ); params->material_diffuse_ = glGetUniformLocation( program, "vMaterialDiffuse" ); params->material_ambient_ = glGetUniformLocation( program, "vMaterialAmbient" ); params->material_specular_ = glGetUniformLocation( program, "vMaterialSpecular" ); // Release vertex and fragment shaders if( vert_shader ) glDeleteShader( vert_shader ); if( frag_shader ) glDeleteShader( frag_shader ); params->program_ = program; return true; }
void Rectangle::Shutdown() { glDeleteProgram(program); glDeleteVertexArrays(1, &vao); glDeleteBuffers(1, &vbo); }