efl

1
#ifdef HAVE_CONFIG_H
2
# include "elementary_config.h"
3
#endif
4

5
#include <Efl_Ui.h>
6
#include <Elementary.h>
7
#ifndef M_PI
8
#define M_PI 3.14159265
9
#endif
10

11
typedef struct _Gear Gear;
12
typedef struct _GLData GLData;
13
struct _Gear
14
{
15
   GLfloat *vertices;
16
   GLuint vbo;
17
   int count;
18
};
19

20
// GL related data here..
21
struct _GLData
22
{
23
   Evas_GL_API *glapi;
24
   GLuint       program;
25
   GLuint       vtx_shader;
26
   GLuint       fgmt_shader;
27
   int          initialized : 1;
28
   int          mouse_down : 1;
29

30
   // Gear Stuff
31
   GLfloat      view_rotx;
32
   GLfloat      view_roty;
33
   GLfloat      view_rotz;
34

35
   Gear        *gear1;
36
   Gear        *gear2;
37
   Gear        *gear3;
38

39
   GLfloat      angle;
40

41
   GLuint       proj_location;
42
   GLuint       light_location;
43
   GLuint       color_location;
44

45
   GLfloat      proj[16];
46
   GLfloat      light[3];
47
};
48

49
static void gears_init(GLData *gld);
50
static void free_gear(Gear *gear);
51
static void gears_reshape(GLData *gld, int width, int height);
52
static void render_gears(GLData *gld);
53

54
//--------------------------------//
55
// Gear Stuff....
56
static GLfloat *
57
vert(GLfloat *p, GLfloat x, GLfloat y, GLfloat z, GLfloat *n)
58
{
59
   p[0] = x;
60
   p[1] = y;
61
   p[2] = z;
62
   p[3] = n[0];
63
   p[4] = n[1];
64
   p[5] = n[2];
65

66
   return p + 6;
67
}
68

69
/*  Draw a gear wheel.  You'll probably want to call this function when
70
 *  building a display list since we do a lot of trig here.
71
 *
72
 *  Input:  inner_radius - radius of hole at center
73
 *          outer_radius - radius at center of teeth
74
 *          width - width of gear
75
 *          teeth - number of teeth
76
 *          tooth_depth - depth of tooth
77
 */
78
static Gear *
79
make_gear(GLData *gld, GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
80
          GLint teeth, GLfloat tooth_depth)
