Compiler/AM4379: OpenGL question

Hello,

GLES and GLES2 folder could be allocated in ti-processor-sdk-linux-am57xx-evm-04.03.00.05/linux-devkit/sysroots/armv7ahf-neon-linux-gnueabi/usr/include gl.h and gl2.h are in there.
I would recommend you to check this guide for more information:
processors.wiki.ti.com/.../Processor_Linux_SDK_Graphics_and_Display
Per my understanding you wanna use gl.h and gl2.h together right?

BR
Margarita

Hello Margarita,

Thank you for your response. I could locate the GLES and GLES2 folders.Yes you are right. I wanna use gl.h and gl2.h together in the same code. Kindly let me know how that can be done. 

I just included the gl.h and gl2.h headers in my code. Tried to compile my code using the following compilation command: 

arm-linuxgnueabihf-gcc circle.c -o circle -lEGL -lGLES -lGLESv2 -lwayland-client -lwayland-cursor -lpvr_wlegl -lm

I get an error message that gl.h not found. No such file or directory. Whereas I can locate gl.h using the 'locate' command on linux terminal. Kindly help. Thank you.

Hello Margarita,

Thank you for your patience. I went through the links but unfortunately I could not find anything that would solve my problem. Please kindly guide me further. I want to use OpenGL ES 1 and OpenGL ES 2 simultaneously in my processor SDK version 04.02.00.09 AM4379 evm. Thanks in advance.

Hello Margarita,

I will definitely check the link which you have shared.

Following is the code that I am working on:

/*
 * Copyright © 2011 Benjamin Franzke
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#include <assert.h>
#include <signal.h>

#include <linux/input.h>

#include <wayland-client.h>
#include <wayland-client-core.h>
#include <wayland-egl-core.h>
#include <wayland-egl.h>
#include <wayland-cursor.h>

#include <GLES2/gl2.h>
#include <GLES/gl.h>
#include <EGL/egl.h>


int ROTATION;
struct window;
struct seat;

struct display {
    struct wl_display *display;
    struct wl_registry *registry;
    struct wl_compositor *compositor;
    struct wl_shell *shell;
    struct wl_seat *seat;
    struct wl_pointer *pointer;
    struct wl_keyboard *keyboard;
    struct wl_shm *shm;
    struct wl_cursor_theme *cursor_theme;
    struct wl_cursor *default_cursor;
    struct wl_surface *cursor_surface;
    struct {
        EGLDisplay dpy;
        EGLContext ctx;
        EGLConfig conf;
    } egl;
    struct window *window;
};

struct geometry {
    int width, height;
};

struct window {
    struct display *display;
    struct geometry geometry, window_size;
    struct {
        GLuint rotation_uniform;
        GLuint pos;
        GLuint col;
    } gl;

    struct wl_egl_window *native;
    struct wl_surface *surface;
    struct wl_shell_surface *shell_surface;
    EGLSurface egl_surface;
    struct wl_callback *callback;
    int fullscreen, configured, rotation, transparent;
};

static const char *vert_shader_text =
    "uniform mat4 rotation;\n"
    "uniform vec4 pos;\n"
    "uniform vec4 color;\n"
    "varying vec4 v_color;\n"
    "void main() {\n"
    "  gl_Position = rotation * pos;\n"
    "  v_color = color;\n"
    "}\n";

static const char *frag_shader_text =
    "precision mediump float;\n"
    "varying vec4 v_color;\n"
    "void main() {\n"
    "  gl_FragColor = v_color;\n"
    "}\n";

static int running = 1;

static void
init_egl(struct display *display, int transparent)
{
    static const EGLint context_attribs[] = {
        EGL_CONTEXT_CLIENT_VERSION, 2,
        EGL_NONE
    };

    EGLint config_attribs[] = {
        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
        EGL_RED_SIZE, 1,
        EGL_GREEN_SIZE, 1,
        EGL_BLUE_SIZE, 1,
        EGL_ALPHA_SIZE, 1,
        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
        EGL_NONE
    };

    EGLint major, minor, n;
    EGLBoolean ret;

    if (!transparent)
        config_attribs[9] = 0;

    display->egl.dpy = eglGetDisplay(display->display);
    assert(display->egl.dpy);

    ret = eglInitialize(display->egl.dpy, &major, &minor);
    assert(ret == EGL_TRUE);
    ret = eglBindAPI(EGL_OPENGL_ES_API);
    assert(ret == EGL_TRUE);

    ret = eglChooseConfig(display->egl.dpy, config_attribs,
                  &display->egl.conf, 1, &n);
    assert(ret && n == 1);

    display->egl.ctx = eglCreateContext(display->egl.dpy,
                        display->egl.conf,
                        EGL_NO_CONTEXT, context_attribs);
    assert(display->egl.ctx);

}

static void
fini_egl(struct display *display)
{
    /* Required, otherwise segfault in egl_dri2.c: dri2_make_current()
     * on eglReleaseThread(). */
    eglMakeCurrent(display->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE,
               EGL_NO_CONTEXT);

    eglTerminate(display->egl.dpy);
    eglReleaseThread();
}

