GLuint GLAPIENTRY _mesa_CreateProgram(void) { GET_CURRENT_CONTEXT(ctx); if (MESA_VERBOSE & VERBOSE_API) _mesa_debug(ctx, "glCreateProgram\n"); return create_shader_program(ctx); }
/** * For GL_EXT_separate_shader_objects */ GLuint GLAPIENTRY _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string) { GET_CURRENT_CONTEXT(ctx); const GLuint shader = create_shader(ctx, type); GLuint program = 0; if (shader) { shader_source(ctx, shader, _mesa_strdup(string)); compile_shader(ctx, shader); program = create_shader_program(ctx); if (program) { struct gl_shader_program *shProg; struct gl_shader *sh; GLint compiled = GL_FALSE; shProg = _mesa_lookup_shader_program(ctx, program); sh = _mesa_lookup_shader(ctx, shader); get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled); if (compiled) { attach_shader(ctx, program, shader); link_program(ctx, program); detach_shader(ctx, program, shader); #if 0 /* Possibly... */ if (active-user-defined-varyings-in-linked-program) { append-error-to-info-log; shProg->LinkStatus = GL_FALSE; } #endif } ralloc_strcat(&shProg->InfoLog, sh->InfoLog); } delete_shader(ctx, shader); } return program; }
int HSV::start(const std::vector<CL_String> &args) { CL_DisplayWindow window("ClanLib HSV Example", 1024, 768); CL_Slot slot = window.sig_window_close().connect(this, &HSV::on_close); CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &HSV::on_input_up); CL_GraphicContext gc = window.get_gc(); CL_InputContext ic = window.get_ic(); CL_ProgramObject program = create_shader_program(gc); CL_Texture texture = create_texture(gc); CL_Font font(gc, "tahoma", 24); unsigned int last_time = CL_System::get_time(); float hue_offset = 0.0; while (!quit) { unsigned int current_time = CL_System::get_time(); float time_delta_ms = static_cast<float> (current_time - last_time); last_time = current_time; if (ic.get_keyboard().get_keycode(CL_KEY_LEFT)) hue_offset += 0.0005f * time_delta_ms; else if (ic.get_keyboard().get_keycode(CL_KEY_RIGHT)) hue_offset -= 0.0005f * time_delta_ms; if (hue_offset < -1.0f) hue_offset += 1.0f; if (hue_offset > 1.0f) hue_offset -= 1.0f; render_texture(gc, program, texture, hue_offset); font.draw_text(gc, 32, 700, "Use cursor keys left and right"); window.flip(); CL_KeepAlive::process(10); } return 0; }
int HSV::start(const std::vector<std::string> &args) { DisplayWindow window("ClanLib HSV Example", 1024, 768); Slot slot = window.sig_window_close().connect(this, &HSV::on_close); Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &HSV::on_input_up); Canvas canvas(window); InputContext ic = window.get_ic(); ProgramObject program = create_shader_program(canvas); Texture texture = create_texture(canvas); clan::Font font(canvas, "tahoma", 24); ubyte64 last_time = System::get_time(); float hue_offset = 0.0; while (!quit) { ubyte64 current_time = System::get_time(); float time_delta_ms = static_cast<float> (current_time - last_time); last_time = current_time; if (ic.get_keyboard().get_keycode(keycode_left)) hue_offset += 0.0005f * time_delta_ms; else if (ic.get_keyboard().get_keycode(keycode_right)) hue_offset -= 0.0005f * time_delta_ms; if (hue_offset < -1.0f) hue_offset += 1.0f; if (hue_offset > 1.0f) hue_offset -= 1.0f; render_texture(canvas, program, texture, hue_offset); font.draw_text(canvas, 32, 700, "Use cursor keys left and right"); window.flip(); KeepAlive::process(10); } return 0; }
GLhandleARB GLAPIENTRY _mesa_CreateProgramObjectARB(void) { GET_CURRENT_CONTEXT(ctx); return create_shader_program(ctx); }
int main(void) { if(!glfwInit()) { fprintf(stderr, "Could not load GLFW, aborting.\n"); return(EXIT_FAILURE); } int WIDTH, HEIGHT; WIDTH = 800; HEIGHT = 600; GLFWwindow *window; window = glfwCreateWindow(WIDTH,HEIGHT,"05 camera.", NULL, NULL); if(!window) { fprintf(stderr, "Could not create main window, aborting.\n"); return(EXIT_FAILURE); } glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); glewExperimental = GL_TRUE; if(glewInit() != GLEW_OK) { fprintf(stderr, "Could not initialize GLEW, aborting.\n"); return(EXIT_FAILURE); } glEnable(GL_DEPTH_TEST); glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); GLuint VAO, VBO, lightVAO; glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); //glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, stride, // (GLvoid*)(3*sizeof(GLfloat))); //glEnableVertexAttribArray(1); glBindVertexArray(0); /* LightVAO definition. */ glGenVertexArrays(1, &lightVAO); glBindVertexArray(lightVAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); // Same vertex data as cube. glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)0); glEnableVertexAttribArray(0); glBindVertexArray(0); char* vertex_source = read_shader("shaders/07.vert"); char* fragment_source = read_shader("shaders/07.frag"); char* lamp_fragment_source = read_shader("shaders/07_lamp.frag"); GLuint shader_program, lamp_program; shader_program = create_shader_program(vertex_source, fragment_source); lamp_program = create_shader_program(vertex_source, lamp_fragment_source); free(vertex_source); free(fragment_source); free(lamp_fragment_source); //GLuint texture; //glActiveTexture(GL_TEXTURE0); //glGenTextures(1, &texture); //glBindTexture(GL_TEXTURE_2D, texture); //load_texture("textures/02_container.jpg"); //glUniform1i(glGetUniformLocation(shader_program, "texture_sampler"), 0); //glBindTexture(GL_TEXTURE_2D, 0); Mat4f *projection, *model, *view, *temp, *temp2; mat4f_allocate(&projection); mat4f_allocate(&model); mat4f_allocate(&view); mat4f_allocate(&temp); mat4f_allocate(&temp2); mat4f_translate(view, 0.0f, 0.0f, -3.0f); //mat4f_rotate_x(model, -M_PI/4); mat4f_rotate_x(model, 0.0f); Vec3f *light_position; vec3f_allocate(&light_position); vec3f_allocate(&camera_pos); vec3f_allocate(&camera_target); vec3f_allocate(&camera_up); vec3f_allocate(&camera_front); vec3f_allocate(&temp_vec3f); vec3f_set(camera_target, 0.0f, 0.0f, 0.0f); vec3f_set(camera_up, 0.0f, 1.0f, 0.0f); vec3f_set(camera_front, 0.0f, 0.0f, -1.0f); vec3f_set(camera_pos, 0.0f, 0.0f, 3.0f); vec3f_set(light_position, 1.2f, 1.0f, 2.0f); /* shader locations */ GLuint model_location, projection_location, view_location, light_position_location, view_position_location; glUseProgram(shader_program); model_location = glGetUniformLocation(shader_program, "model"); projection_location = glGetUniformLocation(shader_program, "perspective"); view_location = glGetUniformLocation(shader_program, "view"); light_position_location = glGetUniformLocation(shader_program, "light_position"); view_position_location = glGetUniformLocation(shader_program, "view_position"); GLuint object_color_location, light_color_location; object_color_location = glGetUniformLocation(shader_program, "object_color"); light_color_location = glGetUniformLocation(shader_program, "light_color"); glUniform3f(object_color_location, 1.0f, 0.5f, 0.31f); glUniform3f(light_color_location, 1.0f, 1.0f, 1.0); glUniform3f(light_position_location, light_position->data[0], light_position->data[1], light_position->data[2]); glUseProgram(0); glUseProgram(lamp_program); GLuint lamp_model_location, lamp_projection_location, lamp_view_location; lamp_model_location = glGetUniformLocation(lamp_program, "model"); lamp_projection_location = glGetUniformLocation(lamp_program, "perspective"); lamp_view_location = glGetUniformLocation(lamp_program, "view"); glUseProgram(0); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); current_frame = 0.0f; last_frame = 0.0f; last_x = WIDTH / 2.0f; last_y = HEIGHT / 2.0f; fov = M_PI/4; yaw = -M_PI/2; pitch = 0.0f; first_mouse = true; while(!glfwWindowShouldClose(window)) { glfwPollEvents(); current_frame = glfwGetTime(); delta_time = current_frame - last_frame; last_frame = current_frame; do_movement(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glUseProgram(shader_program); // glActiveTexture(GL_TEXTURE0); // glBindTexture(GL_TEXTURE_2D, texture); // cam_x = sinf(time) * radius; // cam_z = cosf(time) * radius; vec3f_add(camera_target, camera_pos, camera_front); mat4f_look_at(view, camera_pos, camera_target, camera_up); mat4f_perspective(projection, fov, (float)WIDTH/(float)HEIGHT, 0.1f, 100.0f); //mat4f_rotate_x(model, sinf(time) * M_PI); glUniformMatrix4fv(model_location, 1, GL_TRUE, mat4f_pointer(model)); glUniformMatrix4fv(view_location, 1, GL_TRUE, mat4f_pointer(view)); glUniformMatrix4fv(projection_location, 1, GL_TRUE, mat4f_pointer(projection)); glUniform3f(view_position_location, camera_pos->data[0], camera_pos->data[1], camera_pos->data[2]); glBindVertexArray(VAO); glDrawArrays(GL_TRIANGLES, 0, 36); // glBindTexture(GL_TEXTURE_2D, 0); glBindVertexArray(0); glUseProgram(lamp_program); //glUseProgram(shader_program); mat4f_scale(temp, 0.2f, 0.2f, 0.2f); mat4f_mul(temp, temp, model); mat4f_translate_vec3f(temp2, light_position); mat4f_mul(temp2, temp2, temp); //mat4f_print(temp); glUniformMatrix4fv(lamp_model_location, 1, GL_TRUE, mat4f_pointer(temp2)); glUniformMatrix4fv(lamp_view_location, 1, GL_TRUE, mat4f_pointer(view)); glUniformMatrix4fv(lamp_projection_location, 1, GL_TRUE, mat4f_pointer(projection)); glBindVertexArray(lightVAO); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); glfwSwapBuffers(window); } glfwTerminate(); return(EXIT_SUCCESS); }
HSVSpriteBatch::HSVSpriteBatch(CL_GraphicContext &gc) : fill_position(0), texture_group(CL_Size(256, 256)), program(create_shader_program(gc)) { }
int main(void) { if (!glfwInit()) { fprintf(stderr, "Could not initialize GLFW, aborting.\n"); return(EXIT_FAILURE); } 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); int WIDTH, HEIGHT; WIDTH = 800; HEIGHT = 600; // Define the viewport dimensions glViewport(0, 0, WIDTH, HEIGHT); GLFWwindow* window; window = glfwCreateWindow(WIDTH, HEIGHT, "04 coordinate systems.", NULL, NULL); glfwSetKeyCallback(window, key_callback); if (!window) { fprintf(stderr, "Could not create window, aborting.\n"); return(EXIT_FAILURE); } glfwMakeContextCurrent(window); glewExperimental = GL_TRUE; if(glewInit() != GLEW_OK) { fprintf(stderr, "Could not initialize GLEW, aborting.\n"); return(EXIT_FAILURE); } glEnable(GL_DEPTH_TEST); GLuint VAO, VBO, EBO; glGenVertexArrays(1 ,&VAO); glGenBuffers(1, &VBO); glGenBuffers(1, &EBO); glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, stride, (GLvoid*)(3*sizeof(GLfloat))); glEnableVertexAttribArray(1); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glBindVertexArray(0); char *vertex_source = read_shader("shaders/04.vert"); char *fragment_source = read_shader("shaders/04.frag"); GLuint shader_program; shader_program = create_shader_program(vertex_source, fragment_source); glUseProgram(shader_program); GLuint texture; glActiveTexture(GL_TEXTURE0); glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); load_texture("textures/02_container.jpg"); glUniform1i(glGetUniformLocation(shader_program, "texture_sampler"), 0); glBindTexture(GL_TEXTURE_2D, 0); float rotation_step; rotation_step = M_PI/6; Mat4f *model, *view, *projection, *rotation, *temp; mat4f_allocate(&model); mat4f_allocate(&view); mat4f_allocate(&projection); mat4f_allocate(&rotation); mat4f_allocate(&temp); mat4f_translate(view, 0.0f, 0.0f, -3.0f); mat4f_perspective(projection, (float)M_PI/4, (float)WIDTH/(float)HEIGHT, 0.1f, 100.0f); GLuint model_location, view_location, projection_location; model_location = glGetUniformLocation(shader_program, "model"); view_location = glGetUniformLocation(shader_program, "view"); projection_location = glGetUniformLocation(shader_program, "projection"); int num_cubes = 10; srand (time(NULL)); Vec4f positions[num_cubes]; float a = 4.0f; for (int i = 0; i < num_cubes; i++) { Vec4f vector; for (int j = 0; j < 4; j++) { if (j == 2) { vector.data[j] = ((float)rand()/(float)(RAND_MAX/1.0f)-2.0f); } else { vector.data[j] = ((float)rand()/(float)(RAND_MAX/a))-2.0f; //vector.data[j] = 1.0f*i*j; } printf("%f, ",vector.data[j]); } printf("\n"); positions[i] = vector; }; glClearColor(1.0f, 0.5f, 1.0f, 1.0f); while(!glfwWindowShouldClose(window)) { glfwPollEvents(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glBindVertexArray(VAO); float time = glfwGetTime(); for(int i = 0; i < num_cubes; i++) { float *pos = positions[i].data; glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture); mat4f_rotate_x(rotation, rotation_step*time*(i+1)); mat4f_rotate_y(temp, rotation_step*time*(i+1)); mat4f_mul(rotation, rotation, temp); mat4f_translate(temp, pos[0], pos[1], pos[2]); mat4f_rotate_x(model, -M_PI/4); mat4f_mul(model, model, temp); mat4f_mul(model, model, rotation); glUniformMatrix4fv(model_location, 1, GL_TRUE, mat4f_pointer(model)); glUniformMatrix4fv(view_location, 1, GL_TRUE, mat4f_pointer(view)); glUniformMatrix4fv(projection_location, 1, GL_TRUE, mat4f_pointer(projection)); glDrawArrays(GL_TRIANGLES, 0, 36); glBindTexture(GL_TEXTURE_2D, 0); } //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); glBindVertexArray(0); glfwSwapBuffers(window); } glfwTerminate(); return EXIT_SUCCESS; }
gboolean gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx, GstVideoFormat format) { GLboolean ret; const gchar *texnames[3] = { NULL, }; gchar *frag_prog = NULL; gboolean free_frag_prog = FALSE; gint i; GST_DEBUG_OBJECT (ctx->element, "Enter EGL surface setup"); if (!gst_egl_adaptation_create_surface (ctx)) { goto HANDLE_ERROR_LOCKED; } gst_egl_adaptation_query_buffer_preserved (ctx); if (!gst_egl_adaptation_make_current (ctx, TRUE)) goto HANDLE_ERROR_LOCKED; gst_egl_adaptation_query_par (ctx); /* Save surface dims */ gst_egl_adaptation_update_surface_dimensions (ctx); /* We have a surface! */ ctx->have_surface = TRUE; /* Init vertex and fragment GLSL shaders. * Note: Shader compiler support is optional but we currently rely on it. */ glGetBooleanv (GL_SHADER_COMPILER, &ret); if (ret == GL_FALSE) { GST_ERROR_OBJECT (ctx->element, "Shader compiler support is unavailable!"); goto HANDLE_ERROR; } /* Build shader program for video texture rendering */ switch (format) { case GST_VIDEO_FORMAT_AYUV: frag_prog = (gchar *) frag_AYUV_prog; free_frag_prog = FALSE; ctx->n_textures = 1; texnames[0] = "tex"; break; case GST_VIDEO_FORMAT_Y444: case GST_VIDEO_FORMAT_I420: case GST_VIDEO_FORMAT_YV12: case GST_VIDEO_FORMAT_Y42B: case GST_VIDEO_FORMAT_Y41B: frag_prog = (gchar *) frag_PLANAR_YUV_prog; free_frag_prog = FALSE; ctx->n_textures = 3; texnames[0] = "Ytex"; texnames[1] = "Utex"; texnames[2] = "Vtex"; break; case GST_VIDEO_FORMAT_YUY2: frag_prog = g_strdup_printf (frag_YUY2_YVYU_UYVY_prog, 'r', 'g', 'a'); free_frag_prog = TRUE; ctx->n_textures = 2; texnames[0] = "Ytex"; texnames[1] = "UVtex"; break; case GST_VIDEO_FORMAT_YVYU: frag_prog = g_strdup_printf (frag_YUY2_YVYU_UYVY_prog, 'r', 'a', 'g'); free_frag_prog = TRUE; ctx->n_textures = 2; texnames[0] = "Ytex"; texnames[1] = "UVtex"; break; case GST_VIDEO_FORMAT_UYVY: frag_prog = g_strdup_printf (frag_YUY2_YVYU_UYVY_prog, 'a', 'r', 'b'); free_frag_prog = TRUE; ctx->n_textures = 2; texnames[0] = "Ytex"; texnames[1] = "UVtex"; break; case GST_VIDEO_FORMAT_NV12: frag_prog = g_strdup_printf (frag_NV12_NV21_prog, 'r', 'a'); free_frag_prog = TRUE; ctx->n_textures = 2; texnames[0] = "Ytex"; texnames[1] = "UVtex"; break; case GST_VIDEO_FORMAT_NV21: frag_prog = g_strdup_printf (frag_NV12_NV21_prog, 'a', 'r'); free_frag_prog = TRUE; ctx->n_textures = 2; texnames[0] = "Ytex"; texnames[1] = "UVtex"; break; case GST_VIDEO_FORMAT_BGR: case GST_VIDEO_FORMAT_BGRx: case GST_VIDEO_FORMAT_BGRA: frag_prog = g_strdup_printf (frag_REORDER_prog, 'b', 'g', 'r'); free_frag_prog = TRUE; ctx->n_textures = 1; texnames[0] = "tex"; break; case GST_VIDEO_FORMAT_xRGB: case GST_VIDEO_FORMAT_ARGB: frag_prog = g_strdup_printf (frag_REORDER_prog, 'g', 'b', 'a'); free_frag_prog = TRUE; ctx->n_textures = 1; texnames[0] = "tex"; break; case GST_VIDEO_FORMAT_xBGR: case GST_VIDEO_FORMAT_ABGR: frag_prog = g_strdup_printf (frag_REORDER_prog, 'a', 'b', 'g'); free_frag_prog = TRUE; ctx->n_textures = 1; texnames[0] = "tex"; break; case GST_VIDEO_FORMAT_RGB: case GST_VIDEO_FORMAT_RGBx: case GST_VIDEO_FORMAT_RGBA: case GST_VIDEO_FORMAT_RGB16: frag_prog = (gchar *) frag_COPY_prog; free_frag_prog = FALSE; ctx->n_textures = 1; texnames[0] = "tex"; break; default: g_assert_not_reached (); break; } if (!create_shader_program (ctx, &ctx->glslprogram[0], &ctx->vertshader[0], &ctx->fragshader[0], vert_COPY_prog, frag_prog)) { if (free_frag_prog) g_free (frag_prog); frag_prog = NULL; goto HANDLE_ERROR; } if (free_frag_prog) g_free (frag_prog); frag_prog = NULL; ctx->position_loc[0] = glGetAttribLocation (ctx->glslprogram[0], "position"); ctx->texpos_loc[0] = glGetAttribLocation (ctx->glslprogram[0], "texpos"); glEnableVertexAttribArray (ctx->position_loc[0]); if (got_gl_error ("glEnableVertexAttribArray")) goto HANDLE_ERROR; glEnableVertexAttribArray (ctx->texpos_loc[0]); if (got_gl_error ("glEnableVertexAttribArray")) goto HANDLE_ERROR; for (i = 0; i < ctx->n_textures; i++) { ctx->tex_loc[0][i] = glGetUniformLocation (ctx->glslprogram[0], texnames[i]); } if (!ctx->buffer_preserved) { /* Build shader program for black borders */ if (!create_shader_program (ctx, &ctx->glslprogram[1], &ctx->vertshader[1], &ctx->fragshader[1], vert_COPY_prog_no_tex, frag_BLACK_prog)) goto HANDLE_ERROR; ctx->position_loc[1] = glGetAttribLocation (ctx->glslprogram[1], "position"); glEnableVertexAttribArray (ctx->position_loc[1]); if (got_gl_error ("glEnableVertexAttribArray")) goto HANDLE_ERROR; } /* Generate textures */ if (!ctx->have_texture) { GST_INFO_OBJECT (ctx->element, "Performing initial texture setup"); glGenTextures (ctx->n_textures, ctx->texture); if (got_gl_error ("glGenTextures")) goto HANDLE_ERROR_LOCKED; for (i = 0; i < ctx->n_textures; i++) { glBindTexture (GL_TEXTURE_2D, ctx->texture[i]); if (got_gl_error ("glBindTexture")) goto HANDLE_ERROR; /* Set 2D resizing params */ glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); /* If these are not set the texture image unit will return * (R, G, B, A) = black on glTexImage2D for non-POT width/height * frames. For a deeper explanation take a look at the OpenGL ES * documentation for glTexParameter */ glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); if (got_gl_error ("glTexParameteri")) goto HANDLE_ERROR_LOCKED; } ctx->have_texture = TRUE; } glUseProgram (0); return TRUE; /* Errors */ HANDLE_ERROR_LOCKED: HANDLE_ERROR: GST_ERROR_OBJECT (ctx->element, "Couldn't setup EGL surface"); return FALSE; }
void nullspace_init(void) { GLint vs = create_shader(GL_VERTEX_SHADER, vs_src); GLint fs = create_shader(GL_FRAGMENT_SHADER, fs_src); shdr_prog = create_shader_program(2, vs, fs); glDeleteShader(vs); glDeleteShader(fs); glGenVertexArrays(1, &vtx_arr); glGenBuffers(1, &vtx_buf); glBindVertexArray(vtx_arr); { glBindBuffer(GL_ARRAY_BUFFER, vtx_buf); { glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec4) * num_verts, NULL, GL_STATIC_DRAW); glm::vec4 *ptr = (glm::vec4 *)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); if (!ptr) { fprintf(stderr, "ERROR: failed to map null-space vertex buffer\n"); exit(1); } // grid (GL_LINES) size_t idx = 0; for (int i = -sz; i < sz; ++i) { ptr[idx++] = glm::vec4(-sz, 0, i, 1); ptr[idx++] = glm::vec4(sz, 0, i, 1); ptr[idx++] = glm::vec4(i, 0, -sz, 1); ptr[idx++] = glm::vec4(i, 0, sz, 1); } // border line (GL_LINE_LOOP) ptr[idx++] = glm::vec4(-sz, 0, -sz, 1); ptr[idx++] = glm::vec4(-sz, 0, sz, 1); ptr[idx++] = glm::vec4(sz, 0, sz, 1); ptr[idx++] = glm::vec4(-sz, 0, sz, 1); /* axis lines (GL_LINES)*/ // x-axis ptr[idx++] = glm::vec4(-sz, 0, 0, 1); ptr[idx++] = glm::vec4(sz, 0, 0, 1); // y-axis ptr[idx++] = glm::vec4(0, sz, 0, 1); ptr[idx++] = glm::vec4(0, 0, 0, 1); // z-axis ptr[idx++] = glm::vec4(0, 0, -sz, 1); ptr[idx++] = glm::vec4(0, 0, sz, 1); GLboolean result = glUnmapBuffer(GL_ARRAY_BUFFER); if (!result) { fprintf(stderr, "ERROR: failed to unmap null-space vertex buffer\n"); exit(1); } ptr = NULL; glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL); } glBindVertexArray(0); } glBindBuffer(GL_ARRAY_BUFFER, 0); // buffer lookup offsets upon render size_t offset = 0; for (uint32_t i(0); i < num_draw_arrays; ++i) { draw_array_t *draw_array = &draw_arrays[i]; draw_array->first = offset; offset += draw_array->count; } }