81
{
82
   GLint i;
83
   GLfloat r0, r1, r2;
84
   GLfloat da;
85
   GLfloat *v;
86
   Gear *gear;
87
   double s[5], c[5];
88
   GLfloat normal[3];
89
   const int tris_per_tooth = 20;
90
   Evas_GL_API *gl = gld->glapi;
91

92
   gear = (Gear*)malloc(sizeof(Gear));
93
   if (gear == NULL)
94
     return NULL;
95

96
   r0 = inner_radius;
97
   r1 = outer_radius - tooth_depth / 2.0;
98
   r2 = outer_radius + tooth_depth / 2.0;
99

100
   da = 2.0 * M_PI / teeth / 4.0;
101

102
   gear->vertices = calloc(teeth * tris_per_tooth * 3 * 6,
103
                           sizeof *gear->vertices);
104
   s[4] = 0;
105
   c[4] = 1;
106
   v = gear->vertices;
107
   for (i = 0; i < teeth; i++)
108
     {
109
        s[0] = s[4];
110
        c[0] = c[4];
111
        s[1] = sin(i * 2.0 * M_PI / teeth + da);
112
        c[1] = cos(i * 2.0 * M_PI / teeth + da);
113
        s[2] = sin(i * 2.0 * M_PI / teeth + da * 2);
114
        c[2] = cos(i * 2.0 * M_PI / teeth + da * 2);
115
        s[3] = sin(i * 2.0 * M_PI / teeth + da * 3);
116
        c[3] = cos(i * 2.0 * M_PI / teeth + da * 3);
117
        s[4] = sin(i * 2.0 * M_PI / teeth + da * 4);
118
        c[4] = cos(i * 2.0 * M_PI / teeth + da * 4);
119

120
        normal[0] = 0.0;
121
        normal[1] = 0.0;
122
        normal[2] = 1.0;
123

124
        v = vert(v, r2 * c[1], r2 * s[1], width * 0.5, normal);
125

126
        v = vert(v, r2 * c[1], r2 * s[1], width * 0.5, normal);
127
        v = vert(v, r2 * c[2], r2 * s[2], width * 0.5, normal);
128
        v = vert(v, r1 * c[0], r1 * s[0], width * 0.5, normal);
129
        v = vert(v, r1 * c[3], r1 * s[3], width * 0.5, normal);
130
        v = vert(v, r0 * c[0], r0 * s[0], width * 0.5, normal);
131
        v = vert(v, r1 * c[4], r1 * s[4], width * 0.5, normal);
132
        v = vert(v, r0 * c[4], r0 * s[4], width * 0.5, normal);
133

134
        v = vert(v, r0 * c[4], r0 * s[4], width * 0.5, normal);
135
        v = vert(v, r0 * c[0], r0 * s[0], width * 0.5, normal);
136
        v = vert(v, r0 * c[4], r0 * s[4], -width * 0.5, normal);
137
        v = vert(v, r0 * c[0], r0 * s[0], -width * 0.5, normal);
138

139
        normal[0] = 0.0;
140
        normal[1] = 0.0;
141
        normal[2] = -1.0;
142

143
        v = vert(v, r0 * c[4], r0 * s[4], -width * 0.5, normal);
144

145
        v = vert(v, r0 * c[4], r0 * s[4], -width * 0.5, normal);
146
        v = vert(v, r1 * c[4], r1 * s[4], -width * 0.5, normal);
147
        v = vert(v, r0 * c[0], r0 * s[0], -width * 0.5, normal);
148
        v = vert(v, r1 * c[3], r1 * s[3], -width * 0.5, normal);
149
        v = vert(v, r1 * c[0], r1 * s[0], -width * 0.5, normal);
150
        v = vert(v, r2 * c[2], r2 * s[2], -width * 0.5, normal);
151
        v = vert(v, r2 * c[1], r2 * s[1], -width * 0.5, normal);
152

153
        v = vert(v, r1 * c[0], r1 * s[0], width * 0.5, normal);
154

155
        v = vert(v, r1 * c[0], r1 * s[0], width * 0.5, normal);
156
        v = vert(v, r1 * c[0], r1 * s[0], -width * 0.5, normal);
157
        v = vert(v, r2 * c[1], r2 * s[1], width * 0.5, normal);
158
        v = vert(v, r2 * c[1], r2 * s[1], -width * 0.5, normal);
159
        v = vert(v, r2 * c[2], r2 * s[2], width * 0.5, normal);
160
        v = vert(v, r2 * c[2], r2 * s[2], -width * 0.5, normal);
161
        v = vert(v, r1 * c[3], r1 * s[3], width * 0.5, normal);
162
        v = vert(v, r1 * c[3], r1 * s[3], -width * 0.5, normal);
163
        v = vert(v, r1 * c[4], r1 * s[4], width * 0.5, normal);
164
        v = vert(v, r1 * c[4], r1 * s[4], -width * 0.5, normal);
165

166
        v = vert(v, r1 * c[4], r1 * s[4], -width * 0.5, normal);
167
     }
168

169
   gear->count = (v - gear->vertices) / 6;
170

171
   gl->glGenBuffers(1, &gear->vbo);
172
   gl->glBindBuffer(GL_ARRAY_BUFFER, gear->vbo);
173
   gl->glBufferData(GL_ARRAY_BUFFER, gear->count * 6 * 4,
174
                    gear->vertices, GL_STATIC_DRAW);
175

176
   return gear;
177
}
178

179
static void
180
free_gear(Gear *gear)
181
{
182
    if (!gear) return;
183
    free(gear->vertices);
184
    free(gear);
185
}
186

187
static void
188
multiply(GLfloat *m, const GLfloat *n)
189
{
190
   GLfloat tmp[16];
191
   const GLfloat *row, *column;
192
   div_t d;
193
   int i, j;
194

195
   for (i = 0; i < 16; i++)
196
     {
197
        tmp[i] = 0;
198
        d = div(i, 4);
199
        row = n + d.quot * 4;
200
        column = m + d.rem;
201
        for (j = 0; j < 4; j++)
202
          tmp[i] += row[j] * column[j * 4];
203
     }
204
   memcpy(m, &tmp, sizeof tmp);
205
}
206