static GLuint
create_shader(struct window *window, const char *source, GLenum shader_type)
{
    GLuint shader;
    GLint status;

    shader = glCreateShader(shader_type);
    assert(shader != 0);

    glShaderSource(shader, 1, (const char **) &source, NULL);
    glCompileShader(shader);

    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
    if (!status) {
        char log[1000];
        GLsizei len;
        glGetShaderInfoLog(shader, 1000, &len, log);
        fprintf(stderr, "Error: compiling %s: %*s\n",
            shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment",
            len, log);
        exit(1);
    }

    return shader;
}

static void
init_gl(struct window *window)
{
    GLuint frag, vert;
    GLuint program;
    GLint status;

    frag = create_shader(window, frag_shader_text, GL_FRAGMENT_SHADER);
    vert = create_shader(window, vert_shader_text, GL_VERTEX_SHADER);

    program = glCreateProgram();
    glAttachShader(program, frag);
    glAttachShader(program, vert);
    glLinkProgram(program);

    glGetProgramiv(program, GL_LINK_STATUS, &status);
    if (!status) {
        char log[1000];
        GLsizei len;
        glGetProgramInfoLog(program, 1000, &len, log);
        fprintf(stderr, "Error: linking:\n%*s\n", len, log);
        exit(1);
    }

    glUseProgram(program);
    
    window->gl.pos = 0;
    window->gl.col = 1;

    glBindAttribLocation(program, window->gl.pos, "pos");
    glBindAttribLocation(program, window->gl.col, "color");
    glLinkProgram(program);

    window->gl.rotation_uniform =
        glGetUniformLocation(program, "rotation");
    
    
}

static void
handle_ping(void *data, struct wl_shell_surface *shell_surface,
        uint32_t serial)
{
    wl_shell_surface_pong(shell_surface, serial);
}

static void
handle_configure(void *data, struct wl_shell_surface *shell_surface,
         uint32_t edges, int32_t width, int32_t height)
{
    struct window *window = data;

    if (window->native)
        wl_egl_window_resize(window->native, width, height, 0, 0);

    window->geometry.width = width;
    window->geometry.height = height;

    if (!window->fullscreen)
        window->window_size = window->geometry;
}

static void
handle_popup_done(void *data, struct wl_shell_surface *shell_surface)
{
}

static const struct wl_shell_surface_listener shell_surface_listener = {
    handle_ping,
    handle_configure,
    handle_popup_done
};

static void
redraw(void *data, struct wl_callback *callback, uint32_t time);

static void
configure_callback(void *data, struct wl_callback *callback, uint32_t  time)
{
    struct window *window = data;

    wl_callback_destroy(callback);

    window->configured = 1;

    if (window->callback == NULL)
        redraw(data, NULL, time);
}

static struct wl_callback_listener configure_callback_listener = {
    configure_callback,
};

static void
toggle_fullscreen(struct window *window, int fullscreen)
{
    struct wl_callback *callback;

    window->fullscreen = fullscreen;
    window->configured = 0;

    if (fullscreen) {
        wl_shell_surface_set_fullscreen(window->shell_surface,
                        WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
                        0, NULL);
    } else {
        wl_shell_surface_set_toplevel(window->shell_surface);
        handle_configure(window, window->shell_surface, 0,
                 window->window_size.width,
                 window->window_size.height);
    }

    callback = wl_display_sync(window->display->display);
    wl_callback_add_listener(callback, &configure_callback_listener,
                 window);
}

