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
 357     if(wdata->last_indicator_showtime + 3000< SDL_GetTicks())
 358     {
 359         ModelMatrixTranslate(&mMatrix, 0.0f, 0.02f, 0.0f);
 360     }
 361
 362     if(wdata->last_indicator_showtime + 3500 <SDL_GetTicks()) {
 363         wdata->indicator_show = SDL_FALSE;
 364         _tizen_indicator_event_filter();
 365     }
 366
 367     if(!(window->flags & SDL_WINDOW_FULLSCREEN) && !(window->flags & SDL_WINDOW_BORDERLESS) && wdata->indicator_show)
 368     {
 369         GLES2_Context Mainctx;
 370         LoadContext(&Mainctx);
 371         Mainctx.glUseProgram(programObject);
 372
 373         Mainctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
 374         Mainctx.glVertexAttribPointer(vIndex, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
 375         Mainctx.glVertexAttribPointer(cIndex, 2, GL_FLOAT, GL_FALSE, 0, vCoord);
 376         Mainctx.glUniformMatrix4fv(Mainctx.glGetUniformLocation(programObject,  "modelMatrix"), 1, GL_FALSE, mMatrix.m);
 377
 378         Mainctx.glEnableVertexAttribArray(vIndex);
 379         Mainctx.glEnableVertexAttribArray(cIndex);
 380
 381         GLboolean isDepthTest = Mainctx.glIsEnabled(GL_DEPTH_TEST);
 382         if(isDepthTest) Mainctx.glDisable(GL_DEPTH_TEST);
 383         Mainctx.glDrawArrays(GL_TRIANGLES, 0, 6);
 384
 385         if(isDepthTest) Mainctx.glEnable(GL_DEPTH_TEST);
 386         Mainctx.glDisableVertexAttribArray(vIndex);
 387         Mainctx.glDisableVertexAttribArray(cIndex);
 388     }
 389 }
 390
 391 SDL_bool Tizen_remote_surface_init(void)
 392 {
 393     Eina_Inlist *globals;
 394     Ecore_Wl_Global *global;
 395     struct wl_registry *registry;
 396     if (!shared_info.tizen_rsm)
 397     {
 398         registry = ecore_wl_registry_get();
 399         globals = ecore_wl_globals_get();
 400
 401         if (!registry || !globals)
 402           {
 403              SDL_Log( "Could not get registry(%p) or global list(%p)\n", registry, globals);
 404              return SDL_FALSE;
 405           }
 406
 407         EINA_INLIST_FOREACH(globals, global)
 408           {
 409              if (!strcmp(global->interface, "tizen_remote_surface_manager"))
 410                {
 411                   shared_info.tizen_rsm = wl_registry_bind(registry, global->id,
 412                                       &tizen_remote_surface_manager_interface, 1);
 413                    SDL_Log("[SDL] Create tizen_rsm : %p",shared_info.tizen_rsm);
 414                }
 415           }
 416         shared_info.tizen_rs = NULL;
 417     }
 418     if (!shared_info.tizen_rsm)
 419     {
 420         SDL_Log("Could not bind tizen_remote_surface_manager");
 421         return SDL_FALSE;
 422     }
 423
 424     if(!shared_info.tbm_client)
 425     {
 426         shared_info.tbm_client = (struct wayland_tbm_client *)wayland_tbm_client_init(ecore_wl_display_get());
 427         shared_info.wl_tbm = (struct wl_tbm *)wayland_tbm_client_get_wl_tbm(shared_info.tbm_client);
 428         if (!shared_info.wl_tbm)
 429         {
 430             SDL_Log("[SDL]wl_tbm is NULL");
 431             return SDL_FALSE;
 432         }
 433     }
 434
 435     eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)SDL_GetVideoDevice()->egl_data->eglGetProcAddress("eglCreateImageKHR");
 436     eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)SDL_GetVideoDevice()->egl_data->eglGetProcAddress("eglDestroyImageKHR");
 437     glEGLImageTargetTexture2DOES = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)SDL_GetVideoDevice()->egl_data->eglGetProcAddress("glEGLImageTargetTexture2DOES");
 438
 439     return SDL_TRUE;
 440 }
 441
 442 int Tizen_FiniIndicator()
 443 {
 444     int n;
 445     for (n=0; n < SHARED_FILE_NUMBER; n++)
 446         Tizen_Indicator_SharedFile_Free(&shared_info, n);
 447
 448     if(shared_info.eglImage_Indicator != NULL)
 449         eglDestroyImageKHR(SDL_GetVideoDevice()->egl_data->egl_display, shared_info.eglImage_Indicator);
 450
 451     if (shared_info.tizen_rs)
 452         tizen_remote_surface_destroy(shared_info.tizen_rs);
 453     if (shared_info.tbm_client)
 454         wayland_tbm_client_deinit(shared_info.tbm_client);
 455     if (shared_info.tizen_rsm)
 456         tizen_remote_surface_manager_destroy(shared_info.tizen_rsm);
 457
 458     GLES2_Context Mainctx;
 459     LoadContext(&Mainctx);
 460     Mainctx.glDeleteProgram(programObject);
 461     return SDL_TRUE;
 462 }
 463
 464 int Indicator_GLES_Init(SDL_Window* window)
 465 {
 466     SDL_WindowData *wind = window->driverdata;
 467     ecore_wl_indicator_visible_type_set(wind->window, ECORE_WL_INDICATOR_VISIBLE_TYPE_SHOWN);
 468     ecore_wl_window_indicator_opacity_set(wind->window, ECORE_WL_INDICATOR_OPAQUE);
 469     ecore_wl_window_indicator_state_set(wind->window, ECORE_WL_INDICATOR_STATE_ON);
 470
 471     Ecore_Ipc_Server* IpcServer = serverConnection("elm_indicator", &shared_info);
 472     if(!IpcServer)
 473     {
 474         SDL_Log("Fail to connect elm_indicator!\n");
 475         return 0;
 476     }
 477
 478     GLchar vShaderStr[] =
 479         "attribute vec4 vVertices;\n"
 480         "attribute vec2 vCoord;\n"
 481         "uniform mat4 modelMatrix;\n"
 482         "varying vec2 Coord;\n"
 483         "void main()\n"
 484         "{\n"
 485         "    gl_Position = modelMatrix * vVertices;\n"
 486         "    Coord = vCoord;\n"
 487         "}\n";
 488
 489     GLchar fShaderStr[] =
 490         "precision mediump float;\n"
 491         "varying vec2 Coord;\n"
 492         "uniform sampler2D s_texture;\n"
 493         "void main()\n"
 494         "{\n"
 495         " gl_FragColor = texture2D(s_texture,Coord);\n"
 496         "}\n";
 497
 498     GLuint vertexShader;
 499     GLuint fragmentShader;
 500
 501     GLint linked;
 502
 503     GLES2_Context Mainctx;
 504     LoadContext(&Mainctx);
 505
 506     vertexShader = LoadShader(&Mainctx, vShaderStr, GL_VERTEX_SHADER);
 507     fragmentShader = LoadShader(&Mainctx, fShaderStr, GL_FRAGMENT_SHADER);
 508     SDL_Log("The vertex shader is %d", vertexShader);
 509     SDL_Log("The fragment shader is %d", fragmentShader);
 510
 511     programObject = Mainctx.glCreateProgram();
 512     if(programObject == 0)
 513         return 0;
 514
 515     Mainctx.glAttachShader(programObject, vertexShader);
 516     Mainctx.glAttachShader(programObject, fragmentShader);
 517
 518     Mainctx.glLinkProgram(programObject);
 519     Mainctx.glGetProgramiv(programObject, GL_LINK_STATUS, &linked);
 520
 521     if(!linked)
 522     {
 523         GLint infoLen = 0;
 524         Mainctx.glGetProgramiv(programObject, GL_INFO_LOG_LENGTH, &infoLen);
 525         if(infoLen > 1)
 526         {
 527             char* infoLog = (char*)(malloc(sizeof(char) * infoLen));
 528             Mainctx.glGetProgramInfoLog(programObject, infoLen, NULL, infoLog);
 529             SDL_Log("Error linking program: %s", infoLog);
 530             free(infoLog);
 531         }
 532         Mainctx.glDeleteProgram(programObject);
 533         return 0;
 534     }
 535
 536     Mainctx.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 537     Mainctx.glEnable(GL_DEPTH_TEST);
 538
 539     vIndex = Mainctx.glGetAttribLocation(programObject, "vVertices");
 540     cIndex = Mainctx.glGetAttribLocation(programObject, "vCoord");
 541
 542     Mainctx.glBindAttribLocation(programObject, vIndex, "vVertices");
 543     Mainctx.glBindAttribLocation(programObject, cIndex, "vCoord");
 544
 545     ModelMatrixLoadIdentity(&mMatrix);
 546
 547
 548     Mainctx.glGenTextures(1, &textureID);
 549     Mainctx.glBindTexture(GL_TEXTURE_2D, textureID);
 550
 551     Mainctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 552     Mainctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 553     Mainctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 554     Mainctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 555
 556     wind->indicator_show = SDL_TRUE;
 557     wind->last_indicator_showtime = SDL_GetTicks();
 558
 559     ecore_main_loop_iterate();
 560     SDL_IndicatorProcessEvent(window, wind->rotation);
 561     _tizen_indicator_event_filter();
 562
 563     return 1;
 564 }
 565
 566 SDL_GLContext
 567 Tizen_GLES_CreateContext(_THIS, SDL_Window *window)
 568 {
 569     SDL_GLContext context;
 570
 571     context = SDL_EGL_CreateContext(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
 572
 573     if(!(window->flags & SDL_WINDOW_FULLSCREEN) && !(window->flags & SDL_WINDOW_BORDERLESS))
 574     {
 575         if(!Indicator_GLES_Init(window))
 576         {
 577             SDL_Log("Indicator GLES init error!");
 578         }
 579     }
 580
 581     return context;
 582 }
 583
 584 void
 585 Tizen_GLES_SwapWindow(_THIS, SDL_Window *window)
 586 {
 587     if(!((SDL_WindowData*)window->driverdata)->indicator_show) {
 588         Tizen_DrawIndicator(window);
 589         SDL_EGL_SwapBuffers(_this, ((SDL_WindowData *) window->driverdata)->egl_surface);
 590     }
 591 }
 592
 593 int
 594 Tizen_GLES_MakeCurrent(_THIS, SDL_Window *window, SDL_GLContext context)
 595 {
 596     int ret;
 597
 598     if (window && context) {
 599         ret = SDL_EGL_MakeCurrent(_this, ((SDL_WindowData *) window->driverdata)->egl_surface, context);
 600     } else {
 601         ret = SDL_EGL_MakeCurrent(_this, NULL, NULL);
 602     }
 603
 604     return ret;
 605 }
 606
 607 void
 608 Tizen_GLES_DeleteContext(_THIS, SDL_GLContext context)
 609 {
 610     SDL_EGL_DeleteContext(_this, context);
 611 }
 612
 613 void
 614 SDL_IndicatorProcessEvent(SDL_Window *window, int rot)
 615 {
 616     GLES2_Context Mainctx;
 617     LoadContext(&Mainctx);
 618
 619     SDL_WindowData *wind = window->driverdata;
 620
 621     double ratio = 0.92f;
 622     if( rot == 90 || rot ==270)
 623         ratio = 0.86f;
 624
 625     vVertices[4] = vVertices[7] = vVertices[16] = ratio;
 626
 627     Mainctx.glBindBuffer(GL_ARRAY_BUFFER, indicator_vbo);
 628     Mainctx.glBufferData(GL_ARRAY_BUFFER, 18 * 4, vVertices, GL_STATIC_DRAW);
 629     Mainctx.glBindBuffer(GL_ARRAY_BUFFER, indicator_ibo);
 630     Mainctx.glBufferData(GL_ARRAY_BUFFER, 12 * 4, vCoord, GL_STATIC_DRAW);
 631
 632     ModelMatrixLoadIdentity(&mMatrix);
 633
 634     if (!wind->support_pre_rotation)
 635         rotate_indicator(&mMatrix, 0, 0, rot);
 636
 637     wind->indicator_show = SDL_TRUE;
 638     wind->last_indicator_showtime = SDL_GetTicks();
 639
 640
 641     _tizen_indicator_event_filter();
 642
 643 }
 644
 645 #endif /* SDL_VIDEO_DRIVER_TIZEN && SDL_VIDEO_OPENGL_EGL */
 646
 647 /* vi: set ts=4 sw=4 expandtab: */