207
static void
208
rotate(GLfloat *m, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
209
{
210
   double s, c;
211

212
   s = sin(angle);
213
   c = cos(angle);
214
   GLfloat r[16] =
215
     {
216
        x * x * (1 - c) + c,     y * x * (1 - c) + z * s, x * z * (1 - c) - y * s, 0,
217
        x * y * (1 - c) - z * s, y * y * (1 - c) + c,     y * z * (1 - c) + x * s, 0,
218
        x * z * (1 - c) + y * s, y * z * (1 - c) - x * s, z * z * (1 - c) + c,     0,
219
        0, 0, 0, 1
220
     };
221

222
   multiply(m, r);
223
}
224

225
static void
226
translate(GLfloat *m, GLfloat x, GLfloat y, GLfloat z)
227
{
228
   GLfloat t[16] = { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  x, y, z, 1 };
229

230
   multiply(m, t);
231
}
232

233
static void
234
draw_gear(GLData *gld, Gear *gear, GLfloat *m,
235
          GLfloat x, GLfloat y, GLfloat angle, const GLfloat *color)
236
{
237
   Evas_GL_API *gl = gld->glapi;
238
   GLfloat tmp[16];
239

240
   memcpy(tmp, m, sizeof tmp);
241
   translate(tmp, x, y, 0);
242
   rotate(tmp, 2 * M_PI * angle / 360.0, 0, 0, 1);
243
   gl->glUniformMatrix4fv(gld->proj_location, 1, GL_FALSE, tmp);
244
   gl->glUniform3fv(gld->light_location, 1, gld->light);
245
   gl->glUniform4fv(gld->color_location, 1, color);
246

247
   gl->glBindBuffer(GL_ARRAY_BUFFER, gear->vbo);
248

249
   gl->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
250
                             6 * sizeof(GLfloat), NULL);
251
   gl->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,
252
                             6 * sizeof(GLfloat), (GLfloat *)(0 + 3 * sizeof(GLfloat)));
253
   gl->glEnableVertexAttribArray(0);
254
   gl->glEnableVertexAttribArray(1);
255
   gl->glDrawArrays(GL_TRIANGLE_STRIP, 0, gear->count);
256
}
257

258
static void
259
gears_draw(GLData *gld)
260
{
261
   Evas_GL_API *gl = gld->glapi;
262

263
   static const GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
264
   static const GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
265
   static const GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
266
   GLfloat m[16];
267

268
   gl->glClearColor(0x25 / 255., 0x13 / 255., 0.0, 1.0);
269
   gl->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
270

271
   memcpy(m, gld->proj, sizeof m);
272
   rotate(m, 2 * M_PI * gld->view_rotx / 360.0, 1, 0, 0);
273
   rotate(m, 2 * M_PI * gld->view_roty / 360.0, 0, 1, 0);
274
   rotate(m, 2 * M_PI * gld->view_rotz / 360.0, 0, 0, 1);
275

276
   draw_gear(gld, gld->gear1, m, -3.0, -2.0, gld->angle, red);
277
   draw_gear(gld, gld->gear2, m, 3.1, -2.0, -2 * gld->angle - 9.0, green);
278
   draw_gear(gld, gld->gear3, m, -3.1, 4.2, -2 * gld->angle - 25.0, blue);
279
}
280

281
static void render_gears(GLData *gld)
282
{
283
   gears_draw(gld);
284

285
   gld->angle += 2.0;
286
}
287

288
/* new window size or exposure */
289
static void
290
gears_reshape(GLData *gld, int width, int height)
291
{
292
   Evas_GL_API *gl = gld->glapi;
293

294
   GLfloat ar, m[16] = {
295
      1.0, 0.0, 0.0, 0.0,
296
      0.0, 1.0, 0.0, 0.0,
297
      0.0, 0.0, 0.1, 0.0,
298
      0.0, 0.0, 0.0, 1.0
299
   };
300

301
   if (width < height)
302
     ar = width;
303
   else
304
     ar = height;
305

306
   m[0] = 0.1 * ar / width;
307
   m[5] = 0.1 * ar / height;
308
   memcpy(gld->proj, m, sizeof gld->proj);
309
   gl->glViewport(0, 0, (GLint) width, (GLint) height);
310
}
311

