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;
}
}