static void
create_surface(struct window *window)
{
    struct display *display = window->display;
    EGLBoolean ret;
    
    window->surface = wl_compositor_create_surface(display->compositor);
    window->shell_surface = wl_shell_get_shell_surface(display->shell,
                               window->surface);

    wl_shell_surface_add_listener(window->shell_surface,
                      &shell_surface_listener, window);

    window->native =
        wl_egl_window_create(window->surface,
                     window->window_size.width,
                     window->window_size.height);
    window->egl_surface =
        eglCreateWindowSurface(display->egl.dpy,
                       display->egl.conf,
                       window->native, NULL);

    wl_shell_surface_set_title(window->shell_surface, "simple-egl");

    ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface,
                 window->egl_surface, window->display->egl.ctx);
    assert(ret == EGL_TRUE);

    toggle_fullscreen(window, window->fullscreen);
}

static void
destroy_surface(struct window *window)
{
    wl_egl_window_destroy(window->native);

    wl_shell_surface_destroy(window->shell_surface);
    wl_surface_destroy(window->surface);

    if (window->callback)
        wl_callback_destroy(window->callback);
}

static const struct wl_callback_listener frame_listener;

static void
redraw(void *data, struct wl_callback *callback, uint32_t time)
{
    struct window *window = data;
    static const GLfloat verts[4][2] = {
        { 0.0, 0.0 },
        { -0.5,0.0 },
        {  -0.5,  0.5 },
        { 0.0,  0.5 }
    };
    static const GLfloat colors[3][3] = {
        { 1, 0, 1 },
        { 0, 1, 0 },
        { 1, 0, 1 }
    };
    GLfloat angle;
    GLfloat rotation[4][4] = {
        { 1, 0, 0, 0 },
        { 0, 1, 0, 0 },
        { 0, 0, 1, 0 },
        { 0, 0, 0, 1 }
    };

    static const GLfloat colors1[3][3] = {
        { 1, 0 ,0 },
        { 1, 0, 0 },
        { 1, 0, 0 }
    };
    
    GLfloat a,h=0.25,b,k=-0.25;
    GLfloat r=0.25;
    
    int i, j,index=0;
    
    static GLfloat circle[72][2];
    
    for(i=0; i<360; i+=5)
    {
    
    a=(float)(r*cos(2*i*M_PI/180));
        
    b=(float)(r*sin(2*i*M_PI/180));

    circle[index][0]=a+h;
    circle[index][1]=b+k;
    index++;
    }
    
    

    

    static const int32_t speed_div = 5;
    static uint32_t start_time = 0;
    struct wl_region *region;

    assert(window->callback == callback);
    window->callback = NULL;

    if (callback)
        wl_callback_destroy(callback);

    if (!window->configured)
        return;

    if (start_time == 0)
        start_time = time;


    if(window->rotation){
        angle = ((time-start_time) / speed_div) % 360 * M_PI / 180.0;
        rotation[0][0] =  cos(angle);
        rotation[0][2] =  sin(angle);
        rotation[2][0] = -sin(angle);
        rotation[2][2] =  cos(angle);
    }

    glViewport(0, 0, window->geometry.width, window->geometry.height);

    glUniformMatrix4fv(window->gl.rotation_uniform, 1, GL_FALSE,
               (GLfloat *) rotation);

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);
    
    
    
    glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_TRUE, 0, colors1);
    glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_TRUE, 0, circle);
    glEnableVertexAttribArray(window->gl.pos);
    glEnableVertexAttribArray(window->gl.col);
    glDrawArrays(GL_TRIANGLE_FAN, 0,72);
    glDisableVertexAttribArray(window->gl.pos);
    glDisableVertexAttribArray(window->gl.col);


    glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_FALSE, 0, verts);
    glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_FALSE, 0, colors);
    glEnableVertexAttribArray(window->gl.pos);
    glEnableVertexAttribArray(window->gl.col);

    glDrawArrays(GL_TRIANGLES, 0, 4);

    glDisableVertexAttribArray(window->gl.pos);
    glDisableVertexAttribArray(window->gl.col);

    if (! window->transparent) {
        region = wl_compositor_create_region(window->display->compositor);
        wl_region_add(region, 0, 0,
                  window->geometry.width,
                  window->geometry.height);
        wl_surface_set_opaque_region(window->surface, region);
        wl_region_destroy(region);
    } else {
        wl_surface_set_opaque_region(window->surface, NULL);
    }

    window->callback = wl_surface_frame(window->surface);
    wl_callback_add_listener(window->callback, &frame_listener, window);

    eglSwapBuffers(window->display->egl.dpy, window->egl_surface);
}

