src/video/tizen/SDL_tizenopengles.c

   1 /*
   2   Simple DirectMedia Layer
   3   Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>
   4   Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
   5
   6   This software is provided 'as-is', without any express or implied
   7   warranty.  In no event will the authors be held liable for any damages
   8   arising from the use of this software.
   9
  10   Permission is granted to anyone to use this software for any purpose,
  11   including commercial applications, and to alter it and redistribute it
  12   freely, subject to the following restrictions:
  13
  14   1. The origin of this software must not be misrepresented; you must not
  15      claim that you wrote the original software. If you use this software
  16      in a product, an acknowledgment in the product documentation would be
  17      appreciated but is not required.
  18   2. Altered source versions must be plainly marked as such, and must not be
  19      misrepresented as being the original software.
  20   3. This notice may not be removed or altered from any source distribution.
  21 */
  22 #include "../../SDL_internal.h"
  23
  24 #if SDL_VIDEO_OPENGL_EGL
  25
  26 #include "SDL_tizenvideo.h"
  27 #include "SDL_tizenopengles.h"
  28 #include "SDL_tizenwindow.h"
  29 #include "SDL_tizenevents_c.h"
  30
  31 #include "SDL_ecore_ipc.h"
  32 #include "SDL_tizenvideo.h"
  33
  34 #include <wayland-extension/tizen-remote-surface-client-protocol.h>
  35 #include <wayland-tbm-client.h>
  36 #include <Ecore_Wayland.h>
  37 #include <SDL_egl.h>
  38
  39 #if SDL_VIDEO_OPENGL
  40 #include "SDL_opengl.h"
  41 #endif /* SDL_VIDEO_OPENGL */
  42
  43 #if SDL_VIDEO_OPENGL_ES
  44 #include "SDL_opengles.h"
  45 #endif /* SDL_VIDEO_OPENGL_ES */
  46
  47 /* GL and GLES2 headers conflict on Linux 32 bits */
  48 #if SDL_VIDEO_OPENGL_ES2 && !SDL_VIDEO_OPENGL
  49 #include "SDL_opengles2.h"
  50 #endif /* SDL_VIDEO_OPENGL_ES2 && !SDL_VIDEO_OPENGL */
  51
  52 /* EGL implementation of SDL OpenGL ES support */
  53 typedef struct GLES2_Context
  54 {
  55     #define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
  56     #include "../../render/opengles2/SDL_gles2funcs.h"
  57     #undef SDL_PROC
  58 } GLES2_Context;
  59
  60 GLfloat vVertices[18]={
  61      1.0f, 1.0f,  0.0f,
  62     -1.0f, 0.92f, 0.0f,
  63      1.0f, 0.92f, 0.0f,
  64      1.0f, 1.0f,  0.0f,
  65     -1.0f, 1.0f,  0.0f,
  66     -1.0f, 0.92f, 0.0f
  67     };
  68
  69 GLfloat vCoord[12] = {
  70     1.0f, 0.0f,
  71     0.0f, 1.0f,
  72     1.0f, 1.0f,
  73     1.0f, 0.0f,
  74     0.0f, 0.0f,
  75     0.0f, 1.0f};
  76
  77 PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR = NULL;
  78 PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageKHR = NULL;
  79 PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES = NULL;
  80
  81 SharedIndicatorInfo shared_info;
  82 unsigned int textureID;
  83 unsigned int indicator_vbo[4], indicator_ibo[4];
  84 ModelMatrix mMatrix;
  85
  86
  87 GLuint programObject;
  88 GLuint vIndex;
  89 GLuint cIndex;
  90
  91
  92 static int LoadContext(GLES2_Context * data)
  93 {
  94     #define SDL_PROC(ret,func,params) \
  95     do { \
  96         data->func = SDL_GL_GetProcAddress(#func); \
  97         if ( ! data->func ) { \
  98             return SDL_SetError("Couldn't load GLES2 function %s: %s\n", #func, SDL_GetError()); \
  99         } \
 100     } while ( 0 );
 101
 102     #include "../../render/opengles2/SDL_gles2funcs.h"
 103     #undef SDL_PROC
 104
 105     return 0;
 106 }
 107
 108 static void
 109 _tizen_rs_cb_buffer_update(void *data, struct tizen_remote_surface *trs, struct wl_buffer *buffer, uint32_t time)
 110 {
 111     tizen_remote_surface_transfer_visibility(trs, TIZEN_REMOTE_SURFACE_VISIBILITY_TYPE_VISIBLE);
 112     tbm_surface_h tbmSurface= wl_buffer_get_user_data(buffer);
 113
 114     if(eglCreateImageKHR != NULL && glEGLImageTargetTexture2DOES != NULL && eglDestroyImageKHR != NULL)
 115     {
 116         SDL_VideoDevice *_this = SDL_GetVideoDevice();
 117
 118         if(shared_info.eglImage_Indicator != NULL)
 119             eglDestroyImageKHR(_this->egl_data->egl_display, shared_info.eglImage_Indicator);
 120
 121         shared_info.eglImage_Indicator = eglCreateImageKHR(_this->egl_data->egl_display,
 122                             EGL_NO_CONTEXT, EGL_NATIVE_SURFACE_TIZEN, tbmSurface, NULL);
 123
 124         if(shared_info.eglImage_Indicator == NULL)
 125         {
 126             SDL_Log("[SDL] eglImage is NULL");
 127             return;
 128         }
 129         SDL_Log("[SDL] eglImage : %p", shared_info.eglImage_Indicator);
 130         glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, shared_info.eglImage_Indicator);
 131     }
 132     else
 133     {
 134         tbm_surface_info_s info;
 135         tbm_surface_map(tbmSurface, TBM_SURF_OPTION_WRITE|TBM_SURF_OPTION_READ, &info);
 136
 137         SDL_Log("[SDL] Buffer Update %p %p (%dx%d), format:%d", buffer, tbmSurface, info.width, info.height, info.format);
 138         SDL_Log("[SDL] Info size:%d, offset:%d, stride:%d", info.planes[0].size, info.planes[0].offset, info.planes[0].stride);
 139
 140         GLES2_Context Mainctx;
 141         LoadContext(&Mainctx);
 142
 143         Mainctx.glBindTexture(GL_TEXTURE_2D, textureID);
 144         Mainctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, info.planes[0].stride/4, info.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (unsigned int*)info.planes[0].ptr);
 145
 146         if (tbm_surface_unmap (tbmSurface) != TBM_SURFACE_ERROR_NONE)
 147             SDL_Log("Failed to unmap tbm_surface\n");
 148     }
 149
 150     if (tbm_surface_destroy (tbmSurface) != TBM_SURFACE_ERROR_NONE)
 151         SDL_Log("Failed to destroy tbm_surface\n");
 152
 153 }
 154
 155 static void
 156 _tizen_rs_cb_missing(void *data, struct tizen_remote_surface *trs)
 157 {
 158     SDL_Log("Plug is missing...! ");
 159 }
 160
 161 static const struct tizen_remote_surface_listener _extn_gl_plug_listener =
 162 {
 163     _tizen_rs_cb_buffer_update,
 164     _tizen_rs_cb_missing,
 165 };
 166
 167 Uint32 _tizen_timer_callback_indicator(void *data)
 168 {
 169     SDL_VideoDevice *_this = SDL_GetVideoDevice();
 170
 171     Tizen_DrawIndicator(_this->windows);
 172     SDL_EGL_SwapBuffers(_this, ((SDL_WindowData *) _this->windows->driverdata)->egl_surface);
 173
 174     return  ECORE_CALLBACK_RENEW;
 175 }
 176
 177 int
 178 _tizen_indicator_event_filter()
 179 {
 180     SDL_Window *window = SDL_GetVideoDevice()->windows;
 181     SDL_WindowData *wind = window->driverdata;
 182
 183     if(wind->indicator_show && wind->indicator_timer == NULL)
 184     {
 185         wind->indicator_timer = ecore_timer_add(0.02, _tizen_timer_callback_indicator, NULL);
 186     }
 187     else if(!wind->indicator_show && wind->indicator_timer != NULL)
 188     {
 189         ecore_timer_del(wind ->indicator_timer);
 190         wind->indicator_timer = NULL;
 191     }
 192
 193     return 1;
 194 }
 195
 196 int
 197 Tizen_GLES_LoadLibrary(_THIS, const char *path)
 198 {
 199     int ret;
 200
 201     ret = SDL_EGL_LoadLibrary(_this, path, (NativeDisplayType)ecore_wl_display_get());
 202     return ret;
 203 }
 204
 205 static GLuint LoadShader(GLES2_Context* Mainctx, const char *shaderSrc, GLenum type)
 206 {
 207     GLuint shader;
 208     GLint compiled;
 209
 210     shader = Mainctx->glCreateShader(type);
 211     SDL_Log("shader == %d", shader);
 212     if(shader == 0)
 213         return 0;
 214     Mainctx->glShaderSource(shader, 1, &shaderSrc, NULL);
 215     Mainctx->glCompileShader(shader);
 216     Mainctx->glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
 217     if(!compiled)
 218     {
 219         GLint infoLen = 0;
 220         Mainctx->glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
 221         if(infoLen > 1)
 222         {
 223             char* infoLog = (char*)(malloc(sizeof(char) * infoLen));
 224             Mainctx->glGetShaderInfoLog(shader, infoLen, NULL, infoLog);
 225             SDL_Log("Error compiling shader: %s", infoLog );
 226             free(infoLog);
 227         }
 228         Mainctx->glDeleteShader(shader);
 229         return 0;
 230     }
 231     return shader;
 232
 233 }
 234
 235 extern void ModelMatrixLoadIdentity(ModelMatrix* matrix)
 236 {
 237     matrix->m[0][0] = 1.0f;
 238     matrix->m[0][1] = 0.0f;
 239     matrix->m[0][2] = 0.0f;
 240     matrix->m[0][3] = 0.0f;
 241
 242     matrix->m[1][0] = 0.0f;
 243     matrix->m[1][1] = 1.0f;
 244     matrix->m[1][2] = 0.0f;
 245     matrix->m[1][3] = 0.0f;
 246
 247     matrix->m[2][0] = 0.0f;
 248     matrix->m[2][1] = 0.0f;
 249     matrix->m[2][2] = 1.0f;
 250     matrix->m[2][3] = 0.0f;
 251
 252     matrix->m[3][0] = 0.0f;
 253     matrix->m[3][1] = 0.0f;
 254     matrix->m[3][2] = 0.0f;
 255     matrix->m[3][3] = 1.0f;
 256 }
 257
 258 static void ModelMatrixTranslate(ModelMatrix* matrix, GLfloat x, GLfloat y, GLfloat z)
 259 {
 260     matrix->m[3][0] += (matrix->m[0][0] * x + matrix->m[1][0] * y + matrix->m[2][0] * z);
 261     matrix->m[3][1] += (matrix->m[0][1] * x + matrix->m[1][1] * y + matrix->m[2][1] * z);
 262     matrix->m[3][2] += (matrix->m[0][2] * x + matrix->m[1][2] * y + matrix->m[2][2] * z);
 263     matrix->m[3][3] += (matrix->m[0][3] * x + matrix->m[1][3] * y + matrix->m[2][3] * z);
 264 }
 265
 266 void ModelMatrixTranslateInit(ModelMatrix* matrix)
 267 {
 268     matrix->m[3][0] = matrix->m[3][1] = matrix->m[3][2] =0;
 269     matrix->m[3][3] = 1;
 270 }
 271
 272 void multiply_matrix(ModelMatrix *lhs, ModelMatrix *rhs, ModelMatrix *r)
 273 {
 274     int i, j, k;
 275     float tmp[4][4];
 276
 277     for (i = 0; i < 4; i++) {
 278         for (j = 0; j < 4; j++) {
 279             tmp[j][i] = 0.0;
 280
 281             for (k = 0; k < 4; k++) {
 282                 tmp[j][i] += lhs->m[k][i] * rhs->m[j][k];
 283             }
 284         }
 285     }
 286     for (i = 0; i < 4; i++) {
 287        for (j=0; j<4; j++) {
 288            r->m[i][j] = tmp[i][j];
 289        }
 290     }
 291 }
 292
 293 void rotate_indicator(ModelMatrix* matrix, const float anglex, const float angley, const float anglez)
 294 {
 295     const float pi = 3.141592f;
 296     ModelMatrix* temp = (ModelMatrix*)malloc(sizeof(ModelMatrix));
 297     float rz = 2.0f * pi * anglez / 360.0f;
 298     float rx = 2.0f * pi * anglex / 360.0f;
 299     float ry = 2.0f * pi * angley / 360.0f;
 300     float sy = SDL_sinf(ry);
 301     float cy = SDL_cosf(ry);
 302     float sx = SDL_sinf(rx);
 303     float cx = SDL_cosf(rx);
 304     float sz = SDL_sinf(rz);
 305     float cz = SDL_cosf(rz);
 306
 307     ModelMatrixLoadIdentity(temp);
 308
 309     temp->m[0][0] = cy * cz - sx * sy * sz;
 310     temp->m[0][1] = cz * sx * sy + cy * sz;
 311     temp->m[0][2] = -cx * sy;
 312     temp->m[1][0] = -cx * sz;
 313     temp->m[1][1] = cx * cz;
 314     temp->m[1][2] = sx;
 315
 316     temp->m[2][0] = cz * sy + cy * sx * sz;
 317     temp->m[2][1] = -cy * cz * sx + sy * sz;
 318     temp->m[2][2] = cx * cy;
 319
 320     multiply_matrix(matrix, temp, matrix);
 321     free(temp);
 322 }
 323
 324 void Tizen_remote_indicator(int res_id)
 325 {
 326     if(!shared_info.tizen_rs) {
 327         //create tizen_remote_surface
 328         shared_info.tizen_rs = tizen_remote_surface_manager_create_surface(shared_info.tizen_rsm, res_id, shared_info.wl_tbm);
 329         if(!shared_info.tizen_rs)
 330         {
 331             SDL_Log("tizen_rs is NULL");
 332             return;
 333         }
 334         tizen_remote_surface_add_listener(shared_info.tizen_rs, &_extn_gl_plug_listener, NULL);
 335         tizen_remote_surface_redirect(shared_info.tizen_rs);
 336     }
 337 }
 338
 339 void Tizen_glTexImage2D(int idx)
 340 {
 341     GLES2_Context Mainctx;
 342     LoadContext(&Mainctx);
 343
 344     Mainctx.glBindTexture(GL_TEXTURE_2D, textureID);
 345     Mainctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, shared_info.fileInfo[idx].ImageWidth, shared_info.fileInfo[idx].ImageHeight,
 346                       0, GL_RGBA, GL_UNSIGNED_BYTE, (unsigned char*)(shared_info.fileInfo[idx].sharedFile->address));
 347 }
 348
 349 void Tizen_DrawIndicator(SDL_Window *window)
 350 {
 351     SDL_WindowData* wdata = (SDL_WindowData*)window->driverdata;
 352     if (wdata->received_rotation == 1) {
 353         ecore_wl_window_rotation_change_done_send(wdata->window);
 354         wdata->received_rotation = 0;
 355     }
 356     if(!(window->flags & SDL_WINDOW_FULLSCREEN) && !(window->flags & SDL_WINDOW_BORDERLESS) && wdata->indicator_show)
 357     {
 358         if(wdata->last_indicator_showtime + 3000< SDL_GetTicks())
 359         {
 360             ModelMatrixTranslate(&mMatrix, 0.0f, 0.02f, 0.0f);
 361         }
 362         if(wdata->last_indicator_showtime + 3500 <SDL_GetTicks()) {
 363             wdata->indicator_show = SDL_FALSE;
 364             _tizen_indicator_event_filter();
 365         }
 366         GLES2_Context Mainctx;
 367         LoadContext(&Mainctx);
 368         Mainctx.glViewport(0, 0, window->w, window->h);
 369         Mainctx.glUseProgram(programObject);
 370
 371         Mainctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 372         Mainctx.glVertexAttribPointer(vIndex, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
 373         Mainctx.glVertexAttribPointer(cIndex, 2, GL_FLOAT, GL_FALSE, 0, vCoord);
 374         Mainctx.glUniformMatrix4fv(Mainctx.glGetUniformLocation(programObject,  "modelMatrix"), 1, GL_FALSE, mMatrix.m);
 375
 376         Mainctx.glEnableVertexAttribArray(vIndex);
 377         Mainctx.glEnableVertexAttribArray(cIndex);
 378
 379         GLboolean isDepthTest = Mainctx.glIsEnabled(GL_DEPTH_TEST);
 380         if(isDepthTest) Mainctx.glDisable(GL_DEPTH_TEST);
 381         Mainctx.glDrawArrays(GL_TRIANGLES, 0, 6);
 382
 383         if(isDepthTest) Mainctx.glEnable(GL_DEPTH_TEST);
 384         Mainctx.glDisableVertexAttribArray(vIndex);
 385         Mainctx.glDisableVertexAttribArray(cIndex);
 386     }
 387 }
 388
 389 SDL_bool Tizen_remote_surface_init(void)
 390 {
 391     Eina_Inlist *globals;
 392     Ecore_Wl_Global *global;
 393     struct wl_registry *registry;
 394     if (!shared_info.tizen_rsm)
 395     {
 396         registry = ecore_wl_registry_get();
 397         globals = ecore_wl_globals_get();
 398
 399         if (!registry || !globals)
 400           {
 401              SDL_Log( "Could not get registry(%p) or global list(%p)\n", registry, globals);
 402              return SDL_FALSE;
 403           }
 404
 405         EINA_INLIST_FOREACH(globals, global)
 406           {
 407              if (!strcmp(global->interface, "tizen_remote_surface_manager"))
 408                {
 409                   shared_info.tizen_rsm = wl_registry_bind(registry, global->id,
 410                                       &tizen_remote_surface_manager_interface, 1);
 411                    SDL_Log("[SDL] Create tizen_rsm : %p",shared_info.tizen_rsm);
 412                }
 413           }
 414         shared_info.tizen_rs = NULL;
 415     }
 416     if (!shared_info.tizen_rsm)
 417     {
 418         SDL_Log("Could not bind tizen_remote_surface_manager");
 419         return SDL_FALSE;
 420     }
 421
 422     if(!shared_info.tbm_client)
 423     {
 424         shared_info.tbm_client = (struct wayland_tbm_client *)wayland_tbm_client_init(ecore_wl_display_get());
 425         shared_info.wl_tbm = (struct wl_tbm *)wayland_tbm_client_get_wl_tbm(shared_info.tbm_client);
 426         if (!shared_info.wl_tbm)
 427         {
 428             SDL_Log("[SDL]wl_tbm is NULL");
 429             return SDL_FALSE;
 430         }
 431     }
 432
 433     eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)SDL_GetVideoDevice()->egl_data->eglGetProcAddress("eglCreateImageKHR");
 434     eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)SDL_GetVideoDevice()->egl_data->eglGetProcAddress("eglDestroyImageKHR");
 435     glEGLImageTargetTexture2DOES = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)SDL_GetVideoDevice()->egl_data->eglGetProcAddress("glEGLImageTargetTexture2DOES");
 436
 437     return SDL_TRUE;
 438 }
 439
 440 int Tizen_FiniIndicator()
 441 {
 442     int n;
 443     for (n=0; n < SHARED_FILE_NUMBER; n++)
 444         Tizen_Indicator_SharedFile_Free(&shared_info, n);
 445
 446     if(shared_info.eglImage_Indicator != NULL)
 447         eglDestroyImageKHR(SDL_GetVideoDevice()->egl_data->egl_display, shared_info.eglImage_Indicator);
 448
 449     if (shared_info.tizen_rs)
 450         tizen_remote_surface_destroy(shared_info.tizen_rs);
 451     if (shared_info.tbm_client)
 452         wayland_tbm_client_deinit(shared_info.tbm_client);
 453     if (shared_info.tizen_rsm)
 454         tizen_remote_surface_manager_destroy(shared_info.tizen_rsm);
 455
 456     GLES2_Context Mainctx;
 457     LoadContext(&Mainctx);
 458     Mainctx.glDeleteProgram(programObject);
 459     return SDL_TRUE;
 460 }
 461
 462 int Indicator_GLES_Init(SDL_Window* window)
 463 {
 464     SDL_WindowData *wind = window->driverdata;
 465     ecore_wl_indicator_visible_type_set(wind->window, ECORE_WL_INDICATOR_VISIBLE_TYPE_SHOWN);
 466     ecore_wl_window_indicator_opacity_set(wind->window, ECORE_WL_INDICATOR_OPAQUE);
 467     ecore_wl_window_indicator_state_set(wind->window, ECORE_WL_INDICATOR_STATE_ON);
 468
 469     Ecore_Ipc_Server* IpcServer = serverConnection("elm_indicator", &shared_info);
 470     if(!IpcServer)
 471     {
 472         SDL_Log("Fail to connect elm_indicator!\n");
 473         return 0;
 474     }
 475
 476     GLchar vShaderStr[] =
 477         "attribute vec4 vVertices;\n"
 478         "attribute vec2 vCoord;\n"
 479         "uniform mat4 modelMatrix;\n"
 480         "varying vec2 Coord;\n"
 481         "void main()\n"
 482         "{\n"
 483         "    gl_Position = modelMatrix * vVertices;\n"
 484         "    Coord = vCoord;\n"
 485         "}\n";
 486
 487     GLchar fShaderStr[] =
 488         "precision mediump float;\n"
 489         "varying vec2 Coord;\n"
 490         "uniform sampler2D s_texture;\n"
 491         "void main()\n"
 492         "{\n"
 493         " gl_FragColor = texture2D(s_texture,Coord);\n"
 494         "}\n";
 495
 496     GLuint vertexShader;
 497     GLuint fragmentShader;
 498
 499     GLint linked;
 500
 501     GLES2_Context Mainctx;
 502     LoadContext(&Mainctx);
 503
 504     vertexShader = LoadShader(&Mainctx, vShaderStr, GL_VERTEX_SHADER);
 505     fragmentShader = LoadShader(&Mainctx, fShaderStr, GL_FRAGMENT_SHADER);
 506     SDL_Log("The vertex shader is %d", vertexShader);
 507     SDL_Log("The fragment shader is %d", fragmentShader);
 508
 509     programObject = Mainctx.glCreateProgram();
 510     if(programObject == 0)
 511         return 0;
 512
 513     Mainctx.glAttachShader(programObject, vertexShader);
 514     Mainctx.glAttachShader(programObject, fragmentShader);
 515
 516     Mainctx.glLinkProgram(programObject);
 517     Mainctx.glGetProgramiv(programObject, GL_LINK_STATUS, &linked);
 518
 519     if(!linked)
 520     {
 521         GLint infoLen = 0;
 522         Mainctx.glGetProgramiv(programObject, GL_INFO_LOG_LENGTH, &infoLen);
 523         if(infoLen > 1)
 524         {
 525             char* infoLog = (char*)(malloc(sizeof(char) * infoLen));
 526             Mainctx.glGetProgramInfoLog(programObject, infoLen, NULL, infoLog);
 527             SDL_Log("Error linking program: %s", infoLog);
 528             free(infoLog);
 529         }
 530         Mainctx.glDeleteProgram(programObject);
 531         return 0;
 532     }
 533
 534     Mainctx.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 535     Mainctx.glEnable(GL_DEPTH_TEST);
 536
 537     vIndex = Mainctx.glGetAttribLocation(programObject, "vVertices");
 538     cIndex = Mainctx.glGetAttribLocation(programObject, "vCoord");
 539
 540     Mainctx.glBindAttribLocation(programObject, vIndex, "vVertices");
 541     Mainctx.glBindAttribLocation(programObject, cIndex, "vCoord");
 542
 543     ModelMatrixLoadIdentity(&mMatrix);
 544
 545
 546     Mainctx.glGenTextures(1, &textureID);
 547     Mainctx.glBindTexture(GL_TEXTURE_2D, textureID);
 548
 549     Mainctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 550     Mainctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 551     Mainctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 552     Mainctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 553
 554     wind->indicator_show = SDL_TRUE;
 555     wind->last_indicator_showtime = SDL_GetTicks();
 556
 557     ecore_main_loop_iterate();
 558     SDL_IndicatorProcessEvent(window, wind->rotation);
 559     _tizen_indicator_event_filter();
 560
 561     return 1;
 562 }
 563
 564 SDL_GLContext
 565 Tizen_GLES_CreateContext(_THIS, SDL_Window *window)
 566 {
 567     SDL_GLContext context;
 568
 569     context = SDL_EGL_CreateContext(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
 570
 571     if(!(window->flags & SDL_WINDOW_FULLSCREEN) && !(window->flags & SDL_WINDOW_BORDERLESS))
 572     {
 573         SDL_VideoData *data = (SDL_VideoData *) (SDL_GetVideoDevice()->driverdata);
 574         if(data->current_thread != SDL_GetThreadID(0))
 575             return context;
 576         if(!Indicator_GLES_Init(window))
 577         {
 578             SDL_Log("Indicator GLES init error!");
 579         }
 580     }
 581
 582     return context;
 583 }
 584
 585 void
 586 Tizen_GLES_SwapWindow(_THIS, SDL_Window *window)
 587 {
 588     if(!((SDL_WindowData*)window->driverdata)->indicator_show) {
 589         Tizen_DrawIndicator(window);
 590         SDL_EGL_SwapBuffers(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
 591     }
 592 }
 593
 594 int
 595 Tizen_GLES_MakeCurrent(_THIS, SDL_Window *window, SDL_GLContext context)
 596 {
 597     int ret;
 598
 599     if (window && context) {
 600         ret = SDL_EGL_MakeCurrent(_this, ((SDL_WindowData *) window->driverdata)->egl_surface, context);
 601     } else {
 602         ret = SDL_EGL_MakeCurrent(_this, NULL, NULL);
 603     }
 604
 605     return ret;
 606 }
 607
 608 void
 609 Tizen_GLES_DeleteContext(_THIS, SDL_GLContext context)
 610 {
 611     SDL_EGL_DeleteContext(_this, context);
 612 }
 613
 614 void
 615 SDL_IndicatorProcessEvent(SDL_Window *window, int rot)
 616 {
 617     SDL_WindowData *wind = window->driverdata;
 618     if(!(window->flags & SDL_WINDOW_FULLSCREEN) && !(window->flags & SDL_WINDOW_BORDERLESS) && wind->indicator_show)
 619     {
 620         GLES2_Context Mainctx;
 621         LoadContext(&Mainctx);
 622
 623         double ratio = 0.92f;
 624         if( rot == 90 || rot ==270)
 625             ratio = 0.86f;
 626
 627         vVertices[4] = vVertices[7] = vVertices[16] = ratio;
 628
 629         Mainctx.glBindBuffer(GL_ARRAY_BUFFER, indicator_vbo);
 630         Mainctx.glBufferData(GL_ARRAY_BUFFER, 18 * 4, vVertices, GL_STATIC_DRAW);
 631         Mainctx.glBindBuffer(GL_ARRAY_BUFFER, indicator_ibo);
 632         Mainctx.glBufferData(GL_ARRAY_BUFFER, 12 * 4, vCoord, GL_STATIC_DRAW);
 633
 634         ModelMatrixLoadIdentity(&mMatrix);
 635
 636         if (!wind->support_pre_rotation)
 637             rotate_indicator(&mMatrix, 0, 0, rot);
 638
 639         wind->indicator_show = SDL_TRUE;
 640         wind->last_indicator_showtime = SDL_GetTicks();
 641
 642         _tizen_indicator_event_filter();
 643     }
 644 }
 645
 646 #endif /* SDL_VIDEO_DRIVER_TIZEN && SDL_VIDEO_OPENGL_EGL */
 647
 648 /* vi: set ts=4 sw=4 expandtab: */