static EglDisplay *
egl_display_new_full (gpointer handle, gboolean is_wrapped)
{
EglDisplay *display;
display = egl_object_new0 (egl_display_class ());
if (!display)
return NULL;
display->base.handle.p = handle;
display->base.is_wrapped = is_wrapped;
if (!egl_display_init (display))
goto error;
return display;
/* ERRORS */
error:
{
egl_object_unref (display);
return NULL;
}
}
int
main(int argc, char *argv[])
{
EGLDisplay display;
EGLSurface surface;
GLuint vertex_shader;
GLuint fragment_shader;
GLuint program;
GLint ret;
GLint width, height;
GLuint texture;
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_coord; \n"
"\n"
"vec4 lightSource = vec4(10.0, 20.0, 40.0, 0.0);\n"
" \n"
"varying vec4 vVaryingColor; \n"
"varying vec2 coord; \n"
" \n"
"void main() \n"
"{ \n"
" gl_Position = modelviewprojectionMatrix * in_position;\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"
" vVaryingColor = vec4(diff * vec3(1.0, 1.0, 1.0), 1.0);\n"
" coord = in_coord; \n"
"} \n";
const char *fragment_shader_source =
"precision mediump float; \n"
" \n"
"varying vec4 vVaryingColor; \n"
"varying vec2 coord; \n"
" \n"
"uniform sampler2D in_texture; \n"
" \n"
"void main() \n"
"{ \n"
" gl_FragColor = vVaryingColor * texture2D(in_texture, coord);\n"
"} \n";
buffer_size(&width, &height);
printf("Buffer dimensions %dx%d\n", width, height);
float aspect = (float) height / width;
display = egl_display_init();
surface = egl_surface_init(display, 2, width, height);
glViewport(0, 0, width, height);
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
vertex_shader = vertex_shader_compile(vertex_shader_source);
fragment_shader = fragment_shader_compile(fragment_shader_source);
program = glCreateProgram();
if (!program) {
printf("Error: failed to create program!\n");
return -1;
}
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glBindAttribLocation(program, 0, "in_position");
glBindAttribLocation(program, 1, "in_normal");
glBindAttribLocation(program, 2, "in_coord");
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;
}
glUseProgram(program);
unsigned int vertices_buffer;
glGenBuffers(1, &vertices_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertices_buffer);
glBufferData(GL_ARRAY_BUFFER, 4 * 3 * COMPANION_VERTEX_COUNT,
companion_vertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
unsigned int normals_buffer;
glGenBuffers(1, &normals_buffer);
glBindBuffer(GL_ARRAY_BUFFER, normals_buffer);
glBufferData(GL_ARRAY_BUFFER, 4 * 3 * COMPANION_VERTEX_COUNT,
companion_normals, GL_STATIC_DRAW);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
unsigned int texture_coordinates_buffer;
glGenBuffers(1, &texture_coordinates_buffer);
glBindBuffer(GL_ARRAY_BUFFER, texture_coordinates_buffer);
glBufferData(GL_ARRAY_BUFFER, 4 * 3 * COMPANION_VERTEX_COUNT,
companion_texture_coordinates, GL_STATIC_DRAW);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0);
unsigned int elements_buffer;
glGenBuffers(1, &elements_buffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elements_buffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4 * COMPANION_INDEX_COUNT,
companion_triangles, GL_STATIC_DRAW);
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
COMPANION_TEXTURE_WIDTH, COMPANION_TEXTURE_HEIGHT, 0,
GL_RGB, GL_UNSIGNED_BYTE, companion_texture);
GLint texture_loc = glGetUniformLocation(program, "in_texture");
glUniform1i(texture_loc, 0); // 0 -> GL_TEXTURE0 in glActiveTexture
ESMatrix modelview;
esMatrixLoadIdentity(&modelview);
esTranslate(&modelview, 0.0, 0.0, -4.0);
esRotate(&modelview, -30.0, 1.0, 0.0, 0.0);
esRotate(&modelview, -45.0, 0.0, 1.0, 0.0);
ESMatrix projection;
esMatrixLoadIdentity(&projection);
esFrustum(&projection, -1.0, +1.0, -1.0 * aspect, +1.0 * aspect,
1.0, 10.0);
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");
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);
glDrawElements(GL_TRIANGLES, COMPANION_INDEX_COUNT,
GL_UNSIGNED_SHORT, NULL);
eglSwapBuffers(display, surface);
usleep(1000000);
fflush(stdout);
return 0;
}
int
main(int argc, char *argv[])
{
EGLDisplay display;
EGLSurface surface;
GLuint vertex_shader;
GLuint fragment_shader;
GLuint program;
GLint ret;
GLint width, height;
GLuint texture;
const char* vertex_shader_source =
"attribute vec4 in_vertex;\n"
"attribute vec2 in_coord;\n"
"\n"
"varying vec2 coord;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = in_vertex;\n"
" coord = in_coord;\n"
"}\n";
const char* fragment_shader_source =
"precision mediump float;\n"
"\n"
"varying vec2 coord;\n"
"\n"
"uniform sampler2D in_texture;\n"
"\n"
"void main()\n"
"{\n"
" gl_FragColor = texture2D(in_texture, coord);\n"
"}\n";
const GLfloat aVertices[4][3] = {
{-0.6, -1, 0},
{ 0.6, -1, 0},
{-0.6, 1, 0},
{ 0.6, 1, 0}
};
const GLfloat aCoords[4][2] = {
{0, 1},
{1, 1},
{0, 0},
{1, 0}
};
buffer_size(&width, &height);
printf("Buffer dimensions %dx%d\n", width, height);
display = egl_display_init();
surface = egl_surface_init(display, 2, width, height);
glViewport(0, 0, width, height);
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
vertex_shader = vertex_shader_compile(vertex_shader_source);
fragment_shader = fragment_shader_compile(fragment_shader_source);
program = glCreateProgram();
if (!program) {
printf("Error: failed to create program!\n");
return -1;
}
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glBindAttribLocation(program, 0, "in_vertex");
glBindAttribLocation(program, 1, "in_coord");
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;
}
glUseProgram(program);
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
COMPANION_TEXTURE_WIDTH, COMPANION_TEXTURE_HEIGHT, 0,
GL_RGB, GL_UNSIGNED_BYTE, companion_texture_flat);
//glGenerateMipmap(GL_TEXTURE_2D);
GLint texture_loc = glGetUniformLocation(program, "in_texture");
glUniform1i(texture_loc, 0); // 0 -> GL_TEXTURE0 in glActiveTexture
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, aVertices);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, aCoords);
glEnableVertexAttribArray(1);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
eglSwapBuffers(display, surface);
usleep(1000000);
fflush(stdout);
return 0;
}
int
main(int argc, char *argv[])
{
EGLDisplay display;
EGLSurface surface;
GLuint vertex_shader;
GLuint fragment_shader;
GLuint program;
GLint ret;
GLint width, height;
const char *vertex_shader_source =
"attribute vec4 aPosition; \n"
" \n"
"void main() \n"
"{ \n"
" gl_Position = aPosition; \n"
"} \n";
const char *fragment_shader_source =
"precision mediump float; \n"
" \n"
"uniform vec4 uColor; \n"
" \n"
"void main() \n"
"{ \n"
" gl_FragColor = uColor; \n"
"} \n";
GLfloat vVertices[] = {-0.45, -0.75, 0.0,
0.45, -0.75, 0.0,
-0.45, 0.75, 0.0,
0.45, 0.75, 0.0};
GLfloat uColor[] = {1.0, 0.0, 0.0, 1.0};
buffer_size(&width, &height);
printf("Buffer dimensions %dx%d\n", width, height);
display = egl_display_init();
surface = egl_surface_init(display, 2, width, height);
glViewport(0, 0, width, height);
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
vertex_shader = vertex_shader_compile(vertex_shader_source);
fragment_shader = fragment_shader_compile(fragment_shader_source);
program = glCreateProgram();
if (!program) {
printf("Error: failed to create program!\n");
return -1;
}
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glBindAttribLocation(program, 0, "aPosition");
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;
}
glUseProgram(program);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
glEnableVertexAttribArray(0);
int location = glGetUniformLocation(program, "uColor");
glUniform4fv(location, 1, uColor);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
eglSwapBuffers(display, surface);
usleep(1000000);
fflush(stdout);
return 0;
}
