src/modules/engines/gl_sdl/evas_engine.c

   1 #include "evas_common.h" /* Also includes international specific stuff */
   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, re->gl_context->rot);
 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, re->gl_context->rot);
 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    evas_gl_common_context_newframe(re->gl_context);
 179    /* get the upate rect surface - return engine data as dummy */
 180    if (!re->draw.redraw)
 181      {
 182 //      printf("GL: NO updates!\n");
 183         return NULL;
 184      }
 185 //   printf("GL: update....!\n");
 186 #ifdef SLOW_GL_COPY_RECT
 187    /* if any update - just return the whole canvas - works with swap
 188     * buffers then */
 189    if (x) *x = 0;
 190    if (y) *y = 0;
 191    if (w) *w = re->w;
 192    if (h) *h = re->h;
 193    if (cx) *cx = 0;
 194    if (cy) *cy = 0;
 195    if (cw) *cw = re->w;
 196    if (ch) *ch = re->h;
 197 #else
 198    /* 1 update - INCREDIBLY SLOW if combined with swap_rect in flush. a gl
 199     * problem where there just is no hardware path for somethnig that
 200     * obviously SHOULD be there */
 201    /* only 1 update to minimise gl context games and rendering multiple update
 202     * regions as evas does with other engines
 203     */
 204    if (x) *x = re->draw.x1;
 205    if (y) *y = re->draw.y1;
 206    if (w) *w = re->draw.x2 - re->draw.x1 + 1;
 207    if (h) *h = re->draw.y2 - re->draw.y1 + 1;
 208    if (cx) *cx = re->draw.x1;
 209    if (cy) *cy = re->draw.y1;
 210    if (cw) *cw = re->draw.x2 - re->draw.x1 + 1;
 211    if (ch) *ch = re->draw.y2 - re->draw.y1 + 1;
 212 #endif
 213 // clear buffer. only needed for dest alpha
 214 //   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 215 //   glClear(GL_COLOR_BUFFER_BIT);
 216 //x//   printf("frame -> new\n");
 217    return re->gl_context->def_surface;
 218 }
 219
 220 static void
 221 eng_output_redraws_next_update_push(void *data, void *surface __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
 222 {
 223    Render_Engine *re;
 224
 225    re = (Render_Engine *)data;
 226    /* put back update surface.. in this case just unflag redraw */
 227    re->draw.redraw = 0;
 228    re->draw.drew = 1;
 229    evas_gl_common_context_flush(re->gl_context);
 230 //x//   printf("frame -> push\n");
 231 }
 232
 233 static void
 234 eng_output_flush(void *data)
 235 {
 236    Render_Engine *re;
 237
 238    re = (Render_Engine *)data;
 239    if (!re->draw.drew) return;
 240 //x//   printf("frame -> flush\n");
 241    re->draw.drew = 0;
 242
 243 #if 0
 244 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
 245 //   glFlush();
 246    eglSwapBuffers(re->egl_disp, re->egl_surface[0]);
 247 #else
 248    glXSwapBuffers(re->win->disp, re->win);
 249 #endif
 250 #else
 251    SDL_GL_SwapBuffers();
 252 #endif
 253 }
 254
 255 static void
 256 eng_output_idle_flush(void *data)
 257 {
 258    Render_Engine *re;
 259
 260    re = (Render_Engine *)data;
 261 }
 262
 263 static void
 264 eng_output_dump(void *data)
 265 {
 266    Render_Engine *re;
 267
 268    re = (Render_Engine *)data;
 269    evas_common_image_image_all_unload();
 270    evas_common_font_font_all_unload();
 271    evas_gl_common_image_all_unload(re->gl_context);
 272 }
 273
 274 static void
 275 eng_context_cutout_add(void *data, void *context, int x, int y, int w, int h)
 276 {
 277 //   Render_Engine *re;
 278 //
 279 //   re = (Render_Engine *)data;
 280 //   re->gl_context->dc = context;
 281    evas_common_draw_context_add_cutout(context, x, y, w, h);
 282 }
 283
 284 static void
 285 eng_context_cutout_clear(void *data, void *context)
 286 {
 287 //   Render_Engine *re;
 288 //
 289 //   re = (Render_Engine *)data;
 290 //   re->gl_context->dc = context;
 291    evas_common_draw_context_clear_cutouts(context);
 292 }
 293
 294 static void
 295 eng_rectangle_draw(void *data, void *context, void *surface, int x, int y, int w, int h)
 296 {
 297    Render_Engine *re;
 298
 299    re = (Render_Engine *)data;
 300    evas_gl_common_context_target_surface_set(re->gl_context, surface);
 301    re->gl_context->dc = context;
 302    evas_gl_common_rect_draw(re->gl_context, x, y, w, h);
 303 }
 304
 305 static void
 306 eng_line_draw(void *data, void *context, void *surface, int x1, int y1, int x2, int y2)
 307 {
 308    Render_Engine *re;
 309
 310    re = (Render_Engine *)data;
 311    evas_gl_common_context_target_surface_set(re->gl_context, surface);
 312    re->gl_context->dc = context;
 313    evas_gl_common_line_draw(re->gl_context, x1, y1, x2, y2);
 314 }
 315
 316 static void *
 317 eng_polygon_point_add(void *data, void *context __UNUSED__, void *polygon, int x, int y)
 318 {
 319    Render_Engine *re;
 320
 321    re = (Render_Engine *)data;
 322    return evas_gl_common_poly_point_add(polygon, x, y);
 323 }
 324
 325 static void *
 326 eng_polygon_points_clear(void *data, void *context __UNUSED__, void *polygon)
 327 {
 328    Render_Engine *re;
 329
 330    re = (Render_Engine *)data;
 331    return evas_gl_common_poly_points_clear(polygon);
 332 }
 333
 334 static void
 335 eng_polygon_draw(void *data, void *context, void *surface, void *polygon, int x, int y)
 336 {
 337    Render_Engine *re;
 338
 339    re = (Render_Engine *)data;
 340    evas_gl_common_context_target_surface_set(re->gl_context, surface);
 341    re->gl_context->dc = context;
 342    evas_gl_common_poly_draw(re->gl_context, polygon, x, y);
 343 }
 344
 345 static int
 346 eng_image_alpha_get(void *data, void *image)
 347 {
 348 //   Render_Engine *re;
 349    Evas_GL_Image *im;
 350
 351 //   re = (Render_Engine *)data;
 352    if (!image) return 1;
 353    im = image;
 354    return im->alpha;
 355 }
 356
 357 static int
 358 eng_image_colorspace_get(void *data, void *image)
 359 {
 360 //   Render_Engine *re;
 361    Evas_GL_Image *im;
 362
 363 //   re = (Render_Engine *)data;
 364    if (!image) return EVAS_COLORSPACE_ARGB8888;
 365    im = image;
 366    return im->cs.space;
 367 }
 368
 369 static void *
 370 eng_image_alpha_set(void *data, void *image, int has_alpha)
 371 {
 372    Render_Engine *re;
 373    Evas_GL_Image *im;
 374
 375    re = (Render_Engine *)data;
 376    if (!image) return NULL;
 377    im = image;
 378    if (im->native.data)
 379      {
 380         im->alpha = has_alpha;
 381         return image;
 382      }
 383    /* FIXME: can move to gl_common */
 384    if (im->cs.space != EVAS_COLORSPACE_ARGB8888) return im;
 385    if ((has_alpha) && (im->im->cache_entry.flags.alpha)) return image;
 386    else if ((!has_alpha) && (!im->im->cache_entry.flags.alpha)) return image;
 387    if (im->references > 1)
 388      {
 389         Evas_GL_Image *im_new;
 390
 391         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,
 392                                                            eng_image_alpha_get(data, image),
 393                                                            eng_image_colorspace_get(data, image));
 394         if (!im_new) return im;
 395         evas_gl_common_image_free(im);
 396         im = im_new;
 397      }
 398    else
 399      evas_gl_common_image_dirty(im, 0, 0, 0, 0);
 400    im->im->cache_entry.flags.alpha = has_alpha ? 1 : 0;
 401    return image;
 402 }
 403
 404 static void *
 405 eng_image_border_set(void *data, void *image, int l __UNUSED__, int r __UNUSED__, int t __UNUSED__, int b __UNUSED__)
 406 {
 407 //   Render_Engine *re;
 408 //
 409 //   re = (Render_Engine *)data;
 410    return image;
 411 }
 412
 413 static void
 414 eng_image_border_get(void *data, void *image __UNUSED__, int *l __UNUSED__, int *r __UNUSED__, int *t __UNUSED__, int *b __UNUSED__)
 415 {
 416 //   Render_Engine *re;
 417 //
 418 //   re = (Render_Engine *)data;
 419 }
 420
 421 static char *
 422 eng_image_comment_get(void *data, void *image, char *key __UNUSED__)
 423 {
 424 //   Render_Engine *re;
 425    Evas_GL_Image *im;
 426
 427 //   re = (Render_Engine *)data;
 428    if (!image) return NULL;
 429    im = image;
 430    if (!im->im) return NULL;
 431    return im->im->info.comment;
 432 }
 433
 434 static char *
 435 eng_image_format_get(void *data, void *image)
 436 {
 437 //   Render_Engine *re;
 438    Evas_GL_Image *im;
 439
 440 //   re = (Render_Engine *)data;
 441    im = image;
 442    return NULL;
 443 }
 444
 445 static void
 446 eng_image_colorspace_set(void *data, void *image, int cspace)
 447 {
 448    Render_Engine *re;
 449    Evas_GL_Image *im;
 450
 451    re = (Render_Engine *)data;
 452    if (!image) return;
 453    im = image;
 454    if (im->native.data) return;
 455    /* FIXME: can move to gl_common */
 456    if (im->cs.space == cspace) return;
 457    evas_cache_image_colorspace(&im->im->cache_entry, cspace);
 458    switch (cspace)
 459      {
 460       case EVAS_COLORSPACE_ARGB8888:
 461         if (im->cs.data)
 462           {
 463              if (!im->cs.no_free) free(im->cs.data);
 464              im->cs.data = NULL;
 465              im->cs.no_free = 0;
 466           }
 467         break;
 468       case EVAS_COLORSPACE_YCBCR422P601_PL:
 469       case EVAS_COLORSPACE_YCBCR422P709_PL:
 470         if (im->tex) evas_gl_common_texture_free(im->tex);
 471         im->tex = NULL;
 472         if (im->cs.data)
 473           {
 474              if (!im->cs.no_free) free(im->cs.data);
 475           }
 476         im->cs.data = calloc(1, im->im->cache_entry.h * sizeof(unsigned char *) * 2);
 477         im->cs.no_free = 0;
 478         break;
 479       default:
 480         abort();
 481         break;
 482      }
 483    im->cs.space = cspace;
 484 }
 485
 486 /////////////////////////////////////////////////////////////////////////
 487 //
 488 //
 489 typedef struct _Native Native;
 490
 491 struct _Native
 492 {
 493    Evas_Native_Surface ns;
 494
 495 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
 496    EGLSurface  egl_surface;
 497 #endif
 498 };
 499
 500 static void
 501 _native_bind_cb(void *data, void *image)
 502 {
 503 }
 504
 505 static void
 506 _native_unbind_cb(void *data, void *image)
 507 {
 508 }
 509
 510 static void
 511 _native_free_cb(void *data, void *image)
 512 {
 513 }
 514
 515 static void *
 516 eng_image_native_set(void *data, void *image, void *native)
 517 {
 518    return NULL;
 519 }
 520
 521 static void *
 522 eng_image_native_get(void *data, void *image)
 523 {
 524    return NULL;
 525 }
 526
 527 //
 528 //
 529 /////////////////////////////////////////////////////////////////////////
 530
 531 static void *
 532 eng_image_load(void *data, const char *file, const char *key, int *error, Evas_Image_Load_Opts *lo)
 533 {
 534    Render_Engine *re;
 535
 536    re = (Render_Engine *)data;
 537    *error = EVAS_LOAD_ERROR_NONE;
 538    return evas_gl_common_image_load(re->gl_context, file, key, lo, error);
 539 }
 540
 541 static void *
 542 eng_image_new_from_data(void *data, int w, int h, DATA32 *image_data, int alpha, int cspace)
 543 {
 544    Render_Engine *re;
 545
 546    re = (Render_Engine *)data;
 547    return evas_gl_common_image_new_from_data(re->gl_context, w, h, image_data, alpha, cspace);
 548 }
 549
 550 static void *
 551 eng_image_new_from_copied_data(void *data, int w, int h, DATA32 *image_data, int alpha, int cspace)
 552 {
 553    Render_Engine *re;
 554
 555    re = (Render_Engine *)data;
 556    return evas_gl_common_image_new_from_copied_data(re->gl_context, w, h, image_data, alpha, cspace);
 557 }
 558
 559 static void
 560 eng_image_free(void *data, void *image)
 561 {
 562    Render_Engine *re;
 563
 564    re = (Render_Engine *)data;
 565    if (!image) return;
 566    evas_gl_common_image_free(image);
 567 }
 568
 569 static void
 570 eng_image_size_get(void *data, void *image, int *w, int *h)
 571 {
 572 //   Render_Engine *re;
 573 //
 574 //   re = (Render_Engine *)data;
 575    if (!image)
 576      {
 577         *w = 0;
 578         *h = 0;
 579         return;
 580      }
 581    if (w) *w = ((Evas_GL_Image *)image)->w;
 582    if (h) *h = ((Evas_GL_Image *)image)->h;
 583 }
 584
 585 static void *
 586 eng_image_size_set(void *data, void *image, int w, int h)
 587 {
 588    Render_Engine *re;
 589    Evas_GL_Image *im = image;
 590    Evas_GL_Image *im_old;
 591
 592    re = (Render_Engine *)data;
 593    if (!im) return NULL;
 594    if (im->native.data)
 595      {
 596         im->w = w;
 597         im->h = h;
 598         return image;
 599      }
 600    im_old = image;
 601    if ((eng_image_colorspace_get(data, image) == EVAS_COLORSPACE_YCBCR422P601_PL) ||
 602        (eng_image_colorspace_get(data, image) == EVAS_COLORSPACE_YCBCR422P709_PL))
 603      w &= ~0x1;
 604    if ((im_old) && (im_old->im->cache_entry.w == w) && (im_old->im->cache_entry.h == h))
 605      return image;
 606    if (im_old)
 607      {
 608         im = evas_gl_common_image_new(re->gl_context, w, h,
 609                                       eng_image_alpha_get(data, image),
 610                                       eng_image_colorspace_get(data, image));
 611 /*
 612         evas_common_load_image_data_from_file(im_old->im);
 613         if (im_old->im->image->data)
 614           {
 615              evas_common_blit_rectangle(im_old->im, im->im, 0, 0, w, h, 0, 0);
 616              evas_common_cpu_end_opt();
 617           }
 618  */
 619         evas_gl_common_image_free(im_old);
 620      }
 621    else
 622      im = evas_gl_common_image_new(re->gl_context, w, h, 1, EVAS_COLORSPACE_ARGB8888);
 623    return im;
 624 }
 625
 626 static void *
 627 eng_image_dirty_region(void *data, void *image, int x, int y, int w, int h)
 628 {
 629    Render_Engine *re;
 630    Evas_GL_Image *im = image;
 631
 632    re = (Render_Engine *)data;
 633    if (!image) return NULL;
 634    if (im->native.data) return image;
 635    evas_gl_common_image_dirty(image, x, y, w, h);
 636    return image;
 637 }
 638
 639 static void *
 640 eng_image_data_get(void *data, void *image, int to_write, DATA32 **image_data, int *err)
 641 {
 642    Render_Engine *re;
 643    Evas_GL_Image *im;
 644    int error;
 645
 646    re = (Render_Engine *)data;
 647    if (!image)
 648      {
 649         *image_data = NULL;
 650         if (err) *err = EVAS_LOAD_ERROR_GENERIC;
 651         return NULL;
 652      }
 653    im = image;
 654    if (im->native.data)
 655      {
 656         *image_data = NULL;
 657         if (err) *err = EVAS_LOAD_ERROR_NONE;
 658         return im;
 659      }
 660    error = evas_cache_image_load_data(&im->im->cache_entry);
 661    switch (im->cs.space)
 662      {
 663       case EVAS_COLORSPACE_ARGB8888:
 664         if (to_write)
 665           {
 666              if (im->references > 1)
 667                {
 668                   Evas_GL_Image *im_new;
 669
 670                   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,
 671                                                                      eng_image_alpha_get(data, image),
 672                                                                      eng_image_colorspace_get(data, image));
 673                   if (!im_new)
 674                     {
 675                        *image_data = NULL;
 676                        if (err) *err = error;
 677                        return im;
 678                     }
 679                   evas_gl_common_image_free(im);
 680                   im = im_new;
 681                }
 682              else
 683                evas_gl_common_image_dirty(im, 0, 0, 0, 0);
 684           }
 685         *image_data = im->im->image.data;
 686         break;
 687       case EVAS_COLORSPACE_YCBCR422P601_PL:
 688       case EVAS_COLORSPACE_YCBCR422P709_PL:
 689         *image_data = im->cs.data;
 690         break;
 691       default:
 692         abort();
 693         break;
 694      }
 695    if (err) *err = error;
 696    return im;
 697 }
 698
 699 static void *
 700 eng_image_data_put(void *data, void *image, DATA32 *image_data)
 701 {
 702    Render_Engine *re;
 703    Evas_GL_Image *im, *im2;
 704
 705    re = (Render_Engine *)data;
 706    if (!image) return NULL;
 707    im = image;
 708    if (im->native.data) return image;
 709    switch (im->cs.space)
 710      {
 711       case EVAS_COLORSPACE_ARGB8888:
 712         if (image_data != im->im->image.data)
 713           {
 714              int w, h;
 715
 716              w = im->im->cache_entry.w;
 717              h = im->im->cache_entry.h;
 718              im2 = eng_image_new_from_data(data, w, h, image_data,
 719                                            eng_image_alpha_get(data, image),
 720                                            eng_image_colorspace_get(data, image));
 721              if (!im2) return im;
 722              evas_gl_common_image_free(im);
 723              im = im2;
 724           }
 725         break;
 726       case EVAS_COLORSPACE_YCBCR422P601_PL:
 727       case EVAS_COLORSPACE_YCBCR422P709_PL:
 728         if (image_data != im->cs.data)
 729           {
 730              if (im->cs.data)
 731                {
 732                   if (!im->cs.no_free) free(im->cs.data);
 733                }
 734              im->cs.data = image_data;
 735           }
 736         break;
 737       default:
 738         abort();
 739         break;
 740      }
 741    /* hmmm - but if we wrote... why bother? */
 742    evas_gl_common_image_dirty(im, 0, 0, 0, 0);
 743    return im;
 744 }
 745
 746 static void
 747 eng_image_data_preload_request(void *data __UNUSED__, void *image, const void *target)
 748 {
 749    Evas_GL_Image *gim = image;
 750    RGBA_Image *im;
 751
 752    if (!gim) return;
 753    if (gim->native.data) return;
 754    im = (RGBA_Image *)gim->im;
 755    if (!im) return;
 756    evas_cache_image_preload_data(&im->cache_entry, target);
 757 }
 758
 759 static void
 760 eng_image_data_preload_cancel(void *data __UNUSED__, void *image, const void *target)
 761 {
 762    Evas_GL_Image *gim = image;
 763    RGBA_Image *im;
 764
 765    if (!gim) return;
 766    if (gim->native.data) return;
 767    im = (RGBA_Image *)gim->im;
 768    if (!im) return;
 769    evas_cache_image_preload_cancel(&im->cache_entry, target);
 770 }
 771
 772 static void
 773 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)
 774 {
 775    Render_Engine *re;
 776
 777    re = (Render_Engine *)data;
 778    if (!image) return;
 779    evas_gl_common_context_target_surface_set(re->gl_context, surface);
 780    re->gl_context->dc = context;
 781    evas_gl_common_image_draw(re->gl_context, image,
 782                              src_x, src_y, src_w, src_h,
 783                              dst_x, dst_y, dst_w, dst_h,
 784                              smooth);
 785 }
 786
 787 static void
 788 eng_image_scale_hint_set(void *data __UNUSED__, void *image, int hint)
 789 {
 790 }
 791
 792 static void
 793 eng_image_map_draw(void *data __UNUSED__, void *context, void *surface, void *image, int npoints, RGBA_Map_Point *p, int smooth, int level)
 794 {
 795    Render_Engine *re;
 796
 797    re = (Render_Engine *)data;
 798    evas_gl_common_context_target_surface_set(re->gl_context, surface);
 799    re->gl_context->dc = context;
 800    evas_gl_common_image_map_draw(re->gl_context, image, npoints, p, smooth, level);
 801 }
 802
 803 static void *
 804 eng_image_map_surface_new(void *data __UNUSED__, int w, int h, int alpha)
 805 {
 806    Render_Engine *re;
 807
 808    re = (Render_Engine *)data;
 809    return evas_gl_common_image_surface_new(re->gl_context, w, h, alpha);
 810 }
 811
 812 static void
 813 eng_image_map_surface_free(void *data __UNUSED__, void *surface)
 814 {
 815    evas_gl_common_image_free(surface);
 816 }
 817
 818 static int
 819 eng_image_scale_hint_get(void *data __UNUSED__, void *image)
 820 {
 821    return EVAS_IMAGE_SCALE_HINT_NONE;
 822 }
 823
 824 static void
 825 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 Evas_Text_Props *intl_props)
 826 {
 827    Render_Engine *re;
 828
 829    re = (Render_Engine *)data;
 830    evas_gl_common_context_target_surface_set(re->gl_context, surface);
 831    re->gl_context->dc = context;
 832      {
 833         // FIXME: put im into context so we can free it
 834         static RGBA_Image *im = NULL;
 835
 836         if (!im)
 837           im = (RGBA_Image *)evas_cache_image_empty(evas_common_image_cache_get());
 838         im->cache_entry.w = re->w;
 839         im->cache_entry.h = re->h;
 840         evas_common_draw_context_font_ext_set(context,
 841                                               re->gl_context,
 842                                               evas_gl_font_texture_new,
 843                                               evas_gl_font_texture_free,
 844                                               evas_gl_font_texture_draw);
 845         evas_common_font_draw(im, context, font, x, y, intl_props);
 846         evas_common_draw_context_font_ext_set(context,
 847                                               NULL,
 848                                               NULL,
 849                                               NULL,
 850                                               NULL);
 851      }
 852 }
 853
 854 static Eina_Bool
 855 eng_canvas_alpha_get(void *data __UNUSED__, void *info __UNUSED__)
 856 {
 857    // FIXME: support ARGB gl targets!!!
 858    return EINA_FALSE;
 859 }
 860
 861 static int
 862 eng_image_load_error_get(void *data __UNUSED__, void *image)
 863 {
 864    Evas_GL_Image *im;
 865
 866    if (!image) return EVAS_LOAD_ERROR_NONE;
 867    im = image;
 868    return im->im->cache_entry.load_error;
 869 }
 870
 871
 872 static int
 873 module_open(Evas_Module *em)
 874 {
 875    if (!em) return 0;
 876    if (!evas_gl_common_module_open()) return 0;
 877    /* get whatever engine module we inherit from */
 878    if (!_evas_module_engine_inherit(&pfunc, "software_generic")) return 0;
 879    if (_evas_engine_GL_SDL_log_dom < 0)
 880      _evas_engine_GL_SDL_log_dom = eina_log_domain_register
 881        ("evas-gl_sdl", EVAS_DEFAULT_LOG_COLOR);
 882    if (_evas_engine_GL_SDL_log_dom < 0)
 883      {
 884         EINA_LOG_ERR("Can not create a module log domain.");
 885         return 0;
 886      }
 887    /* store it for later use */
 888    func = pfunc;
 889    /* now to override methods */
 890    #define ORD(f) EVAS_API_OVERRIDE(f, &func, eng_)
 891    ORD(info);
 892    ORD(info_free);
 893    ORD(setup);
 894    ORD(canvas_alpha_get);
 895    ORD(output_free);
 896    ORD(output_resize);
 897    ORD(output_tile_size_set);
 898    ORD(output_redraws_rect_add);
 899    ORD(output_redraws_rect_del);
 900    ORD(output_redraws_clear);
 901    ORD(output_redraws_next_update_get);
 902    ORD(output_redraws_next_update_push);
 903    ORD(context_cutout_add);
 904    ORD(context_cutout_clear);
 905    ORD(output_flush);
 906    ORD(output_idle_flush);
 907    ORD(output_dump);
 908    ORD(rectangle_draw);
 909    ORD(line_draw);
 910    ORD(polygon_point_add);
 911    ORD(polygon_points_clear);
 912    ORD(polygon_draw);
 913
 914    ORD(image_load);
 915    ORD(image_new_from_data);
 916    ORD(image_new_from_copied_data);
 917    ORD(image_free);
 918    ORD(image_size_get);
 919    ORD(image_size_set);
 920    ORD(image_dirty_region);
 921    ORD(image_data_get);
 922    ORD(image_data_put);
 923    ORD(image_data_preload_request);
 924    ORD(image_data_preload_cancel);
 925    ORD(image_alpha_set);
 926    ORD(image_alpha_get);
 927    ORD(image_border_set);
 928    ORD(image_border_get);
 929    ORD(image_draw);
 930    ORD(image_comment_get);
 931    ORD(image_format_get);
 932    ORD(image_colorspace_set);
 933    ORD(image_colorspace_get);
 934    ORD(image_native_set);
 935    ORD(image_native_get);
 936 //   ORD(image_draw_filtered);
 937 //   ORD(image_filtered_get);
 938 //   ORD(image_filtered_save);
 939 //   ORD(image_filtered_free);
 940    ORD(font_draw);
 941
 942    ORD(image_scale_hint_set);
 943    ORD(image_scale_hint_get);
 944
 945    ORD(image_map_draw);
 946    ORD(image_map_surface_new);
 947    ORD(image_map_surface_free);
 948
 949 //   ORD(image_content_hint_set);
 950 //   ORD(image_content_hint_get);
 951
 952 //   ORD(image_cache_flush);
 953 //   ORD(image_cache_set);
 954 //   ORD(image_cache_get);
 955
 956 //   ORD(gl_surface_create);
 957 //   ORD(gl_surface_destroy);
 958 //   ORD(gl_context_create);
 959 //   ORD(gl_context_destroy);
 960 //   ORD(gl_make_current);
 961 //   ORD(gl_proc_address_get);
 962 //   ORD(gl_native_surface_get);
 963
 964 //   ORD(gl_api_get);
 965
 966    ORD(image_load_error_get);
 967
 968    /* now advertise out own api */
 969    em->functions = (void *)(&func);
 970    return 1;
 971 }
 972
 973 static void
 974 module_close(Evas_Module *em)
 975 {
 976     eina_log_domain_unregister(_evas_engine_GL_SDL_log_dom);
 977     evas_gl_common_module_close();
 978 }
 979
 980 static Evas_Module_Api evas_modapi =
 981 {
 982    EVAS_MODULE_API_VERSION,
 983    "gl_sdl",
 984    "none",
 985    {
 986      module_open,
 987      module_close
 988    }
 989 };
 990
 991 EVAS_MODULE_DEFINE(EVAS_MODULE_TYPE_ENGINE, engine, gl_sdl);
 992
 993 #ifndef EVAS_STATIC_BUILD_GL_SDL
 994 EVAS_EINA_MODULE_DEFINE(engine, gl_sdl);
 995 #endif
 996
 997 static void*
 998 _sdl_output_setup               (int w, int h, int fullscreen, int noframe)
 999 {
1000    Render_Engine                *re = calloc(1, sizeof(Render_Engine));
1001    SDL_Surface                  *surface;
1002    int                          context_attrs[3];
1003    int                          config_attrs[20];
1004    int                          major_version, minor_version;
1005    int                          num_config;
1006
1007    /* if we haven't initialized - init (automatic abort if already done) */
1008    evas_common_cpu_init();
1009    evas_common_blend_init();
1010    evas_common_image_init();
1011    evas_common_convert_init();
1012    evas_common_scale_init();
1013    evas_common_rectangle_init();
1014    evas_common_polygon_init();
1015    evas_common_line_init();
1016    evas_common_font_init();
1017    evas_common_draw_init();
1018    evas_common_tilebuf_init();
1019
1020    if (w <= 0) w = 640;
1021    if (h <= 0) h = 480;
1022
1023    /* GL Initialization */
1024 #ifdef HAVE_SDL_GL_CONTEXT_VERSION
1025    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
1026    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
1027 #endif
1028    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
1029    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
1030    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
1031    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
1032    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
1033    SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 0);
1034
1035    surface = SDL_SetVideoMode(w, h, 32, EVAS_SDL_GL_FLAG
1036                            | (fullscreen ? SDL_FULLSCREEN : 0)
1037                            | (noframe ? SDL_NOFRAME : 0));
1038
1039    if (!surface)
1040      {
1041         CRIT("SDL_SetVideoMode [ %i x %i x 32 ] failed. %s", w, h, SDL_GetError());
1042         SDL_Quit();
1043         exit(-1);
1044      }
1045
1046    INF("Screen Depth: %d, Vendor: '%s', Renderer: '%s', Version: '%s'", SDL_GetVideoSurface()->format->BitsPerPixel, glGetString(GL_VENDOR), glGetString(GL_RENDERER), glGetString(GL_VERSION));
1047
1048    re->gl_context = evas_gl_common_context_new();
1049    if (!re->gl_context)
1050      {
1051         free(re);
1052         return NULL;
1053      }
1054    evas_gl_common_context_use(re->gl_context);
1055    evas_gl_common_context_resize(re->gl_context, w, h, re->gl_context->rot);
1056
1057    /* End GL Initialization */
1058    re->w = w;
1059    re->h = h;
1060    return re;
1061 }
1062