312
static const char vertex_shader[] =
313
   "uniform mat4 proj;\n"
314
   "attribute vec4 position;\n"
315
   "attribute vec4 normal;\n"
316
   "varying vec3 rotated_normal;\n"
317
   "varying vec3 rotated_position;\n"
318
   "vec4 tmp;\n"
319
   "void main()\n"
320
   "{\n"
321
   "   gl_Position = proj * position;\n"
322
   "   rotated_position = gl_Position.xyz;\n"
323
   "   tmp = proj * normal;\n"
324
   "   rotated_normal = tmp.xyz;\n"
325
   "}\n";
326

327
 static const char fragment_shader[] =
328
   "#ifdef GL_ES\n"
329
   "precision mediump float;\n"
330
   "#endif\n"
331
   "uniform vec4 color;\n"
332
   "uniform vec3 light;\n"
333
   "varying vec3 rotated_normal;\n"
334
   "varying vec3 rotated_position;\n"
335
   "vec3 light_direction;\n"
336
   "vec4 white = vec4(0.5, 0.5, 0.5, 1.0);\n"
337
   "void main()\n"
338
   "{\n"
339
   "   light_direction = normalize(light - rotated_position);\n"
340
   "   gl_FragColor = color + white * dot(light_direction, rotated_normal);\n"
341
   "}\n";
342

343
static void
344
_print_gl_log(Evas_GL_API *gl, GLuint id)
345
{
346
   GLint log_len = 0;
347
   char *log_info;
348

349
   if (gl->glIsShader(id))
350
     gl->glGetShaderiv(id, GL_INFO_LOG_LENGTH, &log_len);
351
   else if (gl->glIsProgram(id))
352
     gl->glGetProgramiv(id, GL_INFO_LOG_LENGTH, &log_len);
353
   if (!log_len) return;
354

355
   log_info = malloc(log_len * sizeof(char));
356

357
   if (gl->glIsShader(id))
358
     gl->glGetShaderInfoLog(id, log_len, NULL, log_info);
359
   else if (gl->glIsProgram(id))
360
     gl->glGetProgramInfoLog(id, log_len, NULL, log_info);
361

362
   printf("%s", log_info);
363
   free(log_info);
364
}
365

366
static void
367
gears_init(GLData *gld)
368
{
369
   Evas_GL_API *gl = gld->glapi;
370

371
   const char *p;
372

373
   gl->glEnable(GL_CULL_FACE);
374
   gl->glEnable(GL_DEPTH_TEST);
375

376
   p = vertex_shader;
377
   gld->vtx_shader = gl->glCreateShader(GL_VERTEX_SHADER);
378
   gl->glShaderSource(gld->vtx_shader, 1, &p, NULL);
379
   gl->glCompileShader(gld->vtx_shader);
380
   _print_gl_log(gl, gld->vtx_shader);
381

382
   p = fragment_shader;
383
   gld->fgmt_shader = gl->glCreateShader(GL_FRAGMENT_SHADER);
384
   gl->glShaderSource(gld->fgmt_shader, 1, &p, NULL);
385
   gl->glCompileShader(gld->fgmt_shader);
386
   _print_gl_log(gl, gld->fgmt_shader);
387

388
   gld->program = gl->glCreateProgram();
389
   gl->glAttachShader(gld->program, gld->vtx_shader);
390
   gl->glAttachShader(gld->program, gld->fgmt_shader);
391
   gl->glBindAttribLocation(gld->program, 0, "position");
392
   gl->glBindAttribLocation(gld->program, 1, "normal");
393

394
   gl->glLinkProgram(gld->program);
395
   _print_gl_log(gl, gld->program);
396

397
   gl->glUseProgram(gld->program);
398
   gld->proj_location  = gl->glGetUniformLocation(gld->program, "proj");
399
   gld->light_location = gl->glGetUniformLocation(gld->program, "light");
400
   gld->color_location = gl->glGetUniformLocation(gld->program, "color");
401

402
   /* make the gears */
403
   gld->gear1 = make_gear(gld, 1.0, 4.0, 1.0, 20, 0.7);
404
   gld->gear2 = make_gear(gld, 0.5, 2.0, 2.0, 10, 0.7);
405
   gld->gear3 = make_gear(gld, 1.3, 2.0, 0.5, 10, 0.7);
406
}
407

