wearable/src/examples/glview_example_01.c

   1 /**
   2  * Simple Elementary's <b>GLView widget</b> example, illustrating its
   3  * creation.
   4  *
   5  * See stdout/stderr for output. Compile with:
   6  *
   7  * @verbatim
   8  * gcc -o glview_example_01 glview_example_01.c -g `pkg-config --cflags --libs elementary`
   9  * @endverbatim
  10  */
  11 #include <Elementary.h>
  12 #include <Evas_GL.h>
  13 #include <stdio.h>
  14
  15 typedef struct _GLData GLData;
  16
  17 // GL related data here..
  18 struct _GLData
  19 {
  20    Evas_GL_API *glapi;
  21    GLuint       program;
  22    GLuint       vtx_shader;
  23    GLuint       fgmt_shader;
  24    GLuint       vbo;
  25    int          initialized : 1;
  26 };
  27
  28 static float red = 1.0;
  29
  30 //--------------------------------//
  31 // a helper function to load shaders from a shader source
  32 static GLuint
  33 load_shader( GLData *gld, GLenum type, const char *shader_src )
  34 {
  35    Evas_GL_API *gl = gld->glapi;
  36    GLuint shader;
  37    GLint compiled;
  38
  39    // Create the shader object
  40    shader = gl->glCreateShader(type);
  41    if (shader==0)
  42       return 0;
  43
  44    // Load/Compile shader source
  45    gl->glShaderSource(shader, 1, &shader_src, NULL);
  46    gl->glCompileShader(shader);
  47    gl->glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
  48
  49    if (!compiled)
  50      {
  51         GLint info_len = 0;
  52         gl->glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_len);
  53         if (info_len > 1)
  54           {
  55              char* info_log = malloc(sizeof(char) * info_len);
  56
  57              gl->glGetShaderInfoLog(shader, info_len, NULL, info_log);
  58              printf("Error compiling shader:\n%s\n======\n%s\n======\n", info_log, shader_src );
  59              free(info_log);
  60           }
  61         gl->glDeleteShader(shader);
  62         return 0;
  63      }
  64
  65    return shader;
  66 }
  67
  68 // Initialize the shader and program object
  69 static int
  70 init_shaders(GLData *gld)
  71 {
  72    Evas_GL_API *gl = gld->glapi;
  73    GLbyte vShaderStr[] =
  74       "attribute vec4 vPosition;    \n"
  75       "void main()                  \n"
  76       "{                            \n"
  77       "   gl_Position = vPosition;  \n"
  78       "}                            \n";
  79
  80    GLbyte fShaderStr[] =
  81       "#ifdef GL_ES                                 \n"
  82       "precision mediump float;                     \n"
  83       "#endif                                       \n"
  84       "void main()                                  \n"
  85       "{                                            \n"
  86       "  gl_FragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 );\n"
  87       "}                                            \n";
  88
  89    GLint linked;
  90
  91    // Load the vertex/fragment shaders
  92    gld->vtx_shader  = load_shader(gld, GL_VERTEX_SHADER, (const char*)vShaderStr);
  93    gld->fgmt_shader = load_shader(gld, GL_FRAGMENT_SHADER, (const char*)fShaderStr);
  94
  95    // Create the program object
  96    gld->program = gl->glCreateProgram( );
  97    if (gld->program==0)
  98       return 0;
  99
 100    gl->glAttachShader(gld->program, gld->vtx_shader);
 101    gl->glAttachShader(gld->program, gld->fgmt_shader);
 102
 103    gl->glBindAttribLocation(gld->program, 0, "vPosition");
 104    gl->glLinkProgram(gld->program);
 105    gl->glGetProgramiv(gld->program, GL_LINK_STATUS, &linked);
 106
 107    if (!linked)
 108      {
 109         GLint info_len = 0;
 110         gl->glGetProgramiv(gld->program, GL_INFO_LOG_LENGTH, &info_len);
 111         if (info_len > 1)
 112           {
 113              char* info_log = malloc(sizeof(char) * info_len);
 114
 115              gl->glGetProgramInfoLog(gld->program, info_len, NULL, info_log);
 116              printf("Error linking program:\n%s\n", info_log);
 117              free(info_log);
 118           }
 119         gl->glDeleteProgram(gld->program);
 120         return 0;
 121      }
 122    return 1;
 123 }
 124
 125
 126
 127 // Callbacks
 128 // intialize callback that gets called once for intialization
 129 static void
 130 _init_gl(Evas_Object *obj)
 131 {
 132    GLData *gld = evas_object_data_get(obj, "gld");
 133    Evas_GL_API *gl = gld->glapi;
 134    GLfloat vVertices[] = {  0.0f,  0.5f, 0.0f,
 135                            -0.5f, -0.5f, 0.0f,
 136                             0.5f, -0.5f, 0.0f };
 137
 138    if (!init_shaders(gld))
 139      {
 140         printf("Error Initializing Shaders\n");
 141         return;
 142      }
 143
 144    gl->glGenBuffers(1, &gld->vbo);
 145    gl->glBindBuffer(GL_ARRAY_BUFFER, gld->vbo);
 146    gl->glBufferData(GL_ARRAY_BUFFER, 3 * 3 * 4, vVertices, GL_STATIC_DRAW);
 147 }
 148
 149 // delete callback gets called when glview is deleted
 150 static void
 151 _del_gl(Evas_Object *obj)
 152 {
 153    GLData *gld = evas_object_data_get(obj, "gld");
 154    if (!gld)
 155      {
 156         printf("Unable to get GLData. \n");
 157         return;
 158      }
 159    Evas_GL_API *gl = gld->glapi;
 160
 161    gl->glDeleteShader(gld->vtx_shader);
 162    gl->glDeleteShader(gld->fgmt_shader);
 163    gl->glDeleteProgram(gld->program);
 164    gl->glDeleteBuffers(1, &gld->vbo);
 165
 166    evas_object_data_del((Evas_Object*)obj, "..gld");
 167    free(gld);
 168 }
 169
 170 // resize callback gets called every time object is resized
 171 static void
 172 _resize_gl(Evas_Object *obj)
 173 {
 174    int w, h;
 175    GLData *gld = evas_object_data_get(obj, "gld");
 176    Evas_GL_API *gl = gld->glapi;
 177
 178    elm_glview_size_get(obj, &w, &h);
 179
 180    // GL Viewport stuff. you can avoid doing this if viewport is all the
 181    // same as last frame if you want
 182    gl->glViewport(0, 0, w, h);
 183 }
 184
 185
 186 // draw callback is where all the main GL rendering happens
 187 static void
 188 _draw_gl(Evas_Object *obj)
 189 {
 190    Evas_GL_API *gl = elm_glview_gl_api_get(obj);
 191    GLData *gld = evas_object_data_get(obj, "gld");
 192    if (!gld) return;
 193    int w, h;
 194
 195    elm_glview_size_get(obj, &w, &h);
 196
 197    gl->glViewport(0, 0, w, h);
 198    gl->glClearColor(red,0.8,0.3,1);
 199    gl->glClear(GL_COLOR_BUFFER_BIT);
 200
 201    // Draw a Triangle
 202    gl->glEnable(GL_BLEND);
 203
 204    gl->glUseProgram(gld->program);
 205
 206    gl->glBindBuffer(GL_ARRAY_BUFFER, gld->vbo);
 207    gl->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
 208                              0, 0);
 209    gl->glEnableVertexAttribArray(0);
 210
 211    gl->glDrawArrays(GL_TRIANGLES, 0, 3);
 212
 213    // Optional - Flush the GL pipeline
 214    gl->glFinish();
 215
 216    red -= 0.1;
 217    if (red < 0.0) red = 1.0;
 218 }
 219
 220 // just need to notify that glview has changed so it can render
 221 static Eina_Bool
 222 _anim(void *data)
 223 {
 224    elm_glview_changed_set(data);
 225    return EINA_TRUE;
 226 }
 227
 228 static void
 229 _on_done(void *data, Evas_Object *obj, void *event_info)
 230 {
 231    evas_object_del((Evas_Object*)data);
 232    elm_exit();
 233 }
 234
 235 static void
 236 _del(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 237 {
 238    Ecore_Animator *ani = evas_object_data_get(obj, "ani");
 239    ecore_animator_del(ani);
 240 }
 241
 242
 243 EAPI_MAIN int
 244 elm_main(int argc, char **argv)
 245 {
 246    Evas_Object *win, *bg, *bx, *bt, *gl;
 247    Ecore_Animator *ani;
 248    GLData *gld = NULL;
 249
 250    if (!(gld = calloc(1, sizeof(GLData)))) return 1;
 251
 252    // set the preferred engine to opengl_x11. if it isnt' available it
 253    // may use another transparently
 254    elm_config_preferred_engine_set("opengl_x11");
 255
 256    win = elm_win_add(NULL, "glview simple", ELM_WIN_BASIC);
 257    elm_win_title_set(win, "GLView Simple");
 258    elm_win_autodel_set(win, EINA_TRUE);
 259    elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
 260
 261    bg = elm_bg_add(win);
 262    elm_win_resize_object_add(win, bg);
 263    evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 264    evas_object_show(bg);
 265
 266    bx = elm_box_add(win);
 267    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 268    elm_win_resize_object_add(win, bx);
 269    evas_object_show(bx);
 270
 271    //-//-//-// THIS IS WHERE GL INIT STUFF HAPPENS (ALA EGL)
 272    //-//
 273    // create a new glview object
 274    gl = elm_glview_add(win);
 275    gld->glapi = elm_glview_gl_api_get(gl);
 276    evas_object_size_hint_align_set(gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
 277    evas_object_size_hint_weight_set(gl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 278    // mode is simply for supporting alpha, depth buffering, and stencil
 279    // buffering.
 280    elm_glview_mode_set(gl, ELM_GLVIEW_ALPHA | ELM_GLVIEW_DEPTH);
 281    // resize policy tells glview what to do with the surface when it
 282    // resizes.  ELM_GLVIEW_RESIZE_POLICY_RECREATE will tell it to
 283    // destroy the current surface and recreate it to the new size
 284    elm_glview_resize_policy_set(gl, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
 285    // render policy tells glview how it would like glview to render
 286    // gl code. ELM_GLVIEW_RENDER_POLICY_ON_DEMAND will have the gl
 287    // calls called in the pixel_get callback, which only gets called
 288    // if the object is visible, hence ON_DEMAND.  ALWAYS mode renders
 289    // it despite the visibility of the object.
 290    elm_glview_render_policy_set(gl, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
 291    // initialize callback function gets registered here
 292    elm_glview_init_func_set(gl, _init_gl);
 293    // delete callback function gets registered here
 294    elm_glview_del_func_set(gl, _del_gl);
 295    elm_glview_resize_func_set(gl, _resize_gl);
 296    elm_glview_render_func_set(gl, _draw_gl);
 297    //-//
 298    //-//-//-// END GL INIT BLOB
 299
 300    elm_box_pack_end(bx, gl);
 301    evas_object_show(gl);
 302
 303    elm_object_focus_set(gl, EINA_TRUE);
 304
 305    // animating - just a demo. as long as you trigger an update on the image
 306    // object via elm_glview_changed_set() it will be updated.
 307    //
 308    // NOTE: if you delete gl, this animator will keep running trying to access
 309    // gl so you'd better delete this animator with ecore_animator_del().
 310    ani = ecore_animator_add(_anim, gl);
 311
 312    evas_object_data_set(gl, "ani", ani);
 313    evas_object_data_set(gl, "gld", gld);
 314    evas_object_event_callback_add(gl, EVAS_CALLBACK_DEL, _del, gl);
 315
 316    // add an 'OK' button to end the program
 317    bt = elm_button_add(win);
 318    elm_object_text_set(bt, "OK");
 319    evas_object_size_hint_align_set(bt, EVAS_HINT_FILL, EVAS_HINT_FILL);
 320    evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
 321    elm_box_pack_end(bx, bt);
 322    evas_object_show(bt);
 323    evas_object_smart_callback_add(bt, "clicked", _on_done, win);
 324
 325    evas_object_resize(win, 320, 480);
 326    evas_object_show(win);
 327
 328    // run the mainloop and process events and callbacks
 329    elm_run();
 330    elm_shutdown();
 331
 332    return 0;
 333 }
 334 ELM_MAIN()