src/modules/engines/gl_sdl/evas_engine.c

   1 #include "evas_common.h"
   2 #include "evas_engine.h"
   3
   4 #include <dlfcn.h>      /* dlopen,dlclose,etc */
   5
   6 static void*                     _sdl_output_setup      (int w, int h, int fullscreen, int noframe);
   7
   8 int _evas_engine_GL_SDL_log_dom = -1;
   9 /* function tables - filled in later (func and parent func) */
  10 static Evas_Func func, pfunc;
  11
  12 static void *
  13 eng_info(Evas *e)
  14 {
  15    Evas_Engine_Info_GL_SDL *info;
  16
  17    info = calloc(1, sizeof(Evas_Engine_Info_GL_SDL));
  18    if (!info) return NULL;
  19    info->magic.magic = rand();
  20    return info;
  21 }
  22
  23 static void
  24 eng_info_free(Evas *e __UNUSED__, void *info)
  25 {
  26    Evas_Engine_Info_GL_SDL *in;
  27    in = (Evas_Engine_Info_GL_SDL *)info;
  28    free(in);
  29 }
  30
  31 static int
  32 eng_setup(Evas *e, void *in)
  33 {
  34    Render_Engine *re;
  35    Evas_Engine_Info_GL_SDL *info;
  36
  37    info = (Evas_Engine_Info_GL_SDL *)in;
  38
  39    SDL_Init(SDL_INIT_NOPARACHUTE);
  40
  41    if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
  42      {
  43         ERR("SDL_Init failed with %s", SDL_GetError());
  44         SDL_Quit();
  45         return 0;
  46      }
  47
  48    re = _sdl_output_setup(e->output.w, e->output.h,
  49                              info->flags.fullscreen,
  50                              info->flags.noframe);
  51    re->info = info;
  52    e->engine.data.output = re;
  53    if (!e->engine.data.output)
  54      return 0;
  55
  56    e->engine.func = &func;
  57    e->engine.data.context = e->engine.func->context_new(e->engine.data.output);
  58
  59    return 1;
  60 }
  61
  62 static void
  63 eng_output_free(void *data)
  64 {
  65    Render_Engine *re;
  66
  67    re = (Render_Engine *)data;
  68    evas_gl_common_context_free(re->gl_context);
  69    free(re);
  70
  71    evas_common_font_shutdown();
  72    evas_common_image_shutdown();
  73
  74    SDL_QuitSubSystem(SDL_INIT_VIDEO);
  75 }
  76
  77 static void
  78 eng_output_resize(void *data, int w, int h)
  79 {
  80    Render_Engine        *re;
  81    SDL_Surface          *surface;
  82
  83    re = (Render_Engine *)data;
  84    re->w = w;
  85    re->h = h;
  86
  87    if(SDL_GetVideoSurface()->flags & SDL_RESIZABLE)
  88      {
  89         surface = SDL_SetVideoMode(w, h, 32, EVAS_SDL_GL_FLAG
  90                       | (re->info->flags.fullscreen ? SDL_FULLSCREEN : 0)
  91                       | (re->info->flags.noframe ? SDL_NOFRAME : 0));
  92         if (!surface)
  93           {
  94              ERR("Unable to change the resolution to : %ix%i", w, h);
  95              SDL_Quit();
  96              exit(-1);
  97           }
  98      }
  99
 100    evas_gl_common_context_resize(re->gl_context, w, h);
 101 }
 102
 103 static void
 104 eng_output_tile_size_set(void *data, int w __UNUSED__, int h __UNUSED__)
 105 {
 106 //   Render_Engine *re;
 107 //
 108 //   re = (Render_Engine *)data;
 109 }
 110
 111 static void
 112 eng_output_redraws_rect_add(void *data, int x, int y, int w, int h)
 113 {
 114    Render_Engine *re;
 115
 116    re = (Render_Engine *)data;
 117    evas_gl_common_context_resize(re->gl_context, re->w, re->h);
 118    /* smple bounding box */
 119    if (!re->draw.redraw)
 120      {
 121 #if 0
 122         re->draw.x1 = x;
 123         re->draw.y1 = y;
 124         re->draw.x2 = x + w - 1;
 125         re->draw.y2 = y + h - 1;
 126 #else
 127         re->draw.x1 = 0;
 128         re->draw.y1 = 0;
 129         re->draw.x2 = re->w - 1;
 130         re->draw.y2 = re->h - 1;
 131 #endif
 132      }
 133    else
 134      {
 135         if (x < re->draw.x1) re->draw.x1 = x;
 136         if (y < re->draw.y1) re->draw.y1 = y;
 137         if ((x + w - 1) > re->draw.x2) re->draw.x2 = x + w - 1;
 138         if ((y + h - 1) > re->draw.y2) re->draw.y2 = y + h - 1;
 139      }
 140    re->draw.redraw = 1;
 141 }
 142
 143 static void
 144 eng_output_redraws_rect_del(void *data, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
 145 {
 146 //   Render_Engine *re;
 147 //
 148 //   re = (Render_Engine *)data;
 149 }
 150
 151 static void
 152 eng_output_redraws_clear(void *data)
 153 {
 154    Render_Engine *re;
 155
 156    re = (Render_Engine *)data;
 157    re->draw.redraw = 0;
 158 //   INF("GL: finish update cycle!");
 159 }
 160
 161 /* at least the nvidia drivers are so abysmal that copying from the backbuffer
 162  * to the front using glCopyPixels() that you literally can WATCH it draw the
 163  * pixels slowly across the screen with a window update taking multiple
 164  * seconds - so workaround by doing a full buffer render as frankly GL isn't
 165  * up to doing anything that isn't done by quake (etc.)
 166  */
 167 #define SLOW_GL_COPY_RECT 1
 168 /* vsync games - not for now though */
 169 //#define VSYNC_TO_SCREEN 1
 170
 171 static void *
 172 eng_output_redraws_next_update_get(void *data, int *x, int *y, int *w, int *h, int *cx, int *cy, int *cw, int *ch)
 173 {
 174    Render_Engine *re;
 175
 176    re = (Render_Engine *)data;
 177    evas_gl_common_context_flush(re->gl_context);
 178    /* get the upate rect surface - return engine data as dummy */
 179    if (!re->draw.redraw)
 180      {
 181 //      printf("GL: NO updates!\n");
 182         return NULL;
 183      }
 184 //   printf("GL: update....!\n");
 185 #ifdef SLOW_GL_COPY_RECT
 186    /* if any update - just return the whole canvas - works with swap
 187     * buffers then */
 188    if (x) *x = 0;
 189    if (y) *y = 0;
 190    if (w) *w = re->w;
 191    if (h) *h = re->h;
 192    if (cx) *cx = 0;
 193    if (cy) *cy = 0;
 194    if (cw) *cw = re->w;
 195    if (ch) *ch = re->h;
 196 #else
 197    /* 1 update - INCREDIBLY SLOW if combined with swap_rect in flush. a gl
 198     * problem where there just is no hardware path for somethnig that
 199     * obviously SHOULD be there */
 200    /* only 1 update to minimise gl context games and rendering multiple update
 201     * regions as evas does with other engines
 202     */
 203    if (x) *x = re->draw.x1;
 204    if (y) *y = re->draw.y1;
 205    if (w) *w = re->draw.x2 - re->draw.x1 + 1;
 206    if (h) *h = re->draw.y2 - re->draw.y1 + 1;
 207    if (cx) *cx = re->draw.x1;
 208    if (cy) *cy = re->draw.y1;
 209    if (cw) *cw = re->draw.x2 - re->draw.x1 + 1;
 210    if (ch) *ch = re->draw.y2 - re->draw.y1 + 1;
 211 #endif
 212 // clear buffer. only needed for dest alpha
 213 //   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 214 //   glClear(GL_COLOR_BUFFER_BIT);
 215 //x//   printf("frame -> new\n");
 216    return re->gl_context->def_surface;
 217 }
 218
 219 static void
 220 eng_output_redraws_next_update_push(void *data, void *surface __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
 221 {
 222    Render_Engine *re;
 223
 224    re = (Render_Engine *)data;
 225    /* put back update surface.. in this case just unflag redraw */
 226    re->draw.redraw = 0;
 227    re->draw.drew = 1;
 228    evas_gl_common_context_flush(re->gl_context);
 229 //x//   printf("frame -> push\n");
 230 }
 231
 232 static void
 233 eng_output_flush(void *data)
 234 {
 235    Render_Engine *re;
 236
 237    re = (Render_Engine *)data;
 238    if (!re->draw.drew) return;
 239 //x//   printf("frame -> flush\n");
 240    re->draw.drew = 0;
 241
 242 #if 0
 243 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
 244 //   glFlush();
 245    eglSwapBuffers(re->egl_disp, re->egl_surface[0]);
 246 #else
 247    glXSwapBuffers(re->win->disp, re->win);
 248 #endif
 249 #else
 250    SDL_GL_SwapBuffers();
 251 #endif
 252 }
 253
 254 static void
 255 eng_output_idle_flush(void *data)
 256 {
 257 //   Render_Engine *re;
 258 //
 259 //   re = (Render_Engine *)data;
 260 }
 261
 262 static void
 263 eng_context_cutout_add(void *data, void *context, int x, int y, int w, int h)
 264 {
 265 //   Render_Engine *re;
 266 //
 267 //   re = (Render_Engine *)data;
 268 //   re->gl_context->dc = context;
 269    evas_common_draw_context_add_cutout(context, x, y, w, h);
 270 }
 271
 272 static void
 273 eng_context_cutout_clear(void *data, void *context)
 274 {
 275 //   Render_Engine *re;
 276 //
 277 //   re = (Render_Engine *)data;
 278 //   re->gl_context->dc = context;
 279    evas_common_draw_context_clear_cutouts(context);
 280 }
 281
 282 static void
 283 eng_rectangle_draw(void *data, void *context, void *surface, int x, int y, int w, int h)
 284 {
 285    Render_Engine *re;
 286
 287    re = (Render_Engine *)data;
 288    evas_gl_common_context_target_surface_set(re->gl_context, surface);
 289    re->gl_context->dc = context;
 290    evas_gl_common_rect_draw(re->gl_context, x, y, w, h);
 291 }
 292
 293 static void
 294 eng_line_draw(void *data, void *context, void *surface, int x1, int y1, int x2, int y2)
 295 {
 296    Render_Engine *re;
 297
 298    re = (Render_Engine *)data;
 299    evas_gl_common_context_target_surface_set(re->gl_context, surface);
 300    re->gl_context->dc = context;
 301    evas_gl_common_line_draw(re->gl_context, x1, y1, x2, y2);
 302 }
 303
 304 static void *
 305 eng_polygon_point_add(void *data, void *context __UNUSED__, void *polygon, int x, int y)
 306 {
 307    Render_Engine *re;
 308
 309    re = (Render_Engine *)data;
 310    return evas_gl_common_poly_point_add(polygon, x, y);
 311 }
 312
 313 static void *
 314 eng_polygon_points_clear(void *data, void *context __UNUSED__, void *polygon)
 315 {
 316    Render_Engine *re;
 317
 318    re = (Render_Engine *)data;
 319    return evas_gl_common_poly_points_clear(polygon);
 320 }
 321
 322 static void
 323 eng_polygon_draw(void *data, void *context, void *surface, void *polygon, int x, int y)
 324 {
 325    Render_Engine *re;
 326
 327    re = (Render_Engine *)data;
 328    evas_gl_common_context_target_surface_set(re->gl_context, surface);
 329    re->gl_context->dc = context;
 330    evas_gl_common_poly_draw(re->gl_context, polygon, x, y);
 331 }
 332
 333 static void
 334 eng_gradient2_color_np_stop_insert(void *data __UNUSED__, void *gradient __UNUSED__, int r __UNUSED__, int g __UNUSED__, int b __UNUSED__, int a __UNUSED__, float pos __UNUSED__)
 335 {
 336    evas_common_gradient2_color_np_stop_insert(gradient, r, g, b, a, pos);
 337 }
 338
 339 static void
 340 eng_gradient2_clear(void *data __UNUSED__, void *gradient __UNUSED__)
 341 {
 342    evas_common_gradient2_clear(gradient);
 343 }
 344
 345 static void
 346 eng_gradient2_fill_transform_set(void *data __UNUSED__, void *gradient __UNUSED__, void *transform __UNUSED__)
 347 {
 348    evas_common_gradient2_fill_transform_set(gradient, transform);
 349 }
 350
 351 static void
 352 eng_gradient2_fill_spread_set(void *data __UNUSED__, void *gradient __UNUSED__, int spread __UNUSED__)
 353 {
 354    evas_common_gradient2_fill_spread_set(gradient, spread);
 355 }
 356
 357 static void *
 358 eng_gradient2_linear_new(void *data __UNUSED__)
 359 {
 360    return evas_common_gradient2_linear_new();
 361 }
 362
 363 static void
 364 eng_gradient2_linear_free(void *data __UNUSED__, void *linear_gradient __UNUSED__)
 365 {
 366    evas_common_gradient2_free(linear_gradient);
 367 }
 368
 369 static void
 370 eng_gradient2_linear_fill_set(void *data __UNUSED__, void *linear_gradient __UNUSED__, float x0 __UNUSED__, float y0 __UNUSED__, float x1 __UNUSED__, float y1 __UNUSED__)
 371 {
 372    evas_common_gradient2_linear_fill_set(linear_gradient, x0, y0, x1, y1);
 373 }
 374
 375 static int
 376 eng_gradient2_linear_is_opaque(void *data __UNUSED__, void *context __UNUSED__, void *linear_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
 377 {
 378    RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
 379    RGBA_Gradient2 *gr = (RGBA_Gradient2 *)linear_gradient;
 380
 381    if (!dc || !gr || !gr->type.geometer)  return 0;
 382    return !(gr->type.geometer->has_alpha(gr, dc->render_op) |
 383             gr->type.geometer->has_mask(gr, dc->render_op));
 384 }
 385
 386 static int
 387 eng_gradient2_linear_is_visible(void *data __UNUSED__, void *context __UNUSED__, void *linear_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
 388 {
 389    RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
 390
 391    if (!dc || !linear_gradient)  return 0;
 392    return 1;
 393 }
 394
 395 static void
 396 eng_gradient2_linear_render_pre(void *data __UNUSED__, void *context __UNUSED__, void *linear_gradient __UNUSED__)
 397 {
 398    RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
 399    RGBA_Gradient2 *gr = (RGBA_Gradient2 *)linear_gradient;
 400    int  len;
 401
 402    if (!dc || !gr || !gr->type.geometer)  return;
 403    gr->type.geometer->geom_update(gr);
 404    len = gr->type.geometer->get_map_len(gr);
 405    evas_common_gradient2_map(dc, gr, len);
 406 }
 407
 408 static void
 409 eng_gradient2_linear_render_post(void *data __UNUSED__, void *linear_gradient __UNUSED__)
 410 {
 411 }
 412
 413 static void
 414 eng_gradient2_linear_draw(void *data __UNUSED__, void *context __UNUSED__, void *surface __UNUSED__, void *linear_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
 415 {
 416    Render_Engine *re;
 417
 418    re = (Render_Engine *)data;
 419    re->gl_context->dc = context;
 420      {
 421         Evas_GL_Image *gim;
 422         RGBA_Image *im;
 423         RGBA_Draw_Context *dc = context;
 424         int op = dc->render_op, cuse = dc->clip.use;
 425
 426         im = (RGBA_Image *)evas_cache_image_empty(evas_common_image_cache_get());
 427         im = (RGBA_Image *)evas_cache_image_size_set(&im->cache_entry, w, h);
 428
 429         dc->render_op = _EVAS_RENDER_FILL;
 430         dc->clip.use = 0;
 431
 432         // draw to buf, copy to tex, draw tex
 433         evas_common_gradient2_draw(im, dc, 0, 0, w, h, linear_gradient);
 434
 435         gim = evas_gl_common_image_new_from_data(re->gl_context, w, h,
 436                                                  im->image.data, 1,
 437                                                  EVAS_COLORSPACE_ARGB8888);
 438         dc->render_op = op;
 439         dc->clip.use = cuse;
 440         evas_gl_common_image_draw(re->gl_context, gim, 0, 0, w, h, x, y, w, h, 0);
 441         evas_cache_image_drop(&im->cache_entry);
 442         evas_gl_common_image_free(gim);
 443      }
 444 }
 445
 446 static void *
 447 eng_gradient2_radial_new(void *data __UNUSED__)
 448 {
 449    return evas_common_gradient2_radial_new();
 450 }
 451
 452 static void
 453 eng_gradient2_radial_free(void *data __UNUSED__, void *radial_gradient __UNUSED__)
 454 {
 455    evas_common_gradient2_free(radial_gradient);
 456 }
 457
 458 static void
 459 eng_gradient2_radial_fill_set(void *data __UNUSED__, void *radial_gradient __UNUSED__, float cx __UNUSED__, float cy __UNUSED__, float rx __UNUSED__, float ry __UNUSED__)
 460 {
 461    evas_common_gradient2_radial_fill_set(radial_gradient, cx, cy, rx, ry);
 462 }
 463
 464 static int
 465 eng_gradient2_radial_is_opaque(void *data __UNUSED__, void *context __UNUSED__, void *radial_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
 466 {
 467    RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
 468    RGBA_Gradient2 *gr = (RGBA_Gradient2 *)radial_gradient;
 469
 470    if (!dc || !gr || !gr->type.geometer)  return 0;
 471    return !(gr->type.geometer->has_alpha(gr, dc->render_op) |
 472             gr->type.geometer->has_mask(gr, dc->render_op));
 473 }
 474
 475 static int
 476 eng_gradient2_radial_is_visible(void *data __UNUSED__, void *context __UNUSED__, void *radial_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
 477 {
 478    RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
 479
 480    if (!dc || !radial_gradient)  return 0;
 481    return 1;
 482 }
 483
 484 static void
 485 eng_gradient2_radial_render_pre(void *data __UNUSED__, void *context __UNUSED__, void *radial_gradient __UNUSED__)
 486 {
 487    RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
 488    RGBA_Gradient2 *gr = (RGBA_Gradient2 *)radial_gradient;
 489    int  len;
 490
 491    if (!dc || !gr || !gr->type.geometer)  return;
 492    gr->type.geometer->geom_update(gr);
 493    len = gr->type.geometer->get_map_len(gr);
 494    evas_common_gradient2_map(dc, gr, len);
 495 }
 496
 497 static void
 498 eng_gradient2_radial_render_post(void *data __UNUSED__, void *radial_gradient __UNUSED__)
 499 {
 500 }
 501
 502 static void
 503 eng_gradient2_radial_draw(void *data __UNUSED__, void *context __UNUSED__, void *surface __UNUSED__, void *radial_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
 504 {
 505    Render_Engine *re;
 506
 507    re = (Render_Engine *)data;
 508    re->gl_context->dc = context;
 509      {
 510         Evas_GL_Image *gim;
 511         RGBA_Image *im;
 512         RGBA_Draw_Context *dc = context;
 513         int op = dc->render_op, cuse = dc->clip.use;
 514
 515         im = (RGBA_Image *)evas_cache_image_empty(evas_common_image_cache_get());
 516         im = (RGBA_Image *)evas_cache_image_size_set(&im->cache_entry, w, h);
 517
 518         dc->render_op = _EVAS_RENDER_FILL;
 519         dc->clip.use = 0;
 520
 521         // draw to buf, copy to tex, draw tex
 522         evas_common_gradient2_draw(im, dc, 0, 0, w, h, radial_gradient);
 523
 524         gim = evas_gl_common_image_new_from_data(re->gl_context, w, h,
 525                                                  im->image.data, 1,
 526                                                  EVAS_COLORSPACE_ARGB8888);
 527         dc->render_op = op;
 528         dc->clip.use = cuse;
 529         evas_gl_common_image_draw(re->gl_context, gim, 0, 0, w, h, x, y, w, h, 0);
 530         evas_cache_image_drop(&im->cache_entry);
 531         evas_gl_common_image_free(gim);
 532      }
 533 }
 534
 535 static void *
 536 eng_gradient_new(void *data __UNUSED__)
 537 {
 538    return evas_common_gradient_new();
 539 }
 540
 541 static void
 542 eng_gradient_free(void *data __UNUSED__, void *gradient)
 543 {
 544    evas_common_gradient_free(gradient);
 545 }
 546
 547 static void
 548 eng_gradient_color_stop_add(void *data __UNUSED__, void *gradient, int r, int g, int b, int a, int delta)
 549 {
 550    evas_common_gradient_color_stop_add(gradient, r, g, b, a, delta);
 551 }
 552
 553 static void
 554 eng_gradient_alpha_stop_add(void *data __UNUSED__, void *gradient, int a, int delta)
 555 {
 556    evas_common_gradient_alpha_stop_add(gradient, a, delta);
 557 }
 558
 559 static void
 560 eng_gradient_color_data_set(void *data __UNUSED__, void *gradient, void *map, int len, int has_alpha)
 561 {
 562    evas_common_gradient_color_data_set(gradient, map, len, has_alpha);
 563 }
 564
 565 static void
 566 eng_gradient_alpha_data_set(void *data __UNUSED__, void *gradient, void *alpha_map, int len)
 567 {
 568    evas_common_gradient_alpha_data_set(gradient, alpha_map, len);
 569 }
 570
 571 static void
 572 eng_gradient_clear(void *data __UNUSED__, void *gradient)
 573 {
 574    evas_common_gradient_clear(gradient);
 575 }
 576
 577 static void
 578 eng_gradient_fill_set(void *data __UNUSED__, void *gradient, int x, int y, int w, int h)
 579 {
 580    evas_common_gradient_fill_set(gradient, x, y, w, h);
 581 }
 582
 583 static void
 584 eng_gradient_fill_angle_set(void *data __UNUSED__, void *gradient, double angle)
 585 {
 586    evas_common_gradient_fill_angle_set(gradient, angle);
 587 }
 588
 589 static void
 590 eng_gradient_fill_spread_set(void *data __UNUSED__, void *gradient, int spread)
 591 {
 592    evas_common_gradient_fill_spread_set(gradient, spread);
 593 }
 594
 595 static void
 596 eng_gradient_angle_set(void *data __UNUSED__, void *gradient, double angle)
 597 {
 598    evas_common_gradient_map_angle_set(gradient, angle);
 599 }
 600
 601 static void
 602 eng_gradient_offset_set(void *data __UNUSED__, void *gradient, float offset)
 603 {
 604    evas_common_gradient_map_offset_set(gradient, offset);
 605 }
 606
 607 static void
 608 eng_gradient_direction_set(void *data __UNUSED__, void *gradient, int direction)
 609 {
 610    evas_common_gradient_map_direction_set(gradient, direction);
 611 }
 612
 613 static void
 614 eng_gradient_type_set(void *data __UNUSED__, void *gradient, char *name, char *params)
 615 {
 616    evas_common_gradient_type_set(gradient, name, params);
 617 }
 618
 619 static int
 620 eng_gradient_is_opaque(void *data, void *context, void *gradient, int x, int y, int w, int h)
 621 {
 622    RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
 623    RGBA_Gradient *gr = (RGBA_Gradient *)gradient;
 624
 625    if (!dc || !gr || !gr->type.geometer)  return 0;
 626    return !(gr->type.geometer->has_alpha(gr, dc->render_op) |
 627             gr->type.geometer->has_mask(gr, dc->render_op));
 628 }
 629
 630 static int
 631 eng_gradient_is_visible(void *data, void *context, void *gradient, int x, int y, int w, int h)
 632 {
 633    RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
 634
 635    if (!dc || !gradient)  return 0;
 636    return 1;
 637 }
 638
 639 static void
 640 eng_gradient_render_pre(void *data, void *context, void *gradient)
 641 {
 642    RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
 643    RGBA_Gradient *gr = (RGBA_Gradient *)gradient;
 644    int  len;
 645
 646    if (!dc || !gr || !gr->type.geometer)  return;
 647    gr->type.geometer->geom_set(gr);
 648    len = gr->type.geometer->get_map_len(gr);
 649    evas_common_gradient_map(dc, gr, len);
 650 }
 651
 652 static void
 653 eng_gradient_render_post(void *data __UNUSED__, void *gradient)
 654 {
 655 }
 656
 657 static void
 658 eng_gradient_draw(void *data, void *context, void *surface __UNUSED__, void *gradient, int x, int y, int w, int h)
 659 {
 660    Render_Engine *re;
 661
 662    re = (Render_Engine *)data;
 663    re->gl_context->dc = context;
 664      {
 665         Evas_GL_Image *gim;
 666         RGBA_Image *im;
 667         RGBA_Draw_Context *dc = context;
 668         int op = dc->render_op, cuse = dc->clip.use;
 669
 670         im = (RGBA_Image *)evas_cache_image_empty(evas_common_image_cache_get());
 671         im = (RGBA_Image *)evas_cache_image_size_set(&im->cache_entry, w, h);
 672
 673         dc->render_op = _EVAS_RENDER_FILL;
 674         dc->clip.use = 0;
 675
 676         // draw to buf, copy to tex, draw tex
 677         evas_common_gradient_draw(im, dc, 0, 0, w, h, gradient);
 678
 679         gim = evas_gl_common_image_new_from_data(re->gl_context, w, h,
 680                                                  im->image.data, 1,
 681                                                  EVAS_COLORSPACE_ARGB8888);
 682         dc->render_op = op;
 683         dc->clip.use = cuse;
 684         evas_gl_common_image_draw(re->gl_context, gim, 0, 0, w, h, x, y, w, h, 0);
 685         evas_cache_image_drop(&im->cache_entry);
 686         evas_gl_common_image_free(gim);
 687      }
 688 }
 689
 690 static int
 691 eng_image_alpha_get(void *data, void *image)
 692 {
 693 //   Render_Engine *re;
 694    Evas_GL_Image *im;
 695
 696 //   re = (Render_Engine *)data;
 697    if (!image) return 1;
 698    im = image;
 699    return im->alpha;
 700 }
 701
 702 static int
 703 eng_image_colorspace_get(void *data, void *image)
 704 {
 705 //   Render_Engine *re;
 706    Evas_GL_Image *im;
 707
 708 //   re = (Render_Engine *)data;
 709    if (!image) return EVAS_COLORSPACE_ARGB8888;
 710    im = image;
 711    return im->cs.space;
 712 }
 713
 714 static void *
 715 eng_image_alpha_set(void *data, void *image, int has_alpha)
 716 {
 717    Render_Engine *re;
 718    Evas_GL_Image *im;
 719
 720    re = (Render_Engine *)data;
 721    if (!image) return NULL;
 722    im = image;
 723    if (im->native.data)
 724      {
 725         im->alpha = has_alpha;
 726         return image;
 727      }
 728    /* FIXME: can move to gl_common */
 729    if (im->cs.space != EVAS_COLORSPACE_ARGB8888) return im;
 730    if ((has_alpha) && (im->im->cache_entry.flags.alpha)) return image;
 731    else if ((!has_alpha) && (!im->im->cache_entry.flags.alpha)) return image;
 732    if (im->references > 1)
 733      {
 734         Evas_GL_Image *im_new;
 735
 736         im_new = evas_gl_common_image_new_from_copied_data(im->gc, im->im->cache_entry.w, im->im->cache_entry.h, im->im->image.data,
 737                                                            eng_image_alpha_get(data, image),
 738                                                            eng_image_colorspace_get(data, image));
 739         if (!im_new) return im;
 740         evas_gl_common_image_free(im);
 741         im = im_new;
 742      }
 743    else
 744      evas_gl_common_image_dirty(im, 0, 0, 0, 0);
 745    im->im->cache_entry.flags.alpha = has_alpha ? 1 : 0;
 746    return image;
 747 }
 748
 749 static void *
 750 eng_image_border_set(void *data, void *image, int l __UNUSED__, int r __UNUSED__, int t __UNUSED__, int b __UNUSED__)
 751 {
 752 //   Render_Engine *re;
 753 //
 754 //   re = (Render_Engine *)data;
 755    return image;
 756 }
 757
 758 static void
 759 eng_image_border_get(void *data, void *image __UNUSED__, int *l __UNUSED__, int *r __UNUSED__, int *t __UNUSED__, int *b __UNUSED__)
 760 {
 761 //   Render_Engine *re;
 762 //
 763 //   re = (Render_Engine *)data;
 764 }
 765
 766 static char *
 767 eng_image_comment_get(void *data, void *image, char *key __UNUSED__)
 768 {
 769 //   Render_Engine *re;
 770    Evas_GL_Image *im;
 771
 772 //   re = (Render_Engine *)data;
 773    if (!image) return NULL;
 774    im = image;
 775    if (!im->im) return NULL;
 776    return im->im->info.comment;
 777 }
 778
 779 static char *
 780 eng_image_format_get(void *data, void *image)
 781 {
 782 //   Render_Engine *re;
 783    Evas_GL_Image *im;
 784
 785 //   re = (Render_Engine *)data;
 786    im = image;
 787    return NULL;
 788 }
 789
 790 static void
 791 eng_image_colorspace_set(void *data, void *image, int cspace)
 792 {
 793    Render_Engine *re;
 794    Evas_GL_Image *im;
 795
 796    re = (Render_Engine *)data;
 797    if (!image) return;
 798    im = image;
 799    if (im->native.data) return;
 800    /* FIXME: can move to gl_common */
 801    if (im->cs.space == cspace) return;
 802    evas_cache_image_colorspace(&im->im->cache_entry, cspace);
 803    switch (cspace)
 804      {
 805       case EVAS_COLORSPACE_ARGB8888:
 806         if (im->cs.data)
 807           {
 808              if (!im->cs.no_free) free(im->cs.data);
 809              im->cs.data = NULL;
 810              im->cs.no_free = 0;
 811           }
 812         break;
 813       case EVAS_COLORSPACE_YCBCR422P601_PL:
 814       case EVAS_COLORSPACE_YCBCR422P709_PL:
 815         if (im->tex) evas_gl_common_texture_free(im->tex);
 816         im->tex = NULL;
 817         if (im->cs.data)
 818           {
 819              if (!im->cs.no_free) free(im->cs.data);
 820           }
 821         im->cs.data = calloc(1, im->im->cache_entry.h * sizeof(unsigned char *) * 2);
 822         im->cs.no_free = 0;
 823         break;
 824       default:
 825         abort();
 826         break;
 827      }
 828    im->cs.space = cspace;
 829 }
 830
 831 /////////////////////////////////////////////////////////////////////////
 832 //
 833 //
 834 typedef struct _Native Native;
 835
 836 struct _Native
 837 {
 838    Evas_Native_Surface ns;
 839
 840 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
 841    EGLSurface  egl_surface;
 842 #endif
 843 };
 844
 845 static void
 846 _native_bind_cb(void *data, void *image)
 847 {
 848 }
 849
 850 static void
 851 _native_unbind_cb(void *data, void *image)
 852 {
 853 }
 854
 855 static void
 856 _native_free_cb(void *data, void *image)
 857 {
 858 }
 859
 860 static void
 861 eng_image_native_set(void *data, void *image, void *native)
 862 {
 863 }
 864
 865 static void *
 866 eng_image_native_get(void *data, void *image)
 867 {
 868    return NULL;
 869 }
 870
 871 //
 872 //
 873 /////////////////////////////////////////////////////////////////////////
 874
 875 static void *
 876 eng_image_load(void *data, const char *file, const char *key, int *error, Evas_Image_Load_Opts *lo)
 877 {
 878    Render_Engine *re;
 879
 880    re = (Render_Engine *)data;
 881    *error = EVAS_LOAD_ERROR_NONE;
 882    return evas_gl_common_image_load(re->gl_context, file, key, lo, error);
 883 }
 884
 885 static void *
 886 eng_image_new_from_data(void *data, int w, int h, DATA32 *image_data, int alpha, int cspace)
 887 {
 888    Render_Engine *re;
 889
 890    re = (Render_Engine *)data;
 891    return evas_gl_common_image_new_from_data(re->gl_context, w, h, image_data, alpha, cspace);
 892 }
 893
 894 static void *
 895 eng_image_new_from_copied_data(void *data, int w, int h, DATA32 *image_data, int alpha, int cspace)
 896 {
 897    Render_Engine *re;
 898
 899    re = (Render_Engine *)data;
 900    return evas_gl_common_image_new_from_copied_data(re->gl_context, w, h, image_data, alpha, cspace);
 901 }
 902
 903 static void
 904 eng_image_free(void *data, void *image)
 905 {
 906    Render_Engine *re;
 907
 908    re = (Render_Engine *)data;
 909    if (!image) return;
 910    evas_gl_common_image_free(image);
 911 }
 912
 913 static void
 914 eng_image_size_get(void *data, void *image, int *w, int *h)
 915 {
 916 //   Render_Engine *re;
 917 //
 918 //   re = (Render_Engine *)data;
 919    if (!image)
 920      {
 921         *w = 0;
 922         *h = 0;
 923         return;
 924      }
 925    if (w) *w = ((Evas_GL_Image *)image)->w;
 926    if (h) *h = ((Evas_GL_Image *)image)->h;
 927 }
 928
 929 static void *
 930 eng_image_size_set(void *data, void *image, int w, int h)
 931 {
 932    Render_Engine *re;
 933    Evas_GL_Image *im = image;
 934    Evas_GL_Image *im_old;
 935
 936    re = (Render_Engine *)data;
 937    if (!im) return NULL;
 938    if (im->native.data)
 939      {
 940         im->w = w;
 941         im->h = h;
 942         return image;
 943      }
 944    im_old = image;
 945    if ((eng_image_colorspace_get(data, image) == EVAS_COLORSPACE_YCBCR422P601_PL) ||
 946        (eng_image_colorspace_get(data, image) == EVAS_COLORSPACE_YCBCR422P709_PL))
 947      w &= ~0x1;
 948    if ((im_old) && (im_old->im->cache_entry.w == w) && (im_old->im->cache_entry.h == h))
 949      return image;
 950    if (im_old)
 951      {
 952         im = evas_gl_common_image_new(re->gl_context, w, h,
 953                                       eng_image_alpha_get(data, image),
 954                                       eng_image_colorspace_get(data, image));
 955 /*
 956         evas_common_load_image_data_from_file(im_old->im);
 957         if (im_old->im->image->data)
 958           {
 959              evas_common_blit_rectangle(im_old->im, im->im, 0, 0, w, h, 0, 0);
 960              evas_common_cpu_end_opt();
 961           }
 962  */
 963         evas_gl_common_image_free(im_old);
 964      }
 965    else
 966      im = evas_gl_common_image_new(re->gl_context, w, h, 1, EVAS_COLORSPACE_ARGB8888);
 967    return im;
 968 }
 969
 970 static void *
 971 eng_image_dirty_region(void *data, void *image, int x, int y, int w, int h)
 972 {
 973    Render_Engine *re;
 974    Evas_GL_Image *im = image;
 975
 976    re = (Render_Engine *)data;
 977    if (!image) return NULL;
 978    if (im->native.data) return image;
 979    evas_gl_common_image_dirty(image, x, y, w, h);
 980    return image;
 981 }
 982
 983 static void *
 984 eng_image_data_get(void *data, void *image, int to_write, DATA32 **image_data)
 985 {
 986    Render_Engine *re;
 987    Evas_GL_Image *im;
 988
 989    re = (Render_Engine *)data;
 990    if (!image)
 991      {
 992         *image_data = NULL;
 993         return NULL;
 994      }
 995    im = image;
 996    if (im->native.data)
 997      {
 998         *image_data = NULL;
 999         return im;
1000      }
1001    evas_cache_image_load_data(&im->im->cache_entry);
1002    switch (im->cs.space)
1003      {
1004       case EVAS_COLORSPACE_ARGB8888:
1005         if (to_write)
1006           {
1007              if (im->references > 1)
1008                {
1009                   Evas_GL_Image *im_new;
1010
1011                   im_new = evas_gl_common_image_new_from_copied_data(im->gc, im->im->cache_entry.w, im->im->cache_entry.h, im->im->image.data,
1012                                                                      eng_image_alpha_get(data, image),
1013                                                                      eng_image_colorspace_get(data, image));
1014                   if (!im_new)
1015                     {
1016                        *image_data = NULL;
1017                        return im;
1018                     }
1019                   evas_gl_common_image_free(im);
1020                   im = im_new;
1021                }
1022              else
1023                evas_gl_common_image_dirty(im, 0, 0, 0, 0);
1024           }
1025         *image_data = im->im->image.data;
1026         break;
1027       case EVAS_COLORSPACE_YCBCR422P601_PL:
1028       case EVAS_COLORSPACE_YCBCR422P709_PL:
1029         *image_data = im->cs.data;
1030         break;
1031       default:
1032         abort();
1033         break;
1034      }
1035    return im;
1036 }
1037
1038 static void *
1039 eng_image_data_put(void *data, void *image, DATA32 *image_data)
1040 {
1041    Render_Engine *re;
1042    Evas_GL_Image *im, *im2;
1043
1044    re = (Render_Engine *)data;
1045    if (!image) return NULL;
1046    im = image;
1047    if (im->native.data) return image;
1048    switch (im->cs.space)
1049      {
1050       case EVAS_COLORSPACE_ARGB8888:
1051         if (image_data != im->im->image.data)
1052           {
1053              int w, h;
1054
1055              w = im->im->cache_entry.w;
1056              h = im->im->cache_entry.h;
1057              im2 = eng_image_new_from_data(data, w, h, image_data,
1058                                            eng_image_alpha_get(data, image),
1059                                            eng_image_colorspace_get(data, image));
1060              if (!im2) return im;
1061              evas_gl_common_image_free(im);
1062              im = im2;
1063           }
1064         break;
1065       case EVAS_COLORSPACE_YCBCR422P601_PL:
1066       case EVAS_COLORSPACE_YCBCR422P709_PL:
1067         if (image_data != im->cs.data)
1068           {
1069              if (im->cs.data)
1070                {
1071                   if (!im->cs.no_free) free(im->cs.data);
1072                }
1073              im->cs.data = image_data;
1074           }
1075         break;
1076       default:
1077         abort();
1078         break;
1079      }
1080    /* hmmm - but if we wrote... why bother? */
1081    evas_gl_common_image_dirty(im, 0, 0, 0, 0);
1082    return im;
1083 }
1084
1085 static void
1086 eng_image_data_preload_request(void *data __UNUSED__, void *image, const void *target)
1087 {
1088    Evas_GL_Image *gim = image;
1089    RGBA_Image *im;
1090
1091    if (!gim) return;
1092    if (gim->native.data) return;
1093    im = (RGBA_Image *)gim->im;
1094    if (!im) return;
1095    evas_cache_image_preload_data(&im->cache_entry, target);
1096 }
1097
1098 static void
1099 eng_image_data_preload_cancel(void *data __UNUSED__, void *image, const void *target)
1100 {
1101    Evas_GL_Image *gim = image;
1102    RGBA_Image *im;
1103
1104    if (!gim) return;
1105    if (gim->native.data) return;
1106    im = (RGBA_Image *)gim->im;
1107    if (!im) return;
1108    evas_cache_image_preload_cancel(&im->cache_entry, target);
1109 }
1110
1111 static void
1112 eng_image_draw(void *data, void *context, void *surface, void *image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int dst_w, int dst_h, int smooth)
1113 {
1114    Render_Engine *re;
1115
1116    re = (Render_Engine *)data;
1117    if (!image) return;
1118    evas_gl_common_context_target_surface_set(re->gl_context, surface);
1119    re->gl_context->dc = context;
1120    evas_gl_common_image_draw(re->gl_context, image,
1121                              src_x, src_y, src_w, src_h,
1122                              dst_x, dst_y, dst_w, dst_h,
1123                              smooth);
1124 }
1125
1126 static void
1127 eng_image_scale_hint_set(void *data __UNUSED__, void *image, int hint)
1128 {
1129 }
1130
1131 static void
1132 eng_image_map4_draw(void *data __UNUSED__, void *context, void *surface, void *image, RGBA_Map_Point *p, int smooth, int level)
1133 {
1134    Render_Engine *re;
1135
1136    re = (Render_Engine *)data;
1137    evas_gl_common_context_target_surface_set(re->gl_context, surface);
1138    re->gl_context->dc = context;
1139    evas_gl_common_image_map4_draw(re->gl_context, image, p, smooth, level);
1140 }
1141
1142 static void *
1143 eng_image_map_surface_new(void *data __UNUSED__, int w, int h, int alpha)
1144 {
1145    Render_Engine *re;
1146
1147    re = (Render_Engine *)data;
1148    return evas_gl_common_image_surface_new(re->gl_context, w, h, alpha);
1149 }
1150
1151 static void
1152 eng_image_map_surface_free(void *data __UNUSED__, void *surface)
1153 {
1154    evas_gl_common_image_free(surface);
1155 }
1156
1157 static int
1158 eng_image_scale_hint_get(void *data __UNUSED__, void *image)
1159 {
1160    return EVAS_IMAGE_SCALE_HINT_NONE;
1161 }
1162
1163 static void
1164 eng_font_draw(void *data, void *context, void *surface, void *font, int x, int y, int w __UNUSED__, int h __UNUSED__, int ow __UNUSED__, int oh __UNUSED__, const char *text)
1165 {
1166    Render_Engine *re;
1167
1168    re = (Render_Engine *)data;
1169    evas_gl_common_context_target_surface_set(re->gl_context, surface);
1170    re->gl_context->dc = context;
1171      {
1172         // FIXME: put im into context so we can free it
1173         static RGBA_Image *im = NULL;
1174
1175         if (!im)
1176           im = (RGBA_Image *)evas_cache_image_empty(evas_common_image_cache_get());
1177         im->cache_entry.w = re->w;
1178         im->cache_entry.h = re->h;
1179         evas_common_draw_context_font_ext_set(context,
1180                                               re->gl_context,
1181                                               evas_gl_font_texture_new,
1182                                               evas_gl_font_texture_free,
1183                                               evas_gl_font_texture_draw);
1184         evas_common_font_draw(im, context, font, x, y, text);
1185         evas_common_draw_context_font_ext_set(context,
1186                                               NULL,
1187                                               NULL,
1188                                               NULL,
1189                                               NULL);
1190      }
1191 }
1192
1193 static Eina_Bool
1194 eng_canvas_alpha_get(void *data __UNUSED__, void *info __UNUSED__)
1195 {
1196    // FIXME: support ARGB gl targets!!!
1197    return EINA_FALSE;
1198 }
1199
1200 static int
1201 module_open(Evas_Module *em)
1202 {
1203    if (!em) return 0;
1204    /* get whatever engine module we inherit from */
1205    if (!_evas_module_engine_inherit(&pfunc, "software_generic")) return 0;
1206    if (_evas_engine_GL_SDL_log_dom < 0)
1207      _evas_engine_GL_SDL_log_dom = eina_log_domain_register("EvasEngineGLSDL", EVAS_DEFAULT_LOG_COLOR);
1208    if (_evas_engine_GL_SDL_log_dom < 0)
1209      {
1210         EINA_LOG_ERR("Impossible to create a log domain for GL SDL engine.\n");
1211         return 0;
1212      }
1213    /* store it for later use */
1214    func = pfunc;
1215    /* now to override methods */
1216    #define ORD(f) EVAS_API_OVERRIDE(f, &func, eng_)
1217    ORD(info);
1218    ORD(info_free);
1219    ORD(setup);
1220    ORD(canvas_alpha_get);
1221    ORD(output_free);
1222    ORD(output_resize);
1223    ORD(output_tile_size_set);
1224    ORD(output_redraws_rect_add);
1225    ORD(output_redraws_rect_del);
1226    ORD(output_redraws_clear);
1227    ORD(output_redraws_next_update_get);
1228    ORD(output_redraws_next_update_push);
1229    ORD(context_cutout_add);
1230    ORD(context_cutout_clear);
1231    ORD(output_flush);
1232    ORD(output_idle_flush);
1233    ORD(rectangle_draw);
1234    ORD(line_draw);
1235    ORD(polygon_point_add);
1236    ORD(polygon_points_clear);
1237    ORD(polygon_draw);
1238
1239    ORD(gradient2_color_np_stop_insert);
1240    ORD(gradient2_clear);
1241    ORD(gradient2_fill_transform_set);
1242    ORD(gradient2_fill_spread_set);
1243    ORD(gradient2_linear_new);
1244    ORD(gradient2_linear_free);
1245    ORD(gradient2_linear_fill_set);
1246    ORD(gradient2_linear_is_opaque);
1247    ORD(gradient2_linear_is_visible);
1248    ORD(gradient2_linear_render_pre);
1249    ORD(gradient2_linear_render_post);
1250    ORD(gradient2_linear_draw);
1251    ORD(gradient2_radial_new);
1252    ORD(gradient2_radial_free);
1253    ORD(gradient2_radial_fill_set);
1254    ORD(gradient2_radial_is_opaque);
1255    ORD(gradient2_radial_is_visible);
1256    ORD(gradient2_radial_render_pre);
1257    ORD(gradient2_radial_render_post);
1258    ORD(gradient2_radial_draw);
1259
1260    ORD(gradient_new);
1261    ORD(gradient_free);
1262    ORD(gradient_color_stop_add);
1263    ORD(gradient_alpha_stop_add);
1264    ORD(gradient_color_data_set);
1265    ORD(gradient_alpha_data_set);
1266    ORD(gradient_clear);
1267    ORD(gradient_fill_set);
1268    ORD(gradient_fill_angle_set);
1269    ORD(gradient_fill_spread_set);
1270    ORD(gradient_angle_set);
1271    ORD(gradient_offset_set);
1272    ORD(gradient_direction_set);
1273    ORD(gradient_type_set);
1274    ORD(gradient_is_opaque);
1275    ORD(gradient_is_visible);
1276    ORD(gradient_render_pre);
1277    ORD(gradient_render_post);
1278    ORD(gradient_draw);
1279    ORD(image_load);
1280    ORD(image_new_from_data);
1281    ORD(image_new_from_copied_data);
1282    ORD(image_free);
1283    ORD(image_size_get);
1284    ORD(image_size_set);
1285    ORD(image_dirty_region);
1286    ORD(image_data_get);
1287    ORD(image_data_put);
1288    ORD(image_data_preload_request);
1289    ORD(image_data_preload_cancel);
1290    ORD(image_alpha_set);
1291    ORD(image_alpha_get);
1292    ORD(image_border_set);
1293    ORD(image_border_get);
1294    ORD(image_draw);
1295    ORD(image_comment_get);
1296    ORD(image_format_get);
1297    ORD(image_colorspace_set);
1298    ORD(image_colorspace_get);
1299    ORD(image_native_set);
1300    ORD(image_native_get);
1301    ORD(font_draw);
1302
1303    ORD(image_scale_hint_set);
1304    ORD(image_scale_hint_get);
1305
1306    ORD(image_map4_draw);
1307    ORD(image_map_surface_new);
1308    ORD(image_map_surface_free);
1309
1310    /* now advertise out own api */
1311    em->functions = (void *)(&func);
1312    return 1;
1313 }
1314
1315 static void
1316 module_close(Evas_Module *em)
1317 {
1318     eina_log_domain_unregister(_evas_engine_GL_SDL_log_dom);
1319 }
1320
1321 static Evas_Module_Api evas_modapi =
1322 {
1323    EVAS_MODULE_API_VERSION,
1324    "gl_sdl",
1325    "none",
1326    {
1327      module_open,
1328      module_close
1329    }
1330 };
1331
1332 EVAS_MODULE_DEFINE(EVAS_MODULE_TYPE_ENGINE, engine, gl_sdl);
1333
1334 #ifndef EVAS_STATIC_BUILD_GL_SDL
1335 EVAS_EINA_MODULE_DEFINE(engine, gl_sdl);
1336 #endif
1337
1338 static void*
1339 _sdl_output_setup               (int w, int h, int fullscreen, int noframe)
1340 {
1341    Render_Engine                *re = calloc(1, sizeof(Render_Engine));
1342    SDL_Surface                  *surface;
1343    int                          context_attrs[3];
1344    int                          config_attrs[20];
1345    int                          major_version, minor_version;
1346    int                          num_config;
1347
1348    /* if we haven't initialized - init (automatic abort if already done) */
1349    evas_common_cpu_init();
1350    evas_common_blend_init();
1351    evas_common_image_init();
1352    evas_common_convert_init();
1353    evas_common_scale_init();
1354    evas_common_rectangle_init();
1355    evas_common_gradient_init();
1356    evas_common_polygon_init();
1357    evas_common_line_init();
1358    evas_common_font_init();
1359    evas_common_draw_init();
1360    evas_common_tilebuf_init();
1361
1362    if (w <= 0) w = 640;
1363    if (h <= 0) h = 480;
1364
1365    /* GL Initialization */
1366 #ifdef HAVE_SDL_GL_CONTEXT_VERSION
1367    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
1368    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
1369 #endif
1370    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
1371    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
1372    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
1373    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
1374    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
1375    SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 0);
1376
1377    surface = SDL_SetVideoMode(w, h, 32, EVAS_SDL_GL_FLAG
1378                            | (fullscreen ? SDL_FULLSCREEN : 0)
1379                            | (noframe ? SDL_NOFRAME : 0));
1380
1381    if (!surface)
1382      {
1383         CRIT("SDL_SetVideoMode [ %i x %i x 32 ] failed.", w, h);
1384         CRIT("SDL: %s\n", SDL_GetError());
1385         SDL_Quit();
1386         exit(-1);
1387      }
1388
1389    fprintf(stderr, "Screen Depth : %d\n", SDL_GetVideoSurface()->format->BitsPerPixel);
1390    fprintf(stderr, "Vendor       : %s\n", glGetString(GL_VENDOR));
1391    fprintf(stderr, "Renderer     : %s\n", glGetString(GL_RENDERER));
1392    fprintf(stderr, "Version      : %s\n", glGetString(GL_VERSION));
1393
1394    re->gl_context = evas_gl_common_context_new();
1395    if (!re->gl_context)
1396      {
1397         free(re);
1398         return NULL;
1399      }
1400    evas_gl_common_context_use(re->gl_context);
1401    evas_gl_common_context_resize(re->gl_context, w, h);
1402
1403    /* End GL Initialization */
1404    re->w = w;
1405    re->h = h;
1406    return re;
1407 }
1408