408
static void
409
gldata_init(GLData *gld)
410
{
411
   gld->initialized = 0;
412
   gld->mouse_down = 0;
413

414
   gld->view_rotx = -20.0;
415
   gld->view_roty = -30.0;
416
   gld->view_rotz = 0.0;
417
   gld->angle = 0.0;
418

419
   gld->light[0] = 1.0;
420
   gld->light[1] = 1.0;
421
   gld->light[2] = -5.0;
422
}
423

424
//-------------------------//
425

426
static void
427
_init_gl(Evas_Object *obj)
428
{
429
   GLData *gld = evas_object_data_get(obj, "gld");
430

431
   gld->glapi = elm_glview_gl_api_get(obj);
432
   printf("GL_VERSION: %s\n", gld->glapi->glGetString(GL_VERSION));
433
   fflush(stdout);
434

435
   gears_init(gld);
436
}
437

438
static void
439
_del_gl(Evas_Object *obj)
440
{
441
   GLData *gld = evas_object_data_get(obj, "gld");
442
   if (!gld)
443
     {
444
        printf("Unable to get GLData.\n");
445
        fflush(stdout);
446
        return;
447
     }
448
   Evas_GL_API *gl = gld->glapi;
449

450
   if (gl)
451
     {
452
        gl->glDeleteShader(gld->vtx_shader);
453
        gl->glDeleteShader(gld->fgmt_shader);
454
        gl->glDeleteProgram(gld->program);
455
        gl->glDeleteBuffers(1, &gld->gear1->vbo);
456
        gl->glDeleteBuffers(1, &gld->gear2->vbo);
457
        gl->glDeleteBuffers(1, &gld->gear3->vbo);
458
     }
459

460
   free_gear(gld->gear1);
461
   free_gear(gld->gear2);
462
   free_gear(gld->gear3);
463

464
   evas_object_data_del((Evas_Object*)obj, "..gld");
465
   free(gld);
466
}
467

468
static void
469
_resize_gl(Evas_Object *obj)
470
{
471
   int w, h;
472
   GLData *gld = evas_object_data_get(obj, "gld");
473

474
   elm_glview_size_get(obj, &w, &h);
475

476
   // GL Viewport stuff. you can avoid doing this if viewport is all the
477
   // same as last frame if you want
478
   gears_reshape(gld, w,h);
479
}
480

481
static void
482
_draw_gl(Evas_Object *obj)
483
{
484
   Evas_GL_API *gl = elm_glview_gl_api_get(obj);
485
   GLData *gld = evas_object_data_get(obj, "gld");
486
   if (!gld) return;
487

488
   render_gears(gld);
489
   gl->glFinish();
490
}
491

492
static Eina_Bool
493
_anim(void *data)
494
{
495
   elm_glview_changed_set(data);
496
   return EINA_TRUE;
497
}
498

499
static Eina_Bool
500
_quit_idler(void *data)
501
{
502
   evas_object_del(data);
503

504
   return ECORE_CALLBACK_CANCEL;
505
}
506

507
static void
508
_on_done(void *data,
509
         Evas_Object *obj EINA_UNUSED,
510
         void *event_info EINA_UNUSED)
511
{
512
   ecore_idler_add(_quit_idler, data);
513
}
514

515
static void
516
_on_direct(void *data,
517
           Evas_Object *obj EINA_UNUSED,
518
           void *event_info EINA_UNUSED)