static const struct wl_callback_listener frame_listener = {
    redraw
};

static void
pointer_handle_enter(void *data, struct wl_pointer *pointer,
             uint32_t serial, struct wl_surface *surface,
             wl_fixed_t sx, wl_fixed_t sy)
{
    struct display *display = data;
    struct wl_buffer *buffer;
    struct wl_cursor *cursor = display->default_cursor;
    struct wl_cursor_image *image;

    if (display->window->fullscreen)
        wl_pointer_set_cursor(pointer, serial, NULL, 0, 0);
    else if (cursor) {
        image = display->default_cursor->images[0];
        buffer = wl_cursor_image_get_buffer(image);
        wl_pointer_set_cursor(pointer, serial,
                      display->cursor_surface,
                      image->hotspot_x,
                      image->hotspot_y);
        wl_surface_attach(display->cursor_surface, buffer, 0, 0);
        wl_surface_damage(display->cursor_surface, 0, 0,
                  image->width, image->height);
        wl_surface_commit(display->cursor_surface);
    }
}

static void
pointer_handle_leave(void *data, struct wl_pointer *pointer,
             uint32_t serial, struct wl_surface *surface)
{
}

static void
pointer_handle_motion(void *data, struct wl_pointer *pointer,
              uint32_t time, wl_fixed_t sx, wl_fixed_t sy)
{
}

static void
pointer_handle_button(void *data, struct wl_pointer *wl_pointer,
              uint32_t serial, uint32_t time, uint32_t button,
              uint32_t state)
{
    struct display *display = data;

    if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED)
        wl_shell_surface_move(display->window->shell_surface,
                      display->seat, serial);
}

static void
pointer_handle_axis(void *data, struct wl_pointer *wl_pointer,
            uint32_t time, uint32_t axis, wl_fixed_t value)
{
}

static const struct wl_pointer_listener pointer_listener = {
    pointer_handle_enter,
    pointer_handle_leave,
    pointer_handle_motion,
    pointer_handle_button,
    pointer_handle_axis,
};

static void
keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
               uint32_t format, int fd, uint32_t size)
{
}

static void
keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
              uint32_t serial, struct wl_surface *surface,
              struct wl_array *keys)
{
}

static void
keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
              uint32_t serial, struct wl_surface *surface)
{
}

static void
keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
            uint32_t serial, uint32_t time, uint32_t key,
            uint32_t state)
{
    struct display *d = data;

    if (key == KEY_F11 && state)
        toggle_fullscreen(d->window, d->window->fullscreen ^ 1);
    else if (key == KEY_ESC && state)
        running = 0;
}

static void
keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
              uint32_t serial, uint32_t mods_depressed,
              uint32_t mods_latched, uint32_t mods_locked,
              uint32_t group)
{
}

static const struct wl_keyboard_listener keyboard_listener = {
    keyboard_handle_keymap,
    keyboard_handle_enter,
    keyboard_handle_leave,
    keyboard_handle_key,
    keyboard_handle_modifiers,
};

static void
seat_handle_capabilities(void *data, struct wl_seat *seat,
             enum wl_seat_capability caps)
{
    struct display *d = data;

    if ((caps & WL_SEAT_CAPABILITY_POINTER) && !d->pointer) {
        d->pointer = wl_seat_get_pointer(seat);
        wl_pointer_add_listener(d->pointer, &pointer_listener, d);
    } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && d->pointer) {
        wl_pointer_destroy(d->pointer);
        d->pointer = NULL;
    }

    if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !d->keyboard) {
        d->keyboard = wl_seat_get_keyboard(seat);
        wl_keyboard_add_listener(d->keyboard, &keyboard_listener, d);
    } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && d->keyboard) {
        wl_keyboard_destroy(d->keyboard);
        d->keyboard = NULL;
    }
}

static const struct wl_seat_listener seat_listener = {
    seat_handle_capabilities,
};