519
{
520
   if (!data) return;
521

522
   // ON_DEMAND is necessary for Direct Rendering
523
   elm_glview_render_policy_set(data, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
524
   elm_glview_mode_set(data, 0
525
                       | ELM_GLVIEW_ALPHA
526
                       | ELM_GLVIEW_DEPTH
527
                       | ELM_GLVIEW_DIRECT
528
                      );
529
}
530

531
static void
532
_on_indirect(void *data,
533
           Evas_Object *obj EINA_UNUSED,
534
           void *event_info EINA_UNUSED)
535
{
536
   if (!data) return;
537

538
   // note that with policy ALWAYS the window will flicker on resize
539
   elm_glview_render_policy_set(data, ELM_GLVIEW_RENDER_POLICY_ALWAYS);
540
   elm_glview_mode_set(data, 0
541
                       | ELM_GLVIEW_ALPHA
542
                       | ELM_GLVIEW_DEPTH
543
                      );
544
}
545

546
static void
547
_del(void *data EINA_UNUSED, Evas *evas EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
548
{
549
   Ecore_Animator *ani = evas_object_data_get(obj, "ani");
550
   ecore_animator_del(ani);
551
}
552

553
static void
554
_key_down(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info)
555
{
556
   Evas_Event_Key_Down *ev;
557
   ev = (Evas_Event_Key_Down *)event_info;
558
   GLData *gld = evas_object_data_get(obj, "gld");
559

560
   if (strcmp(ev->key, "Left") == 0)
561
     {
562
        gld->view_roty += 5.0;
563
        return;
564
     }
565

566
   if (strcmp(ev->key, "Right") == 0)
567
     {
568
        gld->view_roty -= 5.0;
569
        return;
570
     }
571

572
   if (strcmp(ev->key, "Up") == 0)
573
     {
574
        gld->view_rotx += 5.0;
575
        return;
576
     }
577

578
   if (strcmp(ev->key, "Down") == 0)
579
     {
580
        gld->view_rotx -= 5.0;
581
        return;
582
     }
583
   if ((strcmp(ev->key, "Escape") == 0) ||
584
       (strcmp(ev->key, "Return") == 0))
585
     {
586
        //_on_done(data, obj, event_info);
587
        return;
588
     }
589
}
590

591
static void
592
_mouse_down(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
593
{
594
   GLData *gld = evas_object_data_get(obj, "gld");
595
   gld->mouse_down = 1;
596
}
597

598
static void
599
_mouse_move(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
600
{
601
   Evas_Event_Mouse_Move *ev;
602
   ev = (Evas_Event_Mouse_Move *)event_info;
603
   GLData *gld = evas_object_data_get(obj, "gld");
604
   float dx = 0, dy = 0;
605

606
   if (gld->mouse_down)
607
     {
608
        dx = ev->cur.canvas.x - ev->prev.canvas.x;
609
        dy = ev->cur.canvas.y - ev->prev.canvas.y;
610

611
        gld->view_roty += -1.0 * dx;
612
        gld->view_rotx += -1.0 * dy;
613
     }
614
}
615

616
static void
617
_mouse_up(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
618
{
619
   GLData *gld = evas_object_data_get(obj, "gld");
620
   gld->mouse_down = 0;
621
}
622

623
static void
624
_test_glview_do(Evas_GL_Context_Version version)
625
{
626
   Evas_Object *win, *bx, *bt, *gl, *lb;
627
   Ecore_Animator *ani;
628
   GLData *gld = NULL;
629

630
   // alloc a data struct to hold our relevant gl info in
631
   if (!(gld = calloc(1, sizeof(GLData)))) return;
632
   gldata_init(gld);
633

634
#if 1
635
   // add a Z-depth buffer to the window and try to use GL
636
   Eina_Stringshare *accel;
637
   accel = eina_stringshare_add(elm_config_accel_preference_get());
638
   elm_config_accel_preference_set("gl:depth");
639

640
   // new window - do the usual and give it a name, title and delete handler
641
   win = elm_win_util_standard_add("glview", "GLView");
642
   elm_win_autodel_set(win, EINA_TRUE);
643

644
   // restore previous accel preference
645
   elm_config_accel_preference_set(accel);
646
   eina_stringshare_del(accel);
647
#else
648
   win = efl_add_ref(EFL_UI_WIN_CLASS, NULL,
649
                efl_ui_win_name_set(efl_added, "glview"),
650
                efl_text_set(efl_added, "GLView"),
651
                efl_ui_win_accel_preference_set(efl_added, "gl:depth"));
652
   elm_win_autodel_set(win, EINA_TRUE);
653
#endif
654

655
   bx = elm_box_add(win);
656
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
657
   elm_win_resize_object_add(win, bx);
658
   evas_object_show(bx);
659

660
   // Add a GLView
661
   gl = elm_glview_version_add(win, version);
662
   if (gl)
663
     {
664
        evas_object_size_hint_align_set(gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
665
        evas_object_size_hint_weight_set(gl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
666
        elm_glview_mode_set(gl, 0
667
                            | ELM_GLVIEW_ALPHA
668
                            | ELM_GLVIEW_DEPTH
669
                           );
670
        elm_glview_resize_policy_set(gl, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
671
        elm_glview_render_policy_set(gl, ELM_GLVIEW_RENDER_POLICY_ALWAYS);
672
        elm_glview_init_func_set(gl, _init_gl);
673
        elm_glview_del_func_set(gl, _del_gl);
674
        elm_glview_resize_func_set(gl, _resize_gl);
675
        elm_glview_render_func_set(gl, _draw_gl);
676
        elm_box_pack_end(bx, gl);
677
        evas_object_show(gl);
678

679
        // Add Mouse/Key Event Callbacks
680
        elm_object_focus_set(gl, EINA_TRUE);
681
        evas_object_event_callback_add(gl, EVAS_CALLBACK_KEY_DOWN, _key_down, gl);
682
        evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, gl);
683
        evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_UP, _mouse_up, gl);
684
        evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move, gl);
685

686
        // Animator and other vars
687
        ani = ecore_animator_add(_anim, gl);
688
        evas_object_data_set(gl, "ani", ani);
689
        evas_object_data_set(gl, "gld", gld);
690
        evas_object_event_callback_add(gl, EVAS_CALLBACK_DEL, _del, gl);
691

692
        bt = elm_button_add(win);
693
        elm_object_text_set(bt, "Direct Mode");
694
        evas_object_size_hint_align_set(bt, EVAS_HINT_FILL, EVAS_HINT_FILL);
695
        evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
696
        elm_box_pack_end(bx, bt);
697
        evas_object_show(bt);
698
        evas_object_smart_callback_add(bt, "clicked", _on_direct, gl);
699

700
        bt = elm_button_add(win);
701
        elm_object_text_set(bt, "Indirect Mode");
702
        evas_object_size_hint_align_set(bt, EVAS_HINT_FILL, EVAS_HINT_FILL);
703
        evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
704
        elm_box_pack_end(bx, bt);
705
        evas_object_show(bt);
706
        evas_object_smart_callback_add(bt, "clicked", _on_indirect, gl);
707
     }
708
   else
709
     {
710
        lb = elm_label_add(bx);
711
        elm_object_text_set(lb, "<align=left> GL backend engine is not supported.<br/>"
712
                            " 1. Check your back-end engine or<br/>"
713
                            " 2. Run elementary_test with engine option or<br/>"
714
                            "    ex) $ <b>ELM_ACCEL=gl</b> elementary_test<br/>"
715
                            " 3. Change your back-end engine from elementary_config.<br/></align>");
716
        evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
717
        evas_object_size_hint_align_set(lb, EVAS_HINT_FILL, EVAS_HINT_FILL);
718
        elm_box_pack_end(bx, lb);
719
        evas_object_show(lb);
720
        free(gld);
721
     }
722

723
   bt = elm_button_add(win);
724
   elm_object_text_set(bt, "Close");
725
   evas_object_size_hint_align_set(bt, EVAS_HINT_FILL, EVAS_HINT_FILL);
726
   evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
727
   elm_box_pack_end(bx, bt);
728
   evas_object_show(bt);
729
   evas_object_smart_callback_add(bt, "clicked", _on_done, win);
730

731
   evas_object_resize(win, 320 * elm_config_scale_get(),
732
                           480 * elm_config_scale_get());
733
   evas_object_show(win);
734
}
735

736
void
737
test_glview(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
738
{
739
   _test_glview_do(EVAS_GL_GLES_2_X);
740
}
741

742
void
743
test_glview_gles3(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
744
{
745
   _test_glview_do(EVAS_GL_GLES_3_X);
746
}
747