static void
registry_handle_global(void *data, struct wl_registry *registry,
               uint32_t name, const char *interface, uint32_t version)
{
    struct display *d = data;

    if (strcmp(interface, "wl_compositor") == 0) {
        d->compositor =
            wl_registry_bind(registry, name,
                     &wl_compositor_interface, 1);
    } else if (strcmp(interface, "wl_shell") == 0) {
        d->shell = wl_registry_bind(registry, name,
                        &wl_shell_interface, 1);
    } else if (strcmp(interface, "wl_seat") == 0) {
        d->seat = wl_registry_bind(registry, name,
                       &wl_seat_interface, 1);
        wl_seat_add_listener(d->seat, &seat_listener, d);
    } else if (strcmp(interface, "wl_shm") == 0) {
        d->shm = wl_registry_bind(registry, name,
                      &wl_shm_interface, 1);
        d->cursor_theme = wl_cursor_theme_load(NULL, 32, d->shm);
        d->default_cursor =
            wl_cursor_theme_get_cursor(d->cursor_theme, "left_ptr");
    }
}

static void
registry_handle_global_remove(void *data, struct wl_registry *registry,
                  uint32_t name)
{
}

static const struct wl_registry_listener registry_listener = {
    registry_handle_global,
    registry_handle_global_remove
};

static void
signal_int(int signum)
{
    running = 0;
}

static void
usage(int error_code)
{
    fprintf(stderr, "Usage: simple-egl [OPTIONS]\n\n"
        "  -f\tRun in fullscreen mode\n"
        "  -t\tCreate an transparent surface\n"
        "  -r\tCreate a rotating traingle\n"
        "  -h\tThis help text\n\n");

    exit(error_code);
}

int
main(int argc, char **argv)
{
    struct sigaction sigint;
    struct display display = { 0 };
    struct window  window  = { 0 };
    int i, ret = 0;

    window.display = &display;
    display.window = &window;
    window.window_size.width  = 480;
    window.window_size.height = 480;

    for (i = 1; i < argc; i++) {
        if (strcmp("-f", argv[i]) == 0)
            window.fullscreen = 1;
        else if (strcmp("-t", argv[i]) == 0)
            window.transparent = 1;
        else if (strcmp("-r", argv[i]) == 0)
            window.rotation = 1;
        else if (strcmp("-h", argv[i]) == 0)
            usage(EXIT_SUCCESS);
        else
            usage(EXIT_FAILURE);
    }

    display.display = wl_display_connect(NULL);
    assert(display.display);

    display.registry = wl_display_get_registry(display.display);
    wl_registry_add_listener(display.registry,
                 &registry_listener, &display);

    wl_display_dispatch(display.display);

    init_egl(&display, window.transparent);
    create_surface(&window);
    init_gl(&window);

    display.cursor_surface =
        wl_compositor_create_surface(display.compositor);

    sigint.sa_handler = signal_int;
    sigemptyset(&sigint.sa_mask);
    sigint.sa_flags = SA_RESETHAND;
    sigaction(SIGINT, &sigint, NULL);

    while (running && ret != -1)
        ret = wl_display_dispatch(display.display);

    fprintf(stderr, "simple-egl exiting\n");

    destroy_surface(&window);
    fini_egl(&display);

    wl_surface_destroy(display.cursor_surface);
    if (display.cursor_theme)
        wl_cursor_theme_destroy(display.cursor_theme);

    if (display.shell)
        wl_shell_destroy(display.shell);

    if (display.compositor)
        wl_compositor_destroy(display.compositor);

    wl_registry_destroy(display.registry);
wl_display_flush(display.display);
    wl_display_disconnect(display.display);

    return 0;
}

I am facing problems with drawing filled geometric primitives like circle and square. I do want the colour shading effect. I want solid colour filled geometric primitives. The reason behind looking to use OpenGL ES 1 and OpenGL ES 2 simultaneously is to use glShadeModel function defined in gl.h which enables me to chose between Flat and smooth shading thus allowing me to obtain solid coloured geometric primitives. There are also other built in functions defined in OpenGL ES 1, which I would like to use. I tried editing the vertex and fragment shaders with no success. Do you have knowledge about obtaining solid colour filled geometric primitives. Please guide me further. Thank you in advance.

Best Regards,

Pratiksha.