src/modules/engines/gl_common/evas_gl_context.c

   1 #include "evas_gl_private.h"
   2
   3 #ifdef HAVE_DLSYM
   4 # include <dlfcn.h>      /* dlopen,dlclose,etc */
   5 #else
   6 # error gl_common should not get compiled if dlsym is not found on the system!
   7 #endif
   8
   9 #define PRG_INVALID 0xffffffff
  10 #define GLPIPES 1
  11
  12 static int sym_done = 0;
  13 int _evas_engine_GL_common_log_dom = -1;
  14
  15 typedef void    (*glsym_func_void) ();
  16
  17 void (*glsym_glGenFramebuffers)      (GLsizei a, GLuint *b) = NULL;
  18 void (*glsym_glBindFramebuffer)      (GLenum a, GLuint b) = NULL;
  19 void (*glsym_glFramebufferTexture2D) (GLenum a, GLenum b, GLenum c, GLuint d, GLint e) = NULL;
  20 void (*glsym_glDeleteFramebuffers)   (GLsizei a, const GLuint *b) = NULL;
  21 void (*glsym_glGetProgramBinary)     (GLuint a, GLsizei b, GLsizei *c, GLenum *d, void *e) = NULL;
  22 void (*glsym_glProgramBinary)        (GLuint a, GLenum b, const void *c, GLint d) = NULL;
  23 void (*glsym_glProgramParameteri)    (GLuint a, GLuint b, GLint d) = NULL;
  24
  25 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
  26 // just used for finding symbols :)
  27 typedef void (*_eng_fn) (void);
  28
  29 typedef _eng_fn       (*secsym_func_eng_fn) ();
  30 typedef unsigned int  (*secsym_func_uint) ();
  31 typedef void         *(*secsym_func_void_ptr) ();
  32
  33 static _eng_fn  (*secsym_eglGetProcAddress)          (const char *a) = NULL;
  34
  35 void          *(*secsym_eglCreateImage)               (void *a, void *b, GLenum c, void *d, const int *e) = NULL;
  36 unsigned int   (*secsym_eglDestroyImage)              (void *a, void *b) = NULL;
  37 void           (*secsym_glEGLImageTargetTexture2DOES) (int a, void *b) = NULL;
  38 void          *(*secsym_eglMapImageSEC)               (void *a, void *b) = NULL;
  39 unsigned int   (*secsym_eglUnmapImageSEC)             (void *a, void *b) = NULL;
  40 unsigned int   (*secsym_eglGetImageAttribSEC)         (void *a, void *b, int c, int *d) = NULL;
  41 #endif
  42
  43 static int dbgflushnum = -1;
  44
  45 static void
  46 sym_missing(void)
  47 {
  48    ERR("GL symbols missing!");
  49 }
  50
  51 static void
  52 gl_symbols(void)
  53 {
  54    if (sym_done) return;
  55    sym_done = 1;
  56
  57    /* FIXME: If using the SDL engine, we should use SDL_GL_GetProcAddress
  58     * instead of dlsym
  59     * if (!dst) dst = (typ)SDL_GL_GetProcAddress(sym)
  60     */
  61 #define FINDSYM(dst, sym, typ) if (!dst) dst = (typ)dlsym(RTLD_DEFAULT, sym)
  62 #define FALLBAK(dst, typ) if (!dst) dst = (typ)sym_missing;
  63
  64    FINDSYM(glsym_glGenFramebuffers, "glGenFramebuffers", glsym_func_void);
  65    FINDSYM(glsym_glGenFramebuffers, "glGenFramebuffersEXT", glsym_func_void);
  66    FINDSYM(glsym_glGenFramebuffers, "glGenFramebuffersARB", glsym_func_void);
  67    FALLBAK(glsym_glGenFramebuffers, glsym_func_void);
  68
  69    FINDSYM(glsym_glBindFramebuffer, "glBindFramebuffer", glsym_func_void);
  70    FINDSYM(glsym_glBindFramebuffer, "glBindFramebufferEXT", glsym_func_void);
  71    FINDSYM(glsym_glBindFramebuffer, "glBindFramebufferARB", glsym_func_void);
  72    FALLBAK(glsym_glBindFramebuffer, glsym_func_void);
  73
  74    FINDSYM(glsym_glFramebufferTexture2D, "glFramebufferTexture2D", glsym_func_void);
  75    FINDSYM(glsym_glFramebufferTexture2D, "glFramebufferTexture2DEXT", glsym_func_void);
  76    FINDSYM(glsym_glFramebufferTexture2D, "glFramebufferTexture2DARB", glsym_func_void);
  77    FALLBAK(glsym_glFramebufferTexture2D, glsym_func_void);
  78
  79    FINDSYM(glsym_glDeleteFramebuffers, "glDeleteFramebuffers", glsym_func_void);
  80    FINDSYM(glsym_glDeleteFramebuffers, "glDeleteFramebuffersEXT", glsym_func_void);
  81    FINDSYM(glsym_glDeleteFramebuffers, "glDeleteFramebuffersARB", glsym_func_void);
  82    FALLBAK(glsym_glDeleteFramebuffers, glsym_func_void);
  83
  84    FINDSYM(glsym_glGetProgramBinary, "glGetProgramBinary", glsym_func_void);
  85    FINDSYM(glsym_glGetProgramBinary, "glGetProgramBinaryEXT", glsym_func_void);
  86    FINDSYM(glsym_glGetProgramBinary, "glGetProgramBinaryARB", glsym_func_void);
  87    FINDSYM(glsym_glGetProgramBinary, "glGetProgramBinaryOES", glsym_func_void);
  88
  89    FINDSYM(glsym_glProgramBinary, "glProgramBinary", glsym_func_void);
  90    FINDSYM(glsym_glProgramBinary, "glProgramBinaryEXT", glsym_func_void);
  91    FINDSYM(glsym_glProgramBinary, "glProgramBinaryARB", glsym_func_void);
  92
  93    FINDSYM(glsym_glProgramParameteri, "glProgramParameteri", glsym_func_void);
  94    FINDSYM(glsym_glProgramParameteri, "glProgramParameteriEXT", glsym_func_void);
  95    FINDSYM(glsym_glProgramParameteri, "glProgramParameteriARB", glsym_func_void);
  96
  97 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
  98 #undef FINDSYM
  99 #define FINDSYM(dst, sym, typ) \
 100    if ((!dst) && (secsym_eglGetProcAddress)) dst = (typ)secsym_eglGetProcAddress(sym); \
 101    if (!dst) dst = (typ)dlsym(RTLD_DEFAULT, sym)
 102 // yes - gl core looking for egl stuff. i know it's odd. a reverse-layer thing
 103 // but it will work as the egl/glx layer calls gl core common stuff and thus
 104 // these symbols will work. making the glx/egl + x11 layer do this kind-of is
 105 // wrong as this is not x11 (output) layer specific like the native surface
 106 // stuff. this is generic zero-copy textures for gl
 107
 108    FINDSYM(secsym_eglGetProcAddress, "eglGetProcAddress", secsym_func_eng_fn);
 109    FINDSYM(secsym_eglGetProcAddress, "eglGetProcAddressEXT", secsym_func_eng_fn);
 110    FINDSYM(secsym_eglGetProcAddress, "eglGetProcAddressARB", secsym_func_eng_fn);
 111    FINDSYM(secsym_eglGetProcAddress, "eglGetProcAddressKHR", secsym_func_eng_fn);
 112
 113    FINDSYM(secsym_eglCreateImage, "eglCreateImage", secsym_func_void_ptr);
 114    FINDSYM(secsym_eglCreateImage, "eglCreateImageEXT", secsym_func_void_ptr);
 115    FINDSYM(secsym_eglCreateImage, "eglCreateImageARB", secsym_func_void_ptr);
 116    FINDSYM(secsym_eglCreateImage, "eglCreateImageKHR", secsym_func_void_ptr);
 117
 118    FINDSYM(secsym_eglDestroyImage, "eglDestroyImage", secsym_func_uint);
 119    FINDSYM(secsym_eglDestroyImage, "eglDestroyImageEXT", secsym_func_uint);
 120    FINDSYM(secsym_eglDestroyImage, "eglDestroyImageARB", secsym_func_uint);
 121    FINDSYM(secsym_eglDestroyImage, "eglDestroyImageKHR", secsym_func_uint);
 122
 123    FINDSYM(glsym_glGetProgramBinary, "glGetProgramBinary", glsym_func_void);
 124    FINDSYM(glsym_glGetProgramBinary, "glGetProgramBinaryEXT", glsym_func_void);
 125    FINDSYM(glsym_glGetProgramBinary, "glGetProgramBinaryARB", glsym_func_void);
 126    FINDSYM(glsym_glGetProgramBinary, "glGetProgramBinaryOES", glsym_func_void);
 127    FINDSYM(glsym_glGetProgramBinary, "glGetProgramBinaryKHR", glsym_func_void);
 128
 129    FINDSYM(glsym_glProgramBinary, "glProgramBinary", glsym_func_void);
 130    FINDSYM(glsym_glProgramBinary, "glProgramBinaryEXT", glsym_func_void);
 131    FINDSYM(glsym_glProgramBinary, "glProgramBinaryARB", glsym_func_void);
 132    FINDSYM(glsym_glProgramBinary, "glProgramBinaryOES", glsym_func_void);
 133    FINDSYM(glsym_glProgramBinary, "glProgramBinaryKHR", glsym_func_void);
 134
 135    FINDSYM(glsym_glProgramParameteri, "glProgramParameteri", glsym_func_void);
 136    FINDSYM(glsym_glProgramParameteri, "glProgramParameteriEXT", glsym_func_void);
 137    FINDSYM(glsym_glProgramParameteri, "glProgramParameteriARB", glsym_func_void);
 138    FINDSYM(glsym_glProgramParameteri, "glProgramParameteriOES", glsym_func_void);
 139    FINDSYM(glsym_glProgramParameteri, "glProgramParameteriKHR", glsym_func_void);
 140
 141    FINDSYM(secsym_glEGLImageTargetTexture2DOES, "glEGLImageTargetTexture2DOES", glsym_func_void);
 142
 143    FINDSYM(secsym_eglMapImageSEC, "eglMapImageSEC", secsym_func_void_ptr);
 144
 145    FINDSYM(secsym_eglUnmapImageSEC, "eglUnmapImageSEC", secsym_func_uint);
 146
 147    FINDSYM(secsym_eglGetImageAttribSEC, "eglGetImageAttribSEC", secsym_func_uint);
 148 #endif
 149 }
 150
 151 static void shader_array_flush(Evas_Engine_GL_Context *gc);
 152
 153 static Evas_Engine_GL_Context *_evas_gl_common_context = NULL;
 154 static Evas_GL_Shared *shared = NULL;
 155
 156 void
 157 glerr(int err, const char *file, const char *func, int line, const char *op)
 158 {
 159    const char *errmsg;
 160    char buf[32];
 161
 162    switch (err)
 163      {
 164      case GL_INVALID_ENUM:
 165         errmsg = "GL_INVALID_ENUM";
 166         break;
 167      case GL_INVALID_VALUE:
 168         errmsg = "GL_INVALID_VALUE";
 169         break;
 170      case GL_INVALID_OPERATION:
 171         errmsg = "GL_INVALID_OPERATION";
 172         break;
 173      case GL_OUT_OF_MEMORY:
 174         errmsg = "GL_OUT_OF_MEMORY";
 175         break;
 176      default:
 177         snprintf(buf, sizeof(buf), "%#x", err);
 178         errmsg = buf;
 179      }
 180
 181    eina_log_print(_evas_engine_GL_common_log_dom, EINA_LOG_LEVEL_ERR,
 182                   file, func, line, "%s: %s", op, errmsg);
 183 }
 184
 185 static void
 186 matrix_ortho(GLfloat *m,
 187              GLfloat l, GLfloat r,
 188              GLfloat t, GLfloat b,
 189              GLfloat near, GLfloat far,
 190              int rot, int vw, int vh,
 191              int foc, GLfloat orth)
 192 {
 193    GLfloat rotf;
 194    GLfloat cosv, sinv;
 195    GLfloat tx, ty;
 196
 197    rotf = (((rot / 90) & 0x3) * M_PI) / 2.0;
 198
 199    tx = -0.5 * (1.0 - orth);
 200    ty = -0.5 * (1.0 - orth);
 201
 202    if (rot == 90)
 203      {
 204         tx += -(vw * 1.0);
 205         ty += -(vh * 0.0);
 206      }
 207    if (rot == 180)
 208      {
 209         tx += -(vw * 1.0);
 210         ty += -(vh * 1.0);
 211      }
 212    if (rot == 270)
 213      {
 214         tx += -(vw * 0.0);
 215         ty += -(vh * 1.0);
 216      }
 217
 218    cosv = cos(rotf);
 219    sinv = sin(rotf);
 220
 221    m[0] = (2.0 / (r - l)) * ( cosv);
 222    m[1] = (2.0 / (r - l)) * ( sinv);
 223    m[2] = 0.0;
 224    m[3] = 0.0;
 225
 226    m[4] = (2.0 / (t - b)) * (-sinv);
 227    m[5] = (2.0 / (t - b)) * ( cosv);
 228    m[6] = 0.0;
 229    m[7] = 0.0;
 230
 231    m[8] = 0.0;
 232    m[9] = 0.0;
 233    m[10] = -(2.0 / (far - near));
 234    m[11] = 1.0 / (GLfloat)foc;
 235
 236    m[12] = (m[0] * tx) + (m[4] * ty) - ((r + l) / (r - l));
 237    m[13] = (m[1] * tx) + (m[5] * ty) - ((t + b) / (t - b));
 238    m[14] = (m[2] * tx) + (m[6] * ty) - ((near + far) / (far - near));
 239    m[15] = (m[3] * tx) + (m[7] * ty) + orth;
 240 }
 241
 242 static int
 243 _evas_gl_common_version_check()
 244 {
 245    char *version;
 246    char *tmp;
 247    char *tmp2;
 248    int major;
 249    int minor;
 250
 251   /*
 252    * glGetString returns a string describing the current GL connection.
 253    * GL_VERSION is used to get the version of the connection
 254    */
 255
 256    version = (char *)glGetString(GL_VERSION);
 257
 258   /*
 259    * OpengL ES
 260    *
 261    * 1.* : The form is:
 262    *
 263    * OpenGL ES-<profile> <major>.<minor>
 264    *
 265    * where <profile> is either "CM" or "CL". The minor can be followed by the vendor
 266    * specific information
 267    *
 268    * 2.0 : The form is:
 269    *
 270    * OpenGL<space>ES<space><version number><space><vendor-specific information>
 271    */
 272
 273    /* OpenGL ES 1.* ? */
 274
 275    if ((tmp = strstr(version, "OpenGL ES-CM ")) || (tmp = strstr(version, "OpenGL ES-CL ")))
 276      {
 277         /* Not supported */
 278         return 0;
 279      }
 280
 281    /* OpenGL ES 2.* ? */
 282
 283    if ((tmp = strstr(version, "OpenGL ES ")))
 284      {
 285         /* Supported */
 286         return 1;
 287      }
 288
 289   /*
 290    * OpenGL
 291    *
 292    * The GL_VERSION and GL_SHADING_LANGUAGE_VERSION strings begin with a
 293    * version number. The version number uses one of these forms:
 294    *
 295    * major_number.minor_number
 296    * major_number.minor_number.release_number
 297    *
 298    * Vendor-specific information may follow the version number. Its format
 299    * depends on the implementation, but a space always separates the
 300    * version number and the vendor-specific information.
 301    */
 302
 303    /* glGetString() returns a static string, and we are going to */
 304    /* modify it, so we get a copy first */
 305    version = strdup(version);
 306    if (!version)
 307      return 0;
 308
 309    tmp = strchr(version, '.');
 310    /* the first '.' always exists */
 311    *tmp = '\0';
 312    major = atoi(version);
 313    /* FIXME: maybe we can assume that minor in only a cipher */
 314    tmp2 = ++tmp;
 315    while ((*tmp != '.') && (*tmp != ' ') && (*tmp != '\0'))
 316      tmp++;
 317    /* *tmp is '\0' : version is major_number.minor_number */
 318    /* *tmp is '.'  : version is major_number.minor_number.release_number */
 319    /* *tmp is ' '  : version is major_number.minor_number followed by vendor */
 320    *tmp = '\0';
 321    minor = atoi(tmp2);
 322    free(version);
 323
 324    if (((major == 1) && (minor >= 4)) || (major >= 2))
 325      return 1;
 326
 327    return 0;
 328 }
 329
 330 static void
 331 _evas_gl_common_viewport_set(Evas_Engine_GL_Context *gc)
 332 {
 333    GLfloat proj[16];
 334    unsigned int i;
 335    int w = 1, h = 1, m = 1, rot = 1, foc = 0;
 336
 337    EINA_SAFETY_ON_NULL_RETURN(gc);
 338    foc = gc->foc;
 339    // surface in pipe 0 will be the same as all pipes
 340    if ((gc->pipe[0].shader.surface == gc->def_surface) ||
 341        (!gc->pipe[0].shader.surface))
 342      {
 343         w = gc->w;
 344         h = gc->h;
 345         rot = gc->rot;
 346      }
 347    else
 348      {
 349         w = gc->pipe[0].shader.surface->w;
 350         h = gc->pipe[0].shader.surface->h;
 351         rot = 0;
 352         m = -1;
 353      }
 354
 355    if ((!gc->change.size) ||
 356        ((gc->shared->w == w) && (gc->shared->h == h) &&
 357            (gc->shared->rot == rot) && (gc->shared->foc == gc->foc) &&
 358            (gc->shared->mflip == m)))
 359       return;
 360
 361    gc->shared->w = w;
 362    gc->shared->h = h;
 363    gc->shared->rot = rot;
 364    gc->shared->mflip = m;
 365    gc->shared->foc = foc;
 366    gc->shared->z0 = gc->z0;
 367    gc->shared->px = gc->px;
 368    gc->shared->py = gc->py;
 369    gc->change.size = 0;
 370
 371    if (foc == 0)
 372      {
 373         if ((rot == 0) || (rot == 180))
 374            glViewport(0, 0, w, h);
 375         else
 376            glViewport(0, 0, h, w);
 377         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 378         // std matrix
 379         if (m == 1)
 380            matrix_ortho(proj,
 381                         0, w, 0, h,
 382                         -1000000.0, 1000000.0,
 383                         rot, w, h,
 384                         1, 1.0);
 385         // v flipped matrix for render-to-texture
 386         else
 387            matrix_ortho(proj,
 388                         0, w, h, 0,
 389                         -1000000.0, 1000000.0,
 390                         rot, w, h,
 391                         1, 1.0);
 392      }
 393    else
 394      {
 395         int px, py, vx, vy, vw = 0, vh = 0, ax = 0, ay = 0, ppx = 0, ppy = 0;
 396
 397         px = gc->shared->px;
 398         py = gc->shared->py;
 399
 400         if      ((rot == 0  ) || (rot == 90 )) ppx = px;
 401         else if ((rot == 180) || (rot == 270)) ppx = w - px;
 402         if      ((rot == 0  ) || (rot == 270)) ppy = py;
 403         else if ((rot == 90 ) || (rot == 180)) ppy = h - py;
 404
 405         vx = ((w / 2) - ppx);
 406         if (vx >= 0)
 407           {
 408              vw = w + (2 * vx);
 409              if      ((rot == 0  ) || (rot == 90 )) ax = 2 * vx;
 410              else if ((rot == 180) || (rot == 270)) ax = 0;
 411           }
 412         else
 413           {
 414              vw = w - (2 * vx);
 415              if      ((rot == 0  ) || (rot == 90 )) ax = 0;
 416              else if ((rot == 180) || (rot == 270)) ax = ppx - px;
 417              vx = 0;
 418           }
 419
 420         vy = ((h / 2) - ppy);
 421         if (vy < 0)
 422           {
 423              vh = h - (2 * vy);
 424              if      ((rot == 0  ))                                 ay = 0;
 425              else if ((rot == 90 ) || (rot == 180) || (rot == 270)) ay = ppy - py;
 426              vy = -vy;
 427           }
 428         else
 429           {
 430              vh = h + (2 * vy);
 431              if      ((rot == 0  ) || (rot == 270)) ay = 2 * vy;
 432              else if ((rot == 90 ) || (rot == 180)) ay = 0;
 433              vy = 0;
 434           }
 435
 436         if (m == -1) ay = vy * 2;
 437
 438         if ((rot == 0) || (rot == 180))
 439            glViewport(-2 * vx, -2 * vy, vw, vh);
 440         else
 441            glViewport(-2 * vy, -2 * vx, vh, vw);
 442         if (m == 1)
 443            matrix_ortho(proj, 0, vw, 0, vh,
 444                         -1000000.0, 1000000.0,
 445                         rot, vw, vh,
 446                         foc, 0.0);
 447         else
 448            matrix_ortho(proj, 0, vw, vh, 0,
 449                         -1000000.0, 1000000.0,
 450                         rot, vw, vh,
 451                         foc, 0.0);
 452         gc->shared->ax = ax;
 453         gc->shared->ay = ay;
 454      }
 455
 456    for (i = 0; i < SHADER_LAST; ++i)
 457      {
 458         glUseProgram(gc->shared->shader[i].prog);
 459         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 460         glUniformMatrix4fv(glGetUniformLocation(gc->shared->shader[i].prog, "mvp"), 1, GL_FALSE, proj);
 461         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 462      }
 463
 464    if (gc->state.current.cur_prog == PRG_INVALID)
 465       glUseProgram(gc->shared->shader[0].prog);
 466    else glUseProgram(gc->state.current.cur_prog);
 467    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 468 }
 469
 470 Evas_Engine_GL_Context *
 471 evas_gl_common_context_new(void)
 472 {
 473    Evas_Engine_GL_Context *gc;
 474    const char *s;
 475    int i;
 476
 477 #if 1
 478    if (_evas_gl_common_context)
 479      {
 480         _evas_gl_common_context->references++;
 481         return _evas_gl_common_context;
 482      }
 483 #endif
 484    if (!_evas_gl_common_version_check())
 485      return NULL;
 486    gc = calloc(1, sizeof(Evas_Engine_GL_Context));
 487    if (!gc) return NULL;
 488
 489    gl_symbols();
 490
 491    gc->references = 1;
 492
 493    _evas_gl_common_context = gc;
 494
 495    for (i = 0; i < MAX_PIPES; i++)
 496       gc->pipe[i].shader.render_op = EVAS_RENDER_BLEND;
 497
 498    if (!shared)
 499      {
 500         const GLubyte *ext;
 501
 502         shared = calloc(1, sizeof(Evas_GL_Shared));
 503         ext = glGetString(GL_EXTENSIONS);
 504         if (ext)
 505           {
 506              if (getenv("EVAS_GL_INFO"))
 507                 fprintf(stderr, "EXT:\n%s\n", ext);
 508              if ((strstr((char *)ext, "GL_ARB_texture_non_power_of_two")) ||
 509                  (strstr((char *)ext, "OES_texture_npot")) ||
 510                  (strstr((char *)ext, "GL_IMG_texture_npot")))
 511                shared->info.tex_npo2 = 1;
 512              if ((strstr((char *)ext, "GL_NV_texture_rectangle")) ||
 513                  (strstr((char *)ext, "GL_EXT_texture_rectangle")) ||
 514                  (strstr((char *)ext, "GL_ARB_texture_rectangle")))
 515                shared->info.tex_rect = 1;
 516              if ((strstr((char *)ext, "GL_ARB_get_program_binary")) ||
 517                  (strstr((char *)ext, "GL_OES_get_program_binary")))
 518                shared->info.bin_program = 1;
 519 #ifdef GL_TEXTURE_MAX_ANISOTROPY_EXT
 520              if ((strstr((char *)ext, "GL_EXT_texture_filter_anisotropic")))
 521                glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,
 522                            &(shared->info.anisotropic));
 523 #endif
 524 #ifdef GL_BGRA
 525              if ((strstr((char *)ext, "GL_EXT_bgra")) ||
 526                  (strstr((char *)ext, "GL_EXT_texture_format_BGRA8888")))
 527                shared->info.bgra = 1;
 528 #endif
 529 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
 530              // FIXME: there should be an extension name/string to check for
 531              // not just symbols in the lib
 532              i = 0;
 533              s = getenv("EVAS_GL_NO_MAP_IMAGE_SEC");
 534              if (s) i = atoi(s);
 535              if (!i)
 536                {
 537                   // test for all needed symbols - be "conservative" and
 538                   // need all of it
 539                   if ((secsym_eglCreateImage) &&
 540                       (secsym_eglDestroyImage) &&
 541                       (secsym_glEGLImageTargetTexture2DOES) &&
 542                       (secsym_eglMapImageSEC) &&
 543                       (secsym_eglUnmapImageSEC) &&
 544                       (secsym_eglGetImageAttribSEC))
 545                      shared->info.sec_image_map = 1;
 546                }
 547 #endif
 548           }
 549         glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,
 550                       &(shared->info.max_texture_units));
 551         glGetIntegerv(GL_MAX_TEXTURE_SIZE,
 552                       &(shared->info.max_texture_size));
 553         shared->info.max_vertex_elements = 6 * 100000;
 554 #ifdef GL_MAX_ELEMENTS_VERTICES
 555 /* only applies to glDrawRangeElements. don't really need to get it.
 556         glGetIntegerv(GL_MAX_ELEMENTS_VERTICES,
 557                       &(shared->info.max_vertex_elements));
 558  */
 559 #endif
 560         s = getenv("EVAS_GL_VERTEX_MAX");
 561         if (s) shared->info.max_vertex_elements = atoi(s);
 562         if (shared->info.max_vertex_elements < 6)
 563            shared->info.max_vertex_elements = 6;
 564
 565         // magic numbers that are a result of imperical testing and getting
 566         // "best case" performance across a range of systems
 567         shared->info.tune.cutout.max                 = DEF_CUTOUT;
 568         shared->info.tune.pipes.max                  = DEF_PIPES;
 569         shared->info.tune.atlas.max_alloc_size       = DEF_ATLAS_ALLOC;
 570         shared->info.tune.atlas.max_alloc_alpha_size = DEF_ATLAS_ALLOC_ALPHA;
 571         shared->info.tune.atlas.max_w                = DEF_ATLAS_W;
 572         shared->info.tune.atlas.max_h                = DEF_ATLAS_H;
 573         shared->info.tune.atlas.slot_size            = DEF_ATLAS_SLOT;
 574
 575         // per gpu hacks. based on impirical measurement of some known gpu's
 576         s = (const char *)glGetString(GL_RENDERER);
 577         if (s)
 578           {
 579              if      (strstr(s, "PowerVR SGX 540"))
 580                 shared->info.tune.pipes.max = DEF_PIPES_SGX_540;
 581              else if (strstr(s, "NVIDIA Tegra"))
 582                 shared->info.tune.pipes.max = DEF_PIPES_TEGRA_2;
 583           }
 584
 585 #define GETENVOPT(name, tune_param, min, max) \
 586         do { \
 587            const char *__v = getenv(name); \
 588            if (__v) { \
 589               shared->info.tune.tune_param = atoi(__v); \
 590               if (shared->info.tune.tune_param > max) \
 591                  shared->info.tune.tune_param = max; \
 592               else if (shared->info.tune.tune_param < min) \
 593                  shared->info.tune.tune_param = min; \
 594            } \
 595         } while (0)
 596
 597         GETENVOPT("EVAS_GL_CUTOUT_MAX", cutout.max, -1, 0x7fffffff);
 598         GETENVOPT("EVAS_GL_PIPES_MAX", pipes.max, 1, MAX_PIPES);
 599         GETENVOPT("EVAS_GL_ATLAS_ALLOC_SIZE", atlas.max_alloc_size, MIN_ATLAS_ALLOC, MAX_ATLAS_ALLOC);
 600         GETENVOPT("EVAS_GL_ATLAS_ALLOC_ALPHA_SIZE", atlas.max_alloc_alpha_size, MIN_ATLAS_ALLOC_ALPHA, MAX_ATLAS_ALLOC_ALPHA);
 601         GETENVOPT("EVAS_GL_ATLAS_MAX_W", atlas.max_w, 0, MAX_ATLAS_W);
 602         GETENVOPT("EVAS_GL_ATLAS_MAX_H", atlas.max_h, 0, MAX_ATLAS_H);
 603         GETENVOPT("EVAS_GL_ATLAS_SLOT_SIZE", atlas.slot_size, MIN_ATLAS_SLOT, MAX_ATLAS_SLOT);
 604         s = (const char *)getenv("EVAS_GL_GET_PROGRAM_BINARY");
 605         if (s)
 606           {
 607              if (atoi(s) == 0) shared->info.bin_program = 0;
 608           }
 609
 610         if (getenv("EVAS_GL_INFO"))
 611            fprintf(stderr,
 612                    "max tex size %ix%i\n"
 613                    "max units %i\n"
 614                    "non-power-2 tex %i\n"
 615                    "rect tex %i\n"
 616                    "bgra : %i\n"
 617                    "max ansiotropic filtering: %3.3f\n"
 618                    "egl sec map image: %i\n"
 619                    "max vertex count: %i\n"
 620                    "\n"
 621                    "(can set EVAS_GL_VERTEX_MAX  EVAS_GL_NO_MAP_IMAGE_SEC  EVAS_GL_INFO  EVAS_GL_MEMINFO )\n"
 622                    "\n"
 623                    "EVAS_GL_GET_PROGRAM_BINARY: %i\n"
 624                    "EVAS_GL_CUTOUT_MAX: %i\n"
 625                    "EVAS_GL_PIPES_MAX: %i\n"
 626                    "EVAS_GL_ATLAS_ALLOC_SIZE: %i\n"
 627                    "EVAS_GL_ATLAS_ALLOC_ALPHA_SIZE: %i\n"
 628                    "EVAS_GL_ATLAS_MAX_W x EVAS_GL_ATLAS_MAX_H: %i x %i\n"
 629                    "EVAS_GL_ATLAS_SLOT_SIZE: %i\n"
 630                    ,
 631                    (int)shared->info.max_texture_size, (int)shared->info.max_texture_size,
 632                    (int)shared->info.max_texture_units,
 633                    (int)shared->info.tex_npo2,
 634                    (int)shared->info.tex_rect,
 635                    (int)shared->info.bgra,
 636                    (double)shared->info.anisotropic,
 637                    (int)shared->info.sec_image_map,
 638                    (int)shared->info.max_vertex_elements,
 639
 640                    (int)shared->info.bin_program,
 641                    (int)shared->info.tune.cutout.max,
 642                    (int)shared->info.tune.pipes.max,
 643                    (int)shared->info.tune.atlas.max_alloc_size,
 644                    (int)shared->info.tune.atlas.max_alloc_alpha_size,
 645                    (int)shared->info.tune.atlas.max_w, (int)shared->info.tune.atlas.max_h,
 646                    (int)shared->info.tune.atlas.slot_size
 647                   );
 648
 649         glDisable(GL_DEPTH_TEST);
 650         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 651         glEnable(GL_DITHER);
 652         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 653         glDisable(GL_BLEND);
 654         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 655         glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 656         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 657         // no dest alpha
 658 //        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // dest alpha
 659 //        glBlendFunc(GL_SRC_ALPHA, GL_ONE); // ???
 660         glDepthMask(GL_FALSE);
 661         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 662
 663         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 664         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 665         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 666         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 667         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 668         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 669         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 670         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 671 #ifdef GL_TEXTURE_MAX_ANISOTROPY_EXT
 672         if (shared->info.anisotropic > 0.0)
 673           {
 674              glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0);
 675              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 676           }
 677 #endif
 678
 679         glEnableVertexAttribArray(SHAD_VERTEX);
 680         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 681         glEnableVertexAttribArray(SHAD_COLOR);
 682         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 683
 684         if (!evas_gl_common_shader_program_init(shared)) goto error;
 685
 686 #define SHADER_TEXTURE_ADD(Shared, Shader, Name)                        \
 687         glUseProgram(Shared->shader[SHADER_##Shader].prog);             \
 688         GLERR(__FUNCTION__, __FILE__, __LINE__, "");                    \
 689         glUniform1i(glGetUniformLocation(Shared->shader[SHADER_##Shader].prog, #Name), Shared->shader[SHADER_##Shader].tex_count++); \
 690         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 691
 692         SHADER_TEXTURE_ADD(shared, YUV, tex);
 693         SHADER_TEXTURE_ADD(shared, YUV, texu);
 694         SHADER_TEXTURE_ADD(shared, YUV, texv);
 695
 696         SHADER_TEXTURE_ADD(shared, YUY2, tex);
 697         SHADER_TEXTURE_ADD(shared, YUY2, texuv);
 698
 699         SHADER_TEXTURE_ADD(shared, NV12, tex);
 700         SHADER_TEXTURE_ADD(shared, NV12, texuv);
 701
 702         SHADER_TEXTURE_ADD(shared, YUV_NOMUL, tex);
 703         SHADER_TEXTURE_ADD(shared, YUV_NOMUL, texu);
 704         SHADER_TEXTURE_ADD(shared, YUV_NOMUL, texv);
 705
 706         SHADER_TEXTURE_ADD(shared, YUY2_NOMUL, tex);
 707         SHADER_TEXTURE_ADD(shared, YUY2_NOMUL, texuv);
 708
 709         SHADER_TEXTURE_ADD(shared, NV12_NOMUL, tex);
 710         SHADER_TEXTURE_ADD(shared, NV12_NOMUL, texuv);
 711
 712         SHADER_TEXTURE_ADD(shared, IMG_MASK, tex);
 713         SHADER_TEXTURE_ADD(shared, IMG_MASK, texm);
 714
 715         if (gc->state.current.cur_prog == PRG_INVALID)
 716            glUseProgram(gc->shared->shader[0].prog);
 717         else glUseProgram(gc->state.current.cur_prog);
 718         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 719
 720         evas_gl_common_shader_program_init_done();
 721         // in shader:
 722         // uniform sampler2D tex[8];
 723         //
 724         // in code:
 725         // GLuint texes[8];
 726         // GLint loc = glGetUniformLocation(prog, "tex");
 727         // glUniform1iv(loc, 8, texes);
 728
 729         shared->native_pm_hash  = eina_hash_int32_new(NULL);
 730         shared->native_tex_hash = eina_hash_int32_new(NULL);
 731      }
 732    gc->shared = shared;
 733    gc->shared->references++;
 734    _evas_gl_common_viewport_set(gc);
 735
 736    gc->def_surface = evas_gl_common_image_surface_new(gc, 1, 1, 1);
 737
 738    return gc;
 739    error:
 740    evas_gl_common_context_free(gc);
 741    return NULL;
 742 }
 743
 744 void
 745 evas_gl_common_context_free(Evas_Engine_GL_Context *gc)
 746 {
 747    int i, j;
 748    Eina_List *l;
 749
 750    gc->references--;
 751    if (gc->references > 0) return;
 752    if (gc->shared) gc->shared->references--;
 753
 754    if (gc->def_surface) evas_gl_common_image_free(gc->def_surface);
 755
 756    if (gc->shared)
 757      {
 758         for (i = 0; i < gc->shared->info.tune.pipes.max; i++)
 759           {
 760              if (gc->pipe[i].array.vertex) free(gc->pipe[i].array.vertex);
 761              if (gc->pipe[i].array.color) free(gc->pipe[i].array.color);
 762              if (gc->pipe[i].array.texuv) free(gc->pipe[i].array.texuv);
 763              if (gc->pipe[i].array.texm) free(gc->pipe[i].array.texm);
 764              if (gc->pipe[i].array.texuv2) free(gc->pipe[i].array.texuv2);
 765              if (gc->pipe[i].array.texuv3) free(gc->pipe[i].array.texuv3);
 766           }
 767      }
 768
 769    if ((gc->shared) && (gc->shared->references == 0))
 770      {
 771         Evas_GL_Texture_Pool *pt;
 772
 773         for (i = 0; i < SHADER_LAST; ++i)
 774           evas_gl_common_shader_program_shutdown(&(gc->shared->shader[i]));
 775
 776         while (gc->shared->images)
 777           {
 778              evas_gl_common_image_free(gc->shared->images->data);
 779           }
 780
 781         EINA_LIST_FOREACH(gc->shared->tex.whole, l, pt)
 782            evas_gl_texture_pool_empty(pt);
 783         for (i = 0; i < 33; i++)
 784           {
 785              for (j = 0; j < 3; j++)
 786                {
 787                   EINA_LIST_FOREACH(gc->shared->tex.atlas[i][j], l, pt)
 788                      evas_gl_texture_pool_empty(pt);
 789                }
 790           }
 791         eina_hash_free(gc->shared->native_pm_hash);
 792         eina_hash_free(gc->shared->native_tex_hash);
 793         free(gc->shared);
 794         shared = NULL;
 795      }
 796    if (gc == _evas_gl_common_context) _evas_gl_common_context = NULL;
 797    free(gc);
 798 }
 799
 800 void
 801 evas_gl_common_context_use(Evas_Engine_GL_Context *gc)
 802 {
 803    if (_evas_gl_common_context == gc) return;
 804    _evas_gl_common_context = gc;
 805    if (gc) _evas_gl_common_viewport_set(gc);
 806 }
 807
 808 void
 809 evas_gl_common_context_newframe(Evas_Engine_GL_Context *gc)
 810 {
 811    int i;
 812
 813    if (dbgflushnum < 0)
 814      {
 815         dbgflushnum = 0;
 816         if (getenv("EVAS_GL_DBG")) dbgflushnum = 1;
 817      }
 818    if (dbgflushnum) printf("----prev-flushnum: %i -----------------------------------\n", gc->flushnum);
 819
 820    gc->flushnum = 0;
 821    gc->state.current.cur_prog = 0;
 822    gc->state.current.cur_tex = 0;
 823    gc->state.current.cur_texu = 0;
 824    gc->state.current.cur_texv = 0;
 825    gc->state.current.cur_texm = 0;
 826    gc->state.current.cur_texmu = 0;
 827    gc->state.current.cur_texmv = 0;
 828    gc->state.current.render_op = 0;
 829    gc->state.current.smooth = 0;
 830    gc->state.current.blend = 0;
 831    gc->state.current.clip = 0;
 832    gc->state.current.cx = 0;
 833    gc->state.current.cy = 0;
 834    gc->state.current.cw = 0;
 835    gc->state.current.ch = 0;
 836
 837    for (i = 0; i < gc->shared->info.tune.pipes.max; i++)
 838      {
 839         gc->pipe[i].region.x = 0;
 840         gc->pipe[i].region.y = 0;
 841         gc->pipe[i].region.w = 0;
 842         gc->pipe[i].region.h = 0;
 843         gc->pipe[i].region.type = 0;
 844         gc->pipe[i].clip.active = 0;
 845         gc->pipe[i].clip.x = 0;
 846         gc->pipe[i].clip.y = 0;
 847         gc->pipe[i].clip.w = 0;
 848         gc->pipe[i].clip.h = 0;
 849         gc->pipe[i].shader.surface = NULL;
 850         gc->pipe[i].shader.cur_prog = 0;
 851         gc->pipe[i].shader.cur_tex = 0;
 852         gc->pipe[i].shader.cur_texu = 0;
 853         gc->pipe[i].shader.cur_texv = 0;
 854         gc->pipe[i].shader.cur_texm = 0;
 855         gc->pipe[i].shader.render_op = EVAS_RENDER_BLEND;
 856         gc->pipe[i].shader.smooth = 0;
 857         gc->pipe[i].shader.blend = 0;
 858         gc->pipe[i].shader.clip = 0;
 859         gc->pipe[i].shader.cx = 0;
 860         gc->pipe[i].shader.cy = 0;
 861         gc->pipe[i].shader.cw = 0;
 862         gc->pipe[i].shader.ch = 0;
 863      }
 864    gc->change.size = 1;
 865
 866    glDisable(GL_SCISSOR_TEST);
 867    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 868    glScissor(0, 0, 0, 0);
 869    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 870
 871    glDisable(GL_DEPTH_TEST);
 872    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 873    glEnable(GL_DITHER);
 874    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 875    glDisable(GL_BLEND);
 876    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 877    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 878    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 879    // no dest alpha
 880 //   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // dest alpha
 881 //   glBlendFunc(GL_SRC_ALPHA, GL_ONE); // ???
 882    glDepthMask(GL_FALSE);
 883    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 884
 885    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 886    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 887    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 888    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 889    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 890    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 891    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 892    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 893 #ifdef GL_TEXTURE_MAX_ANISOTROPY_EXT
 894    if (shared->info.anisotropic > 0.0)
 895      {
 896         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0);
 897         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 898      }
 899 #endif
 900
 901    glEnableVertexAttribArray(SHAD_VERTEX);
 902    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 903    glEnableVertexAttribArray(SHAD_COLOR);
 904    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 905    if (gc->state.current.cur_prog == PRG_INVALID)
 906       glUseProgram(gc->shared->shader[0].prog);
 907    else glUseProgram(gc->state.current.cur_prog);
 908    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 909
 910    glActiveTexture(GL_TEXTURE0);
 911    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 912    glBindTexture(GL_TEXTURE_2D, gc->pipe[0].shader.cur_tex);
 913    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 914
 915    _evas_gl_common_viewport_set(gc);
 916 }
 917
 918 void
 919 evas_gl_common_context_resize(Evas_Engine_GL_Context *gc, int w, int h, int rot)
 920 {
 921    if ((gc->w == w) && (gc->h == h) && (gc->rot == rot)) return;
 922    evas_gl_common_context_flush(gc);
 923    gc->change.size = 1;
 924    gc->rot = rot;
 925    gc->w = w;
 926    gc->h = h;
 927    if (_evas_gl_common_context == gc) _evas_gl_common_viewport_set(gc);
 928 }
 929
 930 void
 931 evas_gl_common_context_target_surface_set(Evas_Engine_GL_Context *gc,
 932                                           Evas_GL_Image *surface)
 933 {
 934    if (surface == gc->pipe[0].shader.surface) return;
 935
 936    evas_gl_common_context_flush(gc);
 937
 938    gc->state.current.cur_prog = PRG_INVALID;
 939    gc->state.current.cur_tex = -1;
 940    gc->state.current.cur_texu = -1;
 941    gc->state.current.cur_texv = -1;
 942    gc->state.current.render_op = -1;
 943    gc->state.current.smooth = -1;
 944    gc->state.current.blend = -1;
 945    gc->state.current.clip = -1;
 946    gc->state.current.cx = -1;
 947    gc->state.current.cy = -1;
 948    gc->state.current.cw = -1;
 949    gc->state.current.ch = -1;
 950
 951    gc->pipe[0].shader.surface = surface;
 952    gc->change.size = 1;
 953 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
 954 # ifndef GL_FRAMEBUFFER
 955 #  define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
 956 # endif
 957 #else
 958 # ifndef GL_FRAMEBUFFER
 959 #  define GL_FRAMEBUFFER GL_FRAMEBUFFER_EXT
 960 # endif
 961 #endif
 962    if (gc->pipe[0].shader.surface == gc->def_surface)
 963      {
 964         glsym_glBindFramebuffer(GL_FRAMEBUFFER, 0);
 965         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 966      }
 967    else
 968      {
 969         glsym_glBindFramebuffer(GL_FRAMEBUFFER, surface->tex->pt->fb);
 970         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 971      }
 972    _evas_gl_common_viewport_set(gc);
 973 }
 974
 975 #define PUSH_VERTEX(n, x, y, z) \
 976    gc->pipe[n].array.vertex[nv++] = x; \
 977    gc->pipe[n].array.vertex[nv++] = y; \
 978    gc->pipe[n].array.vertex[nv++] = z
 979 #define PUSH_COLOR(n, r, g, b, a) \
 980    gc->pipe[n].array.color[nc++] = r; \
 981    gc->pipe[n].array.color[nc++] = g; \
 982    gc->pipe[n].array.color[nc++] = b; \
 983    gc->pipe[n].array.color[nc++] = a
 984 #define PUSH_TEXUV(n, u, v) \
 985    gc->pipe[n].array.texuv[nu++] = u; \
 986    gc->pipe[n].array.texuv[nu++] = v
 987 #define PUSH_TEXUV2(n, u, v) \
 988    gc->pipe[n].array.texuv2[nu2++] = u; \
 989    gc->pipe[n].array.texuv2[nu2++] = v
 990 #define PUSH_TEXUV3(n, u, v) \
 991    gc->pipe[n].array.texuv3[nu3++] = u; \
 992    gc->pipe[n].array.texuv3[nu3++] = v
 993 #define PUSH_TEXM(n, u, v) \
 994    gc->pipe[n].array.texm[nm++] = u; \
 995    gc->pipe[n].array.texm[nm++] = v
 996
 997
 998 static inline void
 999 array_alloc(Evas_Engine_GL_Context *gc, int n)
1000 {
1001    gc->havestuff = EINA_TRUE;
1002    if (gc->pipe[n].array.num <= gc->pipe[n].array.alloc) return;
1003    gc->pipe[n].array.alloc += 6 * 1024;
1004    if (gc->pipe[n].array.use_vertex)
1005      gc->pipe[n].array.vertex = realloc(gc->pipe[n].array.vertex,
1006                                 gc->pipe[n].array.alloc * sizeof(GLshort) * 3);
1007    if (gc->pipe[n].array.use_color)
1008      gc->pipe[n].array.color  = realloc(gc->pipe[n].array.color,
1009                                 gc->pipe[n].array.alloc * sizeof(GLubyte) * 4);
1010    if (gc->pipe[n].array.use_texuv)
1011      gc->pipe[n].array.texuv  = realloc(gc->pipe[n].array.texuv,
1012                                 gc->pipe[n].array.alloc * sizeof(GLfloat) * 2);
1013    if (gc->pipe[n].array.use_texm)
1014      gc->pipe[n].array.texm  = realloc(gc->pipe[n].array.texm,
1015                                 gc->pipe[n].array.alloc * sizeof(GLfloat) * 2);
1016    if (gc->pipe[n].array.use_texuv2)
1017      gc->pipe[n].array.texuv2  = realloc(gc->pipe[n].array.texuv2,
1018                                gc->pipe[n].array.alloc * sizeof(GLfloat) * 2);
1019    if (gc->pipe[n].array.use_texuv3)
1020      gc->pipe[n].array.texuv3  = realloc(gc->pipe[n].array.texuv3,
1021                                  gc->pipe[n].array.alloc * sizeof(GLfloat) * 2);
1022 }
1023
1024 #ifdef GLPIPES
1025 static int
1026 pipe_region_intersects(Evas_Engine_GL_Context *gc, int n,
1027                        int x, int y, int w, int h)
1028 {
1029    int i, rx, ry, rw, rh, ii;
1030
1031    rx = gc->pipe[n].region.x;
1032    ry = gc->pipe[n].region.y;
1033    rw = gc->pipe[n].region.w;
1034    rh = gc->pipe[n].region.h;
1035    if (!RECTS_INTERSECT(x, y, w, h, rx, ry, rw, rh))
1036       return 0;
1037
1038    // a hack for now. map pipes use their whole bounding box for intersects
1039    // which at worst case reduces to old pipeline flushes, but cheaper than
1040    // full quad region or triangle intersects right now
1041    if (gc->pipe[n].region.type == RTYPE_MAP) return 1;
1042
1043    for (i = 0,
1044         ii = 0;
1045
1046         i < gc->pipe[n].array.num;
1047
1048         i += (3 * 2),
1049         ii += (3 * 3 * 2))
1050      {  // tri 1...
1051         // 0, 1, 2 < top left
1052         // 3, 4, 5 < top right
1053         // 6. 7, 8 < bottom left
1054         rx = gc->pipe[n].array.vertex[ii + 0];
1055         ry = gc->pipe[n].array.vertex[ii + 1];
1056         rw = gc->pipe[n].array.vertex[ii + 3] - rx;
1057         rh = gc->pipe[n].array.vertex[ii + 7] - ry;
1058         if (RECTS_INTERSECT(x, y, w, h, rx, ry, rw, rh))
1059            return 1;
1060      }
1061    return 0;
1062 }
1063 #endif
1064
1065 static void
1066 pipe_region_expand(Evas_Engine_GL_Context *gc, int n,
1067                    int x, int y, int w, int h)
1068 {
1069    int x1, y1, x2, y2;
1070
1071    if (gc->pipe[n].region.w <= 0)
1072      {
1073         gc->pipe[n].region.x = x;
1074         gc->pipe[n].region.y = y;
1075         gc->pipe[n].region.w = w;
1076         gc->pipe[n].region.h = h;
1077         return;
1078      }
1079    x1 = gc->pipe[n].region.x;
1080    y1 = gc->pipe[n].region.y;
1081    x2 = gc->pipe[n].region.x + gc->pipe[n].region.w;
1082    y2 = gc->pipe[n].region.y + gc->pipe[n].region.h;
1083    if (x < x1) x1 = x;
1084    if (y < y1) y1 = y;
1085    if ((x + w) > x2) x2 = x + w;
1086    if ((y + h) > y2) y2 = y + h;
1087    gc->pipe[n].region.x = x1;
1088    gc->pipe[n].region.y = y1;
1089    gc->pipe[n].region.w = x2 - x1;
1090    gc->pipe[n].region.h = y2 - y1;
1091 }
1092
1093 static Eina_Bool
1094 vertex_array_size_check(Evas_Engine_GL_Context *gc, int pn, int n)
1095 {
1096    return 1;
1097 // this fixup breaks for expedite test 32. why?
1098    if ((gc->pipe[pn].array.num + n) > gc->shared->info.max_vertex_elements)
1099      {
1100         shader_array_flush(gc);
1101         return 0;
1102      }
1103    return 1;
1104 }
1105
1106 static inline Evas_GL_Shader
1107 evas_gl_common_shader_choice(int npoints __UNUSED__,
1108                              RGBA_Map_Point *p,
1109                              int r, int g, int b, int a,
1110                              Evas_GL_Shader nomul,
1111                              Evas_GL_Shader mul)
1112 {
1113   if ((a == 255) && (r == 255) && (g == 255) && (b == 255))
1114     {
1115        if (!p) return nomul;
1116
1117        if ((p[0].col == 0xffffffff) && (p[1].col == 0xffffffff) &&
1118            (p[2].col == 0xffffffff) && (p[3].col == 0xffffffff))
1119          return nomul;
1120     }
1121   return mul;
1122 }
1123
1124 static int
1125 _evas_gl_common_context_push(int rtype,
1126                              Evas_Engine_GL_Context *gc,
1127                              Evas_GL_Texture *tex,
1128                              Evas_GL_Texture *texm,
1129                              GLuint prog,
1130                              int x, int y, int w, int h,
1131                              Eina_Bool blend,
1132                              Eina_Bool smooth,
1133                              Eina_Bool clip,
1134                              int cx, int cy, int cw, int ch)
1135 {
1136    int pn = 0;
1137
1138 #ifdef GLPIPES
1139  again:
1140 #endif
1141    vertex_array_size_check(gc, gc->state.top_pipe, 6);
1142    pn = gc->state.top_pipe;
1143 #ifdef GLPIPES
1144    if (!((pn == 0) && (gc->pipe[pn].array.num == 0)))
1145      {
1146         int found = 0;
1147         int i;
1148
1149         for (i = pn; i >= 0; i--)
1150           {
1151              if ((gc->pipe[i].region.type == rtype)
1152                  && (!tex || gc->pipe[i].shader.cur_tex == tex->pt->texture)
1153                  && (!texm || gc->pipe[i].shader.cur_texm == texm->pt->texture)
1154                  && (gc->pipe[i].shader.cur_prog == prog)
1155                  && (gc->pipe[i].shader.smooth == smooth)
1156                  && (gc->pipe[i].shader.blend == blend)
1157                  && (gc->pipe[i].shader.render_op == gc->dc->render_op)
1158                  && (gc->pipe[i].shader.clip == clip)
1159                  && (!clip || ((gc->pipe[i].shader.cx == cx)
1160                                && (gc->pipe[i].shader.cy == cy)
1161                                && (gc->pipe[i].shader.cw == cw)
1162                                && (gc->pipe[i].shader.ch == ch))))
1163                {
1164                   found = 1;
1165                   pn = i;
1166                   break;
1167                }
1168              if (pipe_region_intersects(gc, i, x, y, w, h)) break;
1169           }
1170         if (!found)
1171           {
1172              pn = gc->state.top_pipe + 1;
1173              if (pn >= gc->shared->info.tune.pipes.max)
1174                {
1175                   shader_array_flush(gc);
1176                   goto again;
1177                }
1178              gc->state.top_pipe = pn;
1179          }
1180      }
1181    if ((tex) && (((tex->im) && (tex->im->native.data)) || tex->pt->dyn.img))
1182      {
1183         if (gc->pipe[pn].array.im != tex->im)
1184           {
1185              shader_array_flush(gc);
1186              pn = gc->state.top_pipe;
1187              gc->pipe[pn].array.im = tex->im;
1188              goto again;
1189           }
1190      }
1191 #else
1192    if (!((gc->pipe[pn].region.type == rtype)
1193          && (!tex || gc->pipe[pn].shader.cur_tex == tex->pt->texture)
1194          && (!texm || gc->pipe[pn].shader.cur_texm == texm->pt->texture)
1195          && (gc->pipe[pn].shader.cur_prog == prog)
1196          && (gc->pipe[pn].shader.smooth == smooth)
1197          && (gc->pipe[pn].shader.blend == blend)
1198          && (gc->pipe[pn].shader.render_op == gc->dc->render_op)
1199          && (gc->pipe[pn].shader.clip == clip)
1200          && (!clip || ((gc->pipe[pn].shader.cx == cx)
1201                        && (gc->pipe[pn].shader.cy == cy)
1202                        && (gc->pipe[pn].shader.cw == cw)
1203                        && (gc->pipe[pn].shader.ch == ch)))))
1204      {
1205         shader_array_flush(gc);
1206      }
1207    if ((tex) && (((tex->im) && (tex->im->native.data)) || tex->pt->dyn.img))
1208      {
1209         if (gc->pipe[pn].array.im != tex->im)
1210           {
1211              shader_array_flush(gc);
1212              gc->pipe[pn].array.im = tex->im;
1213           }
1214      }
1215 #endif
1216
1217    return pn;
1218 }
1219
1220 void
1221 evas_gl_common_context_line_push(Evas_Engine_GL_Context *gc,
1222                                  int x1, int y1, int x2, int y2,
1223                                  int clip, int cx, int cy, int cw, int ch,
1224                                  int r, int g, int b, int a)
1225 {
1226    int pnum, nv, nc, nu, nt, i;
1227    Eina_Bool blend = 0;
1228    GLuint prog = gc->shared->shader[SHADER_RECT].prog;
1229    int pn = 0;
1230
1231    if (a < 255) blend = 1;
1232    if (gc->dc->render_op == EVAS_RENDER_COPY) blend = 0;
1233
1234    shader_array_flush(gc);
1235    vertex_array_size_check(gc, gc->state.top_pipe, 2);
1236    pn = gc->state.top_pipe;
1237    gc->pipe[pn].shader.cur_tex = 0;
1238    gc->pipe[pn].shader.cur_prog = prog;
1239    gc->pipe[pn].shader.blend = blend;
1240    gc->pipe[pn].shader.render_op = gc->dc->render_op;
1241    gc->pipe[pn].shader.clip = clip;
1242    gc->pipe[pn].shader.cx = cx;
1243    gc->pipe[pn].shader.cy = cy;
1244    gc->pipe[pn].shader.cw = cw;
1245    gc->pipe[pn].shader.ch = ch;
1246
1247    gc->pipe[pn].array.line = 1;
1248    gc->pipe[pn].array.use_vertex = 1;
1249    gc->pipe[pn].array.use_color = 1;
1250    gc->pipe[pn].array.use_texuv = 0;
1251    gc->pipe[pn].array.use_texuv2 = 0;
1252    gc->pipe[pn].array.use_texuv3 = 0;
1253
1254    pnum = gc->pipe[pn].array.num;
1255    nv = pnum * 3; nc = pnum * 4; nu = pnum * 2; nt = pnum * 4;
1256    gc->pipe[pn].array.num += 2;
1257    array_alloc(gc, pn);
1258
1259    PUSH_VERTEX(pn, x1, y1, 0);
1260    PUSH_VERTEX(pn, x2, y2, 0);
1261
1262    for (i = 0; i < 2; i++)
1263      {
1264         PUSH_COLOR(pn, r, g, b, a);
1265      }
1266
1267    shader_array_flush(gc);
1268    gc->pipe[pn].array.line = 0;
1269    gc->pipe[pn].array.use_vertex = 0;
1270    gc->pipe[pn].array.use_color = 0;
1271    gc->pipe[pn].array.use_texuv = 0;
1272    gc->pipe[pn].array.use_texuv2 = 0;
1273    gc->pipe[pn].array.use_texuv3 = 0;
1274 }
1275
1276 void
1277 evas_gl_common_context_rectangle_push(Evas_Engine_GL_Context *gc,
1278                                       int x, int y, int w, int h,
1279                                       int r, int g, int b, int a)
1280 {
1281    int pnum, nv, nc, nu, nt, i;
1282    Eina_Bool blend = 0;
1283    GLuint prog = gc->shared->shader[SHADER_RECT].prog;
1284    int pn = 0;
1285
1286    if (gc->dc->mask.mask)
1287      {
1288         RGBA_Draw_Context *dc;
1289         dc = gc->dc;
1290         Evas_GL_Image *im;
1291         im = (void *)dc->mask.mask;
1292         evas_gl_common_context_font_push(gc, im->tex,
1293                                 x - dc->mask.x,y - dc->mask.y,
1294                                 dc->mask.w,dc->mask.h,
1295                                 x,y,w,h,r,g,b,a);
1296         return;
1297      }
1298
1299    if (a < 255) blend = 1;
1300    if (gc->dc->render_op == EVAS_RENDER_COPY) blend = 0;
1301
1302 again:
1303    vertex_array_size_check(gc, gc->state.top_pipe, 6);
1304    pn = gc->state.top_pipe;
1305 #ifdef GLPIPES
1306    if ((pn == 0) && (gc->pipe[pn].array.num == 0))
1307      {
1308         gc->pipe[pn].region.type = RTYPE_RECT;
1309         gc->pipe[pn].shader.cur_tex = 0;
1310         gc->pipe[pn].shader.cur_prog = prog;
1311         gc->pipe[pn].shader.blend = blend;
1312         gc->pipe[pn].shader.render_op = gc->dc->render_op;
1313         gc->pipe[pn].shader.clip = 0;
1314         gc->pipe[pn].shader.cx = 0;
1315         gc->pipe[pn].shader.cy = 0;
1316         gc->pipe[pn].shader.cw = 0;
1317         gc->pipe[pn].shader.ch = 0;
1318         gc->pipe[pn].array.line = 0;
1319         gc->pipe[pn].array.use_vertex = 1;
1320         gc->pipe[pn].array.use_color = 1;
1321         gc->pipe[pn].array.use_texuv = 0;
1322         gc->pipe[pn].array.use_texuv2 = 0;
1323         gc->pipe[pn].array.use_texuv3 = 0;
1324      }
1325    else
1326      {
1327         int found = 0;
1328
1329         for (i = pn; i >= 0; i--)
1330           {
1331              if ((gc->pipe[i].region.type == RTYPE_RECT)
1332                  && (gc->pipe[i].shader.cur_tex == 0)
1333                  && (gc->pipe[i].shader.cur_prog == prog)
1334                  && (gc->pipe[i].shader.blend == blend)
1335                  && (gc->pipe[i].shader.render_op == gc->dc->render_op)
1336                  && (gc->pipe[i].shader.clip == 0)
1337                 )
1338                {
1339                   found = 1;
1340                   pn = i;
1341                   break;
1342                }
1343              if (pipe_region_intersects(gc, i, x, y, w, h)) break;
1344           }
1345         if (!found)
1346           {
1347              pn = gc->state.top_pipe + 1;
1348              if (pn >= gc->shared->info.tune.pipes.max)
1349                {
1350                   shader_array_flush(gc);
1351                   goto again;
1352                }
1353              gc->state.top_pipe = pn;
1354              gc->pipe[pn].region.type = RTYPE_RECT;
1355              gc->pipe[pn].shader.cur_tex = 0;
1356              gc->pipe[pn].shader.cur_prog = prog;
1357              gc->pipe[pn].shader.blend = blend;
1358              gc->pipe[pn].shader.render_op = gc->dc->render_op;
1359              gc->pipe[pn].shader.clip = 0;
1360              gc->pipe[pn].shader.cx = 0;
1361              gc->pipe[pn].shader.cy = 0;
1362              gc->pipe[pn].shader.cw = 0;
1363              gc->pipe[pn].shader.ch = 0;
1364              gc->pipe[pn].array.line = 0;
1365              gc->pipe[pn].array.use_vertex = 1;
1366              gc->pipe[pn].array.use_color = 1;
1367              gc->pipe[pn].array.use_texuv = 0;
1368              gc->pipe[pn].array.use_texuv2 = 0;
1369              gc->pipe[pn].array.use_texuv3 = 0;
1370          }
1371      }
1372 #else
1373    if ((gc->pipe[pn].shader.cur_tex != 0)
1374        || (gc->pipe[pn].shader.cur_prog != prog)
1375        || (gc->pipe[pn].shader.blend != blend)
1376        || (gc->pipe[pn].shader.render_op != gc->dc->render_op)
1377        || (gc->pipe[pn].shader.clip != 0)
1378        )
1379      {
1380         shader_array_flush(gc);
1381         pn = gc->state.top_pipe;
1382         gc->pipe[pn].shader.cur_tex = 0;
1383         gc->pipe[pn].shader.cur_prog = prog;
1384         gc->pipe[pn].shader.blend = blend;
1385         gc->pipe[pn].shader.render_op = gc->dc->render_op;
1386         gc->pipe[pn].shader.clip = 0;
1387         gc->pipe[pn].shader.cx = 0;
1388         gc->pipe[pn].shader.cy = 0;
1389         gc->pipe[pn].shader.cw = 0;
1390         gc->pipe[pn].shader.ch = 0;
1391      }
1392
1393    gc->pipe[pn].region.type = RTYPE_RECT;
1394    gc->pipe[pn].array.line = 0;
1395    gc->pipe[pn].array.use_vertex = 1;
1396    gc->pipe[pn].array.use_color = 1;
1397    gc->pipe[pn].array.use_texuv = 0;
1398    gc->pipe[pn].array.use_texuv2 = 0;
1399    gc->pipe[pn].array.use_texuv3 = 0;
1400 #endif
1401
1402    pipe_region_expand(gc, pn, x, y, w, h);
1403
1404    pnum = gc->pipe[pn].array.num;
1405    nv = pnum * 3; nc = pnum * 4; nu = pnum * 2; nt = pnum * 4;
1406    gc->pipe[pn].array.num += 6;
1407    array_alloc(gc, pn);
1408
1409    PUSH_VERTEX(pn, x    , y    , 0);
1410    PUSH_VERTEX(pn, x + w, y    , 0);
1411    PUSH_VERTEX(pn, x    , y + h, 0);
1412
1413    PUSH_VERTEX(pn, x + w, y    , 0);
1414    PUSH_VERTEX(pn, x + w, y + h, 0);
1415    PUSH_VERTEX(pn, x    , y + h, 0);
1416
1417    for (i = 0; i < 6; i++)
1418      {
1419         PUSH_COLOR(pn, r, g, b, a);
1420      }
1421 }
1422
1423 void
1424 evas_gl_common_context_image_push(Evas_Engine_GL_Context *gc,
1425                                   Evas_GL_Texture *tex,
1426                                   double sx, double sy, double sw, double sh,
1427                                   int x, int y, int w, int h,
1428                                   int r, int g, int b, int a,
1429                                   Eina_Bool smooth, Eina_Bool tex_only)
1430 {
1431    int pnum, nv, nc, nu, nu2, nt, i;
1432    GLfloat tx1, tx2, ty1, ty2;
1433    Eina_Bool blend = 1;
1434    GLuint prog = gc->shared->shader[SHADER_IMG].prog;
1435    int pn = 0;
1436
1437    if (!tex->alpha) blend = 0;
1438    if (a < 255) blend = 1;
1439
1440    if (gc->filter_prog)
1441      {
1442         prog = gc->filter_prog;
1443      }
1444    else if (tex_only)
1445      {
1446         if (tex->pt->dyn.img)
1447           {
1448              prog = gc->shared->shader[evas_gl_common_shader_choice(0, NULL, r, g, b, a,
1449                                                                     SHADER_IMG_BGRA_NOMUL, SHADER_IMG_BGRA)].prog;
1450           }
1451         else
1452           {
1453              prog = gc->shared->shader[evas_gl_common_shader_choice(0, NULL, r, g, b, a,
1454                                                                     SHADER_TEX_NOMUL, SHADER_TEX)].prog;
1455           }
1456      }
1457    else
1458      {
1459         if (tex->gc->shared->info.bgra)
1460           {
1461              prog = gc->shared->shader[evas_gl_common_shader_choice(0, NULL, r, g, b, a,
1462                                                                     SHADER_IMG_BGRA_NOMUL, SHADER_IMG_BGRA)].prog;
1463           }
1464         else
1465           {
1466              prog = gc->shared->shader[evas_gl_common_shader_choice(0, NULL, r, g, b, a,
1467                                                                     SHADER_IMG_NOMUL, SHADER_IMG)].prog;
1468           }
1469      }
1470
1471    pn = _evas_gl_common_context_push(RTYPE_IMAGE,
1472                                      gc, tex, NULL,
1473                                      prog,
1474                                      x, y, w, h,
1475                                      blend,
1476                                      smooth,
1477                                      0, 0, 0, 0, 0);
1478
1479    gc->pipe[pn].region.type = RTYPE_IMAGE;
1480    gc->pipe[pn].shader.cur_tex = tex->pt->texture;
1481    gc->pipe[pn].shader.cur_prog = prog;
1482    gc->pipe[pn].shader.smooth = smooth;
1483    gc->pipe[pn].shader.blend = blend;
1484    gc->pipe[pn].shader.render_op = gc->dc->render_op;
1485    gc->pipe[pn].shader.clip = 0;
1486    gc->pipe[pn].shader.cx = 0;
1487    gc->pipe[pn].shader.cy = 0;
1488    gc->pipe[pn].shader.cw = 0;
1489    gc->pipe[pn].shader.ch = 0;
1490    gc->pipe[pn].array.line = 0;
1491    gc->pipe[pn].array.use_vertex = 1;
1492    // if nomul... dont need this
1493    gc->pipe[pn].array.use_color = 1;
1494    gc->pipe[pn].array.use_texuv = 1;
1495    gc->pipe[pn].array.use_texuv2 = 0;
1496    gc->pipe[pn].array.use_texuv3 = 0;
1497
1498    pipe_region_expand(gc, pn, x, y, w, h);
1499
1500    pnum = gc->pipe[pn].array.num;
1501    nv = pnum * 3; nc = pnum * 4; nu = pnum * 2; nu2 = pnum * 2;
1502    nt = pnum * 4;
1503    gc->pipe[pn].array.num += 6;
1504    array_alloc(gc, pn);
1505
1506    if ((tex->im) && (tex->im->native.data) && (!tex->im->native.yinvert))
1507      {
1508         tx1 = ((double)(tex->x) + sx) / (double)tex->pt->w;
1509         ty1 = 1.0 - ((double)(tex->y) + sy) / (double)tex->pt->h;
1510         tx2 = ((double)(tex->x) + sx + sw) / (double)tex->pt->w;
1511         ty2 = 1.0 - ((double)(tex->y) + sy + sh) / (double)tex->pt->h;
1512      }
1513    else
1514      {
1515         tx1 = ((double)(tex->x) + sx) / (double)tex->pt->w;
1516         ty1 = ((double)(tex->y) + sy) / (double)tex->pt->h;
1517         tx2 = ((double)(tex->x) + sx + sw) / (double)tex->pt->w;
1518         ty2 = ((double)(tex->y) + sy + sh) / (double)tex->pt->h;
1519      }
1520
1521    PUSH_VERTEX(pn, x    , y    , 0);
1522    PUSH_VERTEX(pn, x + w, y    , 0);
1523    PUSH_VERTEX(pn, x    , y + h, 0);
1524
1525    PUSH_TEXUV(pn, tx1, ty1);
1526    PUSH_TEXUV(pn, tx2, ty1);
1527    PUSH_TEXUV(pn, tx1, ty2);
1528
1529    PUSH_VERTEX(pn, x + w, y    , 0);
1530    PUSH_VERTEX(pn, x + w, y + h, 0);
1531    PUSH_VERTEX(pn, x    , y + h, 0);
1532
1533    PUSH_TEXUV(pn, tx2, ty1);
1534    PUSH_TEXUV(pn, tx2, ty2);
1535    PUSH_TEXUV(pn, tx1, ty2);
1536
1537    // if nomul... dont need this
1538    for (i = 0; i < 6; i++)
1539      {
1540         PUSH_COLOR(pn, r, g, b, a);
1541      }
1542 }
1543
1544 void
1545 evas_gl_common_context_image_mask_push(Evas_Engine_GL_Context *gc,
1546                                   Evas_GL_Texture *tex,
1547                                   Evas_GL_Texture *texm,
1548                                   double sx, double sy, double sw, double sh,
1549                                   double sxm, double sym, double swm,double shm,
1550                                   int x, int y, int w, int h,
1551                                   int r, int g, int b, int a,
1552                                   Eina_Bool smooth)
1553 {
1554    int pnum, nv, nc, nu, nm, nt, i;
1555    GLfloat tx1, tx2, ty1, ty2;
1556    GLfloat txm1, txm2, tym1, tym2;
1557    Eina_Bool blend = 1;
1558    GLuint prog = gc->shared->shader[SHADER_IMG_MASK].prog;
1559    int pn = 0;
1560
1561 #if 0
1562    if (tex->gc->shared->info.bgra)
1563    {
1564       prog = gc->shared->shader[SHADER_IMG_MASK].prog;
1565    }
1566    else
1567    {
1568 #warning Nash: FIXME: Need two shaders?
1569            printf("Not good: Need other texture\n");
1570            prog = gc->shared->shader[SHADER_IMG].prog;
1571    }
1572 #endif
1573
1574    pn = _evas_gl_common_context_push(RTYPE_IMASK,
1575                                      gc, tex, texm,
1576                                      prog,
1577                                      x, y, w, h,
1578                                      blend,
1579                                      smooth,
1580                                      0, 0, 0, 0, 0);
1581
1582    gc->pipe[pn].region.type = RTYPE_IMASK;
1583    gc->pipe[pn].shader.cur_tex = tex->pt->texture;
1584    gc->pipe[pn].shader.cur_texm = texm->pt->texture;
1585    gc->pipe[pn].shader.cur_prog = prog;
1586    gc->pipe[pn].shader.smooth = smooth;
1587    gc->pipe[pn].shader.blend = blend;
1588    gc->pipe[pn].shader.render_op = gc->dc->render_op;
1589    gc->pipe[pn].shader.clip = 0;
1590    gc->pipe[pn].shader.cx = 0;
1591    gc->pipe[pn].shader.cy = 0;
1592    gc->pipe[pn].shader.cw = 0;
1593    gc->pipe[pn].shader.ch = 0;
1594    gc->pipe[pn].array.line = 0;
1595    gc->pipe[pn].array.use_vertex = 1;
1596    // if nomul... dont need this
1597    gc->pipe[pn].array.use_color = 1;
1598    gc->pipe[pn].array.use_texuv = 1;
1599    gc->pipe[pn].array.use_texuv2 = 0;
1600    gc->pipe[pn].array.use_texuv3 = 0;
1601    gc->pipe[pn].array.use_texm = 1;
1602
1603    pipe_region_expand(gc, pn, x, y, w, h);
1604
1605    pnum = gc->pipe[pn].array.num;
1606    nv = pnum * 3; nc = pnum * 4; nm = pnum * 2; nu = pnum * 2;
1607    nt = pnum * 4;
1608    gc->pipe[pn].array.num += 6;
1609    array_alloc(gc, pn);
1610
1611    if ((tex->im) && (tex->im->native.data) && (!tex->im->native.yinvert))
1612      {
1613         tx1 = ((double)(tex->x) + sx) / (double)tex->pt->w;
1614         ty1 = ((double)(tex->y) + sy + sh) / (double)tex->pt->h;
1615         tx2 = ((double)(tex->x) + sx + sw) / (double)tex->pt->w;
1616         ty2 = ((double)(tex->y) + sy) / (double)tex->pt->h;
1617
1618         txm1 = ((double)(texm->x) + sxm) / (double)texm->pt->w;
1619         tym1 = ((double)(texm->y) + sym + shm) / (double)texm->pt->h;
1620         txm2 = ((double)(texm->x) + sxm + swm) / (double)texm->pt->w;
1621         tym2 = ((double)(texm->y) + sym) / (double)texm->pt->h;
1622      }
1623    else
1624      {
1625         tx1 = ((double)(tex->x) + sx) / (double)tex->pt->w;
1626         ty1 = ((double)(tex->y) + sy) / (double)tex->pt->h;
1627         tx2 = ((double)(tex->x) + sx + sw) / (double)tex->pt->w;
1628         ty2 = ((double)(tex->y) + sy + sh) / (double)tex->pt->h;
1629
1630         txm1 = (texm->x + sxm) / (double)texm->pt->w;
1631         tym1 = (texm->y + sym) / (double)texm->pt->h;
1632         txm2 = (texm->x + sxm + swm) / (double)texm->pt->w;
1633         tym2 = (texm->y + sym + shm) / (double)texm->pt->h;
1634      }
1635  // printf(" %3.6lf %3.6lf %3.6lf %3.6lf\n",sx,sy,sw,sh);
1636  //  printf("m%3.6lf %3.6lf %3.6lf %3.6lf\n",sxm,sym,swm,shm);
1637  // printf(" %3f %3f %3f %3f\n",tx1,ty1,tx2,ty2);
1638  // printf("m%3f %3f %3f %3f\n",txm1,tym1,txm2,tym2);
1639
1640    PUSH_VERTEX(pn, x    , y    , 0);
1641    PUSH_VERTEX(pn, x + w, y    , 0);
1642    PUSH_VERTEX(pn, x    , y + h, 0);
1643
1644    PUSH_TEXUV(pn, tx1, ty1);
1645    PUSH_TEXUV(pn, tx2, ty1);
1646    PUSH_TEXUV(pn, tx1, ty2);
1647
1648    PUSH_TEXM(pn, txm1, tym1);
1649    PUSH_TEXM(pn, txm2, tym1);
1650    PUSH_TEXM(pn, txm1, tym2);
1651
1652    PUSH_VERTEX(pn, x + w, y    , 0);
1653    PUSH_VERTEX(pn, x + w, y + h, 0);
1654    PUSH_VERTEX(pn, x    , y + h, 0);
1655
1656    PUSH_TEXUV(pn, tx2, ty1);
1657    PUSH_TEXUV(pn, tx2, ty2);
1658    PUSH_TEXUV(pn, tx1, ty2);
1659
1660    PUSH_TEXM(pn, txm2, tym1);
1661    PUSH_TEXM(pn, txm2, tym2);
1662    PUSH_TEXM(pn, txm1, tym2);
1663
1664    // if nomul... dont need this
1665    for (i = 0; i < 6; i++)
1666      {
1667         PUSH_COLOR(pn, r, g, b, a);
1668      }
1669 }
1670
1671
1672 void
1673 evas_gl_common_context_font_push(Evas_Engine_GL_Context *gc,
1674                                  Evas_GL_Texture *tex,
1675                                  double sx, double sy, double sw, double sh,
1676                                  int x, int y, int w, int h,
1677                                  int r, int g, int b, int a)
1678 {
1679    int pnum, nv, nc, nu, nt, i;
1680    GLfloat tx1, tx2, ty1, ty2;
1681    GLuint prog = gc->shared->shader[SHADER_FONT].prog;
1682    int pn = 0;
1683
1684    pn = _evas_gl_common_context_push(RTYPE_FONT,
1685                                      gc, tex, NULL,
1686                                      prog,
1687                                      x, y, w, h,
1688                                      1,
1689                                      0,
1690                                      0, 0, 0, 0, 0);
1691
1692    gc->pipe[pn].region.type = RTYPE_FONT;
1693    gc->pipe[pn].shader.cur_tex = tex->pt->texture;
1694    gc->pipe[pn].shader.cur_prog = prog;
1695    gc->pipe[pn].shader.smooth = 0;
1696    gc->pipe[pn].shader.blend = 1;
1697    gc->pipe[pn].shader.render_op = gc->dc->render_op;
1698    gc->pipe[pn].shader.clip = 0;
1699    gc->pipe[pn].shader.cx = 0;
1700    gc->pipe[pn].shader.cy = 0;
1701    gc->pipe[pn].shader.cw = 0;
1702    gc->pipe[pn].shader.ch = 0;
1703    gc->pipe[pn].array.line = 0;
1704    gc->pipe[pn].array.use_vertex = 1;
1705    gc->pipe[pn].array.use_color = 1;
1706    gc->pipe[pn].array.use_texuv = 1;
1707    gc->pipe[pn].array.use_texuv2 = 0;
1708    gc->pipe[pn].array.use_texuv3 = 0;
1709
1710    pipe_region_expand(gc, pn, x, y, w, h);
1711
1712    pnum = gc->pipe[pn].array.num;
1713    nv = pnum * 3; nc = pnum * 4; nu = pnum * 2; nt = pnum * 4;
1714    gc->pipe[pn].array.num += 6;
1715    array_alloc(gc, pn);
1716
1717    if (sw == 0.0)
1718      {
1719         tx1 = tex->sx1;
1720         ty1 = tex->sy1;
1721         tx2 = tex->sx2;
1722         ty2 = tex->sy2;
1723      }
1724    else
1725      {
1726         tx1 = ((double)(tex->x) + sx) / (double)tex->pt->w;
1727         ty1 = ((double)(tex->y) + sy) / (double)tex->pt->h;
1728         tx2 = ((double)(tex->x) + sx + sw) / (double)tex->pt->w;
1729         ty2 = ((double)(tex->y) + sy + sh) / (double)tex->pt->h;
1730      }
1731
1732    PUSH_VERTEX(pn, x    , y    , 0);
1733    PUSH_VERTEX(pn, x + w, y    , 0);
1734    PUSH_VERTEX(pn, x    , y + h, 0);
1735
1736    PUSH_TEXUV(pn, tx1, ty1);
1737    PUSH_TEXUV(pn, tx2, ty1);
1738    PUSH_TEXUV(pn, tx1, ty2);
1739
1740    PUSH_VERTEX(pn, x + w, y    , 0);
1741    PUSH_VERTEX(pn, x + w, y + h, 0);
1742    PUSH_VERTEX(pn, x    , y + h, 0);
1743
1744    PUSH_TEXUV(pn, tx2, ty1);
1745    PUSH_TEXUV(pn, tx2, ty2);
1746    PUSH_TEXUV(pn, tx1, ty2);
1747
1748    for (i = 0; i < 6; i++)
1749      {
1750         PUSH_COLOR(pn, r, g, b, a);
1751      }
1752 }
1753
1754 void
1755 evas_gl_common_context_yuv_push(Evas_Engine_GL_Context *gc,
1756                                 Evas_GL_Texture *tex,
1757                                 double sx, double sy, double sw, double sh,
1758                                 int x, int y, int w, int h,
1759                                 int r, int g, int b, int a,
1760                                 Eina_Bool smooth)
1761 {
1762    int pnum, nv, nc, nu, nu2, nu3, nt, i;
1763    GLfloat tx1, tx2, ty1, ty2, t2x1, t2x2, t2y1, t2y2;
1764    Eina_Bool blend = 0;
1765    GLuint prog;
1766    int pn = 0;
1767
1768    if (a < 255) blend = 1;
1769
1770    prog = gc->shared->shader[evas_gl_common_shader_choice(0, NULL, r, g, b, a,
1771                                                           SHADER_YUV_NOMUL, SHADER_YUV)].prog;
1772
1773    pn = _evas_gl_common_context_push(RTYPE_YUV,
1774                                      gc, tex, NULL,
1775                                      prog,
1776                                      x, y, w, h,
1777                                      blend,
1778                                      smooth,
1779                                      0, 0, 0, 0, 0);
1780
1781    gc->pipe[pn].region.type = RTYPE_YUV;
1782    gc->pipe[pn].shader.cur_tex = tex->pt->texture;
1783    gc->pipe[pn].shader.cur_texu = tex->ptu->texture;
1784    gc->pipe[pn].shader.cur_texv = tex->ptv->texture;
1785    gc->pipe[pn].shader.cur_prog = prog;
1786    gc->pipe[pn].shader.smooth = smooth;
1787    gc->pipe[pn].shader.blend = blend;
1788    gc->pipe[pn].shader.render_op = gc->dc->render_op;
1789    gc->pipe[pn].shader.clip = 0;
1790    gc->pipe[pn].shader.cx = 0;
1791    gc->pipe[pn].shader.cy = 0;
1792    gc->pipe[pn].shader.cw = 0;
1793    gc->pipe[pn].shader.ch = 0;
1794    gc->pipe[pn].array.line = 0;
1795    gc->pipe[pn].array.use_vertex = 1;
1796    gc->pipe[pn].array.use_color = 1;
1797    gc->pipe[pn].array.use_texuv = 1;
1798    gc->pipe[pn].array.use_texuv2 = 1;
1799    gc->pipe[pn].array.use_texuv3 = 1;
1800
1801    pipe_region_expand(gc, pn, x, y, w, h);
1802
1803    pnum = gc->pipe[pn].array.num;
1804    nv = pnum * 3; nc = pnum * 4; nu = pnum * 2;
1805    nu2 = pnum * 2; nu3 = pnum * 2; nt = pnum * 4;
1806    gc->pipe[pn].array.num += 6;
1807    array_alloc(gc, pn);
1808
1809    tx1 = (sx) / (double)tex->pt->w;
1810    ty1 = (sy) / (double)tex->pt->h;
1811    tx2 = (sx + sw) / (double)tex->pt->w;
1812    ty2 = (sy + sh) / (double)tex->pt->h;
1813
1814    t2x1 = ((sx) / 2) / (double)tex->ptu->w;
1815    t2y1 = ((sy) / 2) / (double)tex->ptu->h;
1816    t2x2 = ((sx + sw) / 2) / (double)tex->ptu->w;
1817    t2y2 = ((sy + sh) / 2) / (double)tex->ptu->h;
1818
1819    PUSH_VERTEX(pn, x    , y    , 0);
1820    PUSH_VERTEX(pn, x + w, y    , 0);
1821    PUSH_VERTEX(pn, x    , y + h, 0);
1822
1823    PUSH_TEXUV(pn, tx1, ty1);
1824    PUSH_TEXUV(pn, tx2, ty1);
1825    PUSH_TEXUV(pn, tx1, ty2);
1826
1827    PUSH_TEXUV2(pn, t2x1, t2y1);
1828    PUSH_TEXUV2(pn, t2x2, t2y1);
1829    PUSH_TEXUV2(pn, t2x1, t2y2);
1830
1831    PUSH_TEXUV3(pn, t2x1, t2y1);
1832    PUSH_TEXUV3(pn, t2x2, t2y1);
1833    PUSH_TEXUV3(pn, t2x1, t2y2);
1834
1835    PUSH_VERTEX(pn, x + w, y    , 0);
1836    PUSH_VERTEX(pn, x + w, y + h, 0);
1837    PUSH_VERTEX(pn, x    , y + h, 0);
1838
1839    PUSH_TEXUV(pn, tx2, ty1);
1840    PUSH_TEXUV(pn, tx2, ty2);
1841    PUSH_TEXUV(pn, tx1, ty2);
1842
1843    PUSH_TEXUV2(pn, t2x2, t2y1);
1844    PUSH_TEXUV2(pn, t2x2, t2y2);
1845    PUSH_TEXUV2(pn, t2x1, t2y2);
1846
1847    PUSH_TEXUV3(pn, t2x2, t2y1);
1848    PUSH_TEXUV3(pn, t2x2, t2y2);
1849    PUSH_TEXUV3(pn, t2x1, t2y2);
1850
1851    for (i = 0; i < 6; i++)
1852      {
1853         PUSH_COLOR(pn, r, g, b, a);
1854      }
1855 }
1856
1857 void
1858 evas_gl_common_context_yuy2_push(Evas_Engine_GL_Context *gc,
1859                                  Evas_GL_Texture *tex,
1860                                  double sx, double sy, double sw, double sh,
1861                                  int x, int y, int w, int h,
1862                                  int r, int g, int b, int a,
1863                                  Eina_Bool smooth)
1864 {
1865    int pnum, nv, nc, nu, nu2, nu3, nt, i;
1866    GLfloat tx1, tx2, ty1, ty2, t2x1, t2x2, t2y1, t2y2;
1867    Eina_Bool blend = 0;
1868    GLuint prog;
1869    int pn = 0;
1870
1871    if (a < 255) blend = 1;
1872
1873    prog = gc->shared->shader[evas_gl_common_shader_choice(0, NULL, r, g, b, a,
1874                                                           SHADER_YUY2_NOMUL, SHADER_YUY2)].prog;
1875
1876    pn = _evas_gl_common_context_push(RTYPE_YUY2,
1877                                      gc, tex, NULL,
1878                                      prog,
1879                                      x, y, w, h,
1880                                      blend,
1881                                      smooth,
1882                                      0, 0, 0, 0, 0);
1883
1884    gc->pipe[pn].region.type = RTYPE_YUY2;
1885    gc->pipe[pn].shader.cur_tex = tex->pt->texture;
1886    gc->pipe[pn].shader.cur_texu = tex->ptuv->texture;
1887    gc->pipe[pn].shader.cur_prog = prog;
1888    gc->pipe[pn].shader.smooth = smooth;
1889    gc->pipe[pn].shader.blend = blend;
1890    gc->pipe[pn].shader.render_op = gc->dc->render_op;
1891    gc->pipe[pn].shader.clip = 0;
1892    gc->pipe[pn].shader.cx = 0;
1893    gc->pipe[pn].shader.cy = 0;
1894    gc->pipe[pn].shader.cw = 0;
1895    gc->pipe[pn].shader.ch = 0;
1896    gc->pipe[pn].array.line = 0;
1897    gc->pipe[pn].array.use_vertex = 1;
1898    gc->pipe[pn].array.use_color = 1;
1899    gc->pipe[pn].array.use_texuv = 1;
1900    gc->pipe[pn].array.use_texuv2 = 1;
1901    gc->pipe[pn].array.use_texuv3 = 0;
1902
1903    pipe_region_expand(gc, pn, x, y, w, h);
1904
1905    pnum = gc->pipe[pn].array.num;
1906    nv = pnum * 3; nc = pnum * 4; nu = pnum * 2;
1907    nu2 = pnum * 2; nu3 = pnum * 2; nt = pnum * 4;
1908    gc->pipe[pn].array.num += 6;
1909    array_alloc(gc, pn);
1910
1911    tx1 = (sx) / (double)tex->pt->w;
1912    ty1 = (sy) / (double)tex->pt->h;
1913    tx2 = (sx + sw) / (double)tex->pt->w;
1914    ty2 = (sy + sh) / (double)tex->pt->h;
1915
1916    t2x1 = sx / (double)tex->ptuv->w;
1917    t2y1 = sy / (double)tex->ptuv->h;
1918    t2x2 = (sx + sw) / (double)tex->ptuv->w;
1919    t2y2 = (sy + sh) / (double)tex->ptuv->h;
1920
1921    PUSH_VERTEX(pn, x    , y    , 0);
1922    PUSH_VERTEX(pn, x + w, y    , 0);
1923    PUSH_VERTEX(pn, x    , y + h, 0);
1924
1925    PUSH_TEXUV(pn, tx1, ty1);
1926    PUSH_TEXUV(pn, tx2, ty1);
1927    PUSH_TEXUV(pn, tx1, ty2);
1928
1929    PUSH_TEXUV2(pn, t2x1, t2y1);
1930    PUSH_TEXUV2(pn, t2x2, t2y1);
1931    PUSH_TEXUV2(pn, t2x1, t2y2);
1932
1933    PUSH_VERTEX(pn, x + w, y    , 0);
1934    PUSH_VERTEX(pn, x + w, y + h, 0);
1935    PUSH_VERTEX(pn, x    , y + h, 0);
1936
1937    PUSH_TEXUV(pn, tx2, ty1);
1938    PUSH_TEXUV(pn, tx2, ty2);
1939    PUSH_TEXUV(pn, tx1, ty2);
1940
1941    PUSH_TEXUV2(pn, t2x2, t2y1);
1942    PUSH_TEXUV2(pn, t2x2, t2y2);
1943    PUSH_TEXUV2(pn, t2x1, t2y2);
1944
1945    for (i = 0; i < 6; i++)
1946      {
1947         PUSH_COLOR(pn, r, g, b, a);
1948      }
1949 }
1950
1951 void
1952 evas_gl_common_context_nv12_push(Evas_Engine_GL_Context *gc,
1953                                  Evas_GL_Texture *tex,
1954                                  double sx, double sy, double sw, double sh,
1955                                  int x, int y, int w, int h,
1956                                  int r, int g, int b, int a,
1957                                  Eina_Bool smooth)
1958 {
1959    int pnum, nv, nc, nu, nu2, nu3, nt, i;
1960    GLfloat tx1, tx2, ty1, ty2, t2x1, t2x2, t2y1, t2y2;
1961    Eina_Bool blend = 0;
1962    GLuint prog;
1963    int pn = 0;
1964
1965    if (a < 255) blend = 1;
1966
1967    prog = gc->shared->shader[evas_gl_common_shader_choice(0, NULL, r, g, b, a,
1968                                                           SHADER_NV12_NOMUL, SHADER_NV12)].prog;
1969
1970    pn = _evas_gl_common_context_push(RTYPE_NV12,
1971                                      gc, tex, NULL,
1972                                      prog,
1973                                      x, y, w, h,
1974                                      blend,
1975                                      smooth,
1976                                      0, 0, 0, 0, 0);
1977
1978    gc->pipe[pn].region.type = RTYPE_NV12;
1979    gc->pipe[pn].shader.cur_tex = tex->pt->texture;
1980    gc->pipe[pn].shader.cur_tex_dyn = tex->pt->dyn.img;
1981    gc->pipe[pn].shader.cur_texu = tex->ptuv->texture;
1982    gc->pipe[pn].shader.cur_texu_dyn = tex->ptuv->dyn.img;
1983    gc->pipe[pn].shader.cur_prog = prog;
1984    gc->pipe[pn].shader.smooth = smooth;
1985    gc->pipe[pn].shader.blend = blend;
1986    gc->pipe[pn].shader.render_op = gc->dc->render_op;
1987    gc->pipe[pn].shader.clip = 0;
1988    gc->pipe[pn].shader.cx = 0;
1989    gc->pipe[pn].shader.cy = 0;
1990    gc->pipe[pn].shader.cw = 0;
1991    gc->pipe[pn].shader.ch = 0;
1992    gc->pipe[pn].array.line = 0;
1993    gc->pipe[pn].array.use_vertex = 1;
1994    gc->pipe[pn].array.use_color = 1;
1995    gc->pipe[pn].array.use_texuv = 1;
1996    gc->pipe[pn].array.use_texuv2 = 1;
1997    gc->pipe[pn].array.use_texuv3 = 0;
1998
1999    pipe_region_expand(gc, pn, x, y, w, h);
2000
2001    pnum = gc->pipe[pn].array.num;
2002    nv = pnum * 3; nc = pnum * 4; nu = pnum * 2;
2003    nu2 = pnum * 2; nu3 = pnum * 2; nt = pnum * 4;
2004    gc->pipe[pn].array.num += 6;
2005    array_alloc(gc, pn);
2006
2007    tx1 = (sx) / (double)tex->pt->w;
2008    ty1 = (sy) / (double)tex->pt->h;
2009    tx2 = (sx + sw) / (double)tex->pt->w;
2010    ty2 = (sy + sh) / (double)tex->pt->h;
2011
2012    t2x1 = sx / (double)tex->ptuv->w;
2013    t2y1 = sy / (double)tex->ptuv->h;
2014    t2x2 = (sx + sw) / (double)tex->ptuv->w;
2015    t2y2 = (sy + sh) / (double)tex->ptuv->h;
2016
2017    PUSH_VERTEX(pn, x    , y    , 0);
2018    PUSH_VERTEX(pn, x + w, y    , 0);
2019    PUSH_VERTEX(pn, x    , y + h, 0);
2020
2021    PUSH_TEXUV(pn, tx1, ty1);
2022    PUSH_TEXUV(pn, tx2, ty1);
2023    PUSH_TEXUV(pn, tx1, ty2);
2024
2025    PUSH_TEXUV2(pn, t2x1, t2y1);
2026    PUSH_TEXUV2(pn, t2x2, t2y1);
2027    PUSH_TEXUV2(pn, t2x1, t2y2);
2028
2029    PUSH_VERTEX(pn, x + w, y    , 0);
2030    PUSH_VERTEX(pn, x + w, y + h, 0);
2031    PUSH_VERTEX(pn, x    , y + h, 0);
2032
2033    PUSH_TEXUV(pn, tx2, ty1);
2034    PUSH_TEXUV(pn, tx2, ty2);
2035    PUSH_TEXUV(pn, tx1, ty2);
2036
2037    PUSH_TEXUV2(pn, t2x2, t2y1);
2038    PUSH_TEXUV2(pn, t2x2, t2y2);
2039    PUSH_TEXUV2(pn, t2x1, t2y2);
2040
2041    for (i = 0; i < 6; i++)
2042      {
2043         PUSH_COLOR(pn, r, g, b, a);
2044      }
2045 }
2046
2047 void
2048 evas_gl_common_context_image_map_push(Evas_Engine_GL_Context *gc,
2049                                       Evas_GL_Texture *tex,
2050                                       int npoints,
2051                                       RGBA_Map_Point *p,
2052                                       int clip, int cx, int cy, int cw, int ch,
2053                                       int r, int g, int b, int a,
2054                                       Eina_Bool smooth, Eina_Bool tex_only,
2055                                       Evas_Colorspace cspace)
2056 {
2057    int pnum, nv, nc, nu, nu2, nu3, nt, i;
2058    const int points[6] = { 0, 1, 2, 0, 2, 3 };
2059    int x = 0, y = 0, w = 0, h = 0, px = 0, py = 0;
2060    GLfloat tx[4], ty[4], t2x[4], t2y[4];
2061    Eina_Bool blend = 1;
2062    DATA32 cmul;
2063    GLuint prog = gc->shared->shader[SHADER_IMG].prog;
2064    Eina_Bool utexture = EINA_FALSE;
2065    Eina_Bool uvtexture = EINA_FALSE;
2066    int pn = 0;
2067    int flat = 0;
2068
2069    if (!tex->alpha) blend = 0;
2070    if (a < 255) blend = 1;
2071    if (npoints != 4)
2072      {
2073         // FIXME: nash - you didn't fix this for n points. its still all
2074         // 4 point stuff!!! grrrr.
2075         abort();
2076      }
2077    if ((A_VAL(&(p[0].col)) < 0xff) || (A_VAL(&(p[1].col)) < 0xff) ||
2078        (A_VAL(&(p[2].col)) < 0xff) || (A_VAL(&(p[3].col)) < 0xff))
2079      blend = 1;
2080
2081    if ((p[0].z == p[1].z) && (p[1].z == p[2].z) && (p[2].z == p[3].z))
2082       flat = 1;
2083
2084    if (!clip) cx = cy = cw = ch = 0;
2085
2086    if (!flat)
2087      {
2088         if (p[0].foc <= 0) flat = 1;
2089      }
2090
2091    switch (cspace)
2092      {
2093       case EVAS_COLORSPACE_YCBCR422P601_PL:
2094       case EVAS_COLORSPACE_YCBCR422P709_PL:
2095          prog = gc->shared->shader[evas_gl_common_shader_choice(npoints, p, r, g, b, a,
2096                                                                 SHADER_YUV_NOMUL, SHADER_YUV)].prog;
2097          utexture = EINA_TRUE;
2098          break;
2099       case EVAS_COLORSPACE_YCBCR422601_PL:
2100          prog = gc->shared->shader[evas_gl_common_shader_choice(npoints, p, r, g, b, a,
2101                                                                 SHADER_YUY2_NOMUL, SHADER_YUY2)].prog;
2102          uvtexture = EINA_TRUE;
2103          break;
2104       case EVAS_COLORSPACE_YCBCR420NV12601_PL:
2105       case EVAS_COLORSPACE_YCBCR420TM12601_PL:
2106          prog = gc->shared->shader[evas_gl_common_shader_choice(npoints, p, r, g, b, a,
2107                                                                 SHADER_NV12_NOMUL, SHADER_NV12)].prog;
2108          uvtexture = EINA_TRUE;
2109          break;
2110
2111       default:
2112          if (tex_only)
2113            {
2114               if (tex->pt->dyn.img)
2115                 {
2116                    prog = gc->shared->shader[evas_gl_common_shader_choice(npoints, p, r, g, b, a,
2117                                                                           SHADER_IMG_BGRA_NOMUL, SHADER_IMG_BGRA)].prog;
2118                 }
2119               else
2120                 {
2121                    prog = gc->shared->shader[evas_gl_common_shader_choice(npoints, p, r, g, b, a,
2122                                                                           SHADER_TEX_NOMUL, SHADER_TEX)].prog;
2123                 }
2124            }
2125          else
2126            {
2127               if (tex->gc->shared->info.bgra)
2128                 {
2129                    prog = gc->shared->shader[evas_gl_common_shader_choice(npoints, p, r, g, b, a,
2130                                                                           SHADER_IMG_BGRA_NOMUL,
2131                                                                           SHADER_IMG_BGRA)].prog;
2132                 }
2133              else
2134                {
2135                   prog = gc->shared->shader[evas_gl_common_shader_choice(npoints, p, r, g, b, a,
2136                                                                          SHADER_IMG_NOMUL,
2137                                                                          SHADER_IMG)].prog;
2138                }
2139            }
2140      }
2141
2142    x = w = (p[0].x >> FP);
2143    y = h = (p[0].y >> FP);
2144    for (i = 0; i < 4; i++)
2145      {
2146         tx[i] = ((double)(tex->x) + (((double)p[i].u) / FP1)) /
2147           (double)tex->pt->w;
2148         ty[i] = ((double)(tex->y) + (((double)p[i].v) / FP1)) /
2149           (double)tex->pt->h;
2150         px = (p[i].x >> FP);
2151         if      (px < x) x = px;
2152         else if (px > w) w = px;
2153         py = (p[i].y >> FP);
2154         if      (py < y) y = py;
2155         else if (py > h) h = py;
2156         if (utexture)
2157           {
2158              t2x[i] = ((((double)p[i].u / 2) / FP1)) / (double)tex->ptu->w;
2159              t2y[i] = ((((double)p[i].v / 2) / FP1)) / (double)tex->ptu->h;
2160           }
2161         else if (uvtexture)
2162           {
2163              t2x[i] = ((((double)p[i].u / 2) / FP1)) / (double)tex->ptuv->w;
2164              t2y[i] = ((((double)p[i].v / 2) / FP1)) / (double)tex->ptuv->h;
2165           }
2166      }
2167    w = w - x;
2168    h = h - y;
2169
2170    if (clip)
2171      {
2172         int nx = x, ny = y, nw = w, nh = h;
2173
2174         RECTS_CLIP_TO_RECT(nx, ny, nw, nh, cx, cy, cw, ch);
2175         if ((nx == x) && (ny == y) && (nw == w) && (nh == h))
2176           {
2177              clip = 0; cx = 0; cy = 0; cw = 0; ch = 0;
2178           }
2179         x = nx; y = nw; w = nw; h = nh;
2180      }
2181
2182    if (!flat)
2183      {
2184         shader_array_flush(gc);
2185         gc->foc = p[0].foc >> FP;
2186         gc->z0 = p[0].z0 >> FP;
2187         gc->px = p[0].px >> FP;
2188         gc->py = p[0].py >> FP;
2189         gc->change.size = 1;
2190         _evas_gl_common_viewport_set(gc);
2191      }
2192
2193    pn = _evas_gl_common_context_push(RTYPE_MAP,
2194                                      gc, tex, NULL,
2195                                      prog,
2196                                      x, y, w, h,
2197                                      blend,
2198                                      smooth,
2199                                      clip, cx, cy, cw, ch);
2200    gc->pipe[pn].region.type = RTYPE_MAP;
2201    gc->pipe[pn].shader.cur_tex = tex->pt->texture;
2202    if (utexture)
2203      {
2204        gc->pipe[pn].shader.cur_texu = tex->ptu->texture;
2205        gc->pipe[pn].shader.cur_texu_dyn = tex->ptu->dyn.img;
2206        gc->pipe[pn].shader.cur_texv = tex->ptv->texture;
2207        gc->pipe[pn].shader.cur_texv_dyn = tex->ptv->dyn.img;
2208      }
2209    else if (uvtexture)
2210      {
2211        gc->pipe[pn].shader.cur_texu = tex->ptuv->texture;
2212        gc->pipe[pn].shader.cur_texu_dyn = tex->ptuv->dyn.img;
2213      }
2214    gc->pipe[pn].shader.cur_prog = prog;
2215    gc->pipe[pn].shader.smooth = smooth;
2216    gc->pipe[pn].shader.blend = blend;
2217    gc->pipe[pn].shader.render_op = gc->dc->render_op;
2218    gc->pipe[pn].shader.clip = clip;
2219    gc->pipe[pn].shader.cx = cx;
2220    gc->pipe[pn].shader.cy = cy;
2221    gc->pipe[pn].shader.cw = cw;
2222    gc->pipe[pn].shader.ch = ch;
2223    gc->pipe[pn].array.line = 0;
2224    gc->pipe[pn].array.use_vertex = 1;
2225    gc->pipe[pn].array.use_color = 1;
2226    gc->pipe[pn].array.use_texuv = 1;
2227    gc->pipe[pn].array.use_texuv2 = (utexture || uvtexture) ? 1 : 0;
2228    gc->pipe[pn].array.use_texuv3 = (utexture) ? 1 : 0;
2229
2230    pipe_region_expand(gc, pn, x, y, w, h);
2231
2232    pnum = gc->pipe[pn].array.num;
2233    nv = pnum * 3; nc = pnum * 4; nu = pnum * 2; nu2 = pnum * 2;
2234    nu2 = pnum * 2; nu3 = pnum * 2; nt = pnum * 4;
2235    gc->pipe[pn].array.num += 6;
2236    array_alloc(gc, pn);
2237
2238    if ((tex->im) && (tex->im->native.data) && (!tex->im->native.yinvert))
2239      {
2240         for (i = 0; i < 4; i++)
2241           {
2242              ty[i] = 1.0 - ty[i];
2243              if (utexture || uvtexture)
2244                 t2y[i] = 1.0 - t2y[i];
2245           }
2246      }
2247
2248    cmul = ARGB_JOIN(a, r, g, b);
2249    for (i = 0; i < 6; i++)
2250      {
2251         DATA32 cl = MUL4_SYM(cmul, p[points[i]].col);
2252         if (flat)
2253           {
2254              PUSH_VERTEX(pn,
2255                          (p[points[i]].x >> FP),
2256                          (p[points[i]].y >> FP),
2257                          0);
2258           }
2259         else
2260           {
2261              PUSH_VERTEX(pn,
2262                          (p[points[i]].fx) + gc->shared->ax,
2263                          (p[points[i]].fy) + gc->shared->ay,
2264                          (p[points[i]].fz)
2265                          + (gc->shared->foc - gc->shared->z0));
2266           }
2267         PUSH_TEXUV(pn,
2268                    tx[points[i]],
2269                    ty[points[i]]);
2270         if (utexture)
2271           {
2272              PUSH_TEXUV2(pn,
2273                          t2x[points[i]],
2274                          t2y[points[i]]);
2275              PUSH_TEXUV3(pn,
2276                          t2x[points[i]],
2277                          t2y[points[i]]);
2278           }
2279         else if (uvtexture)
2280           {
2281              PUSH_TEXUV2(pn,
2282                          t2x[points[i]],
2283                          t2y[points[i]]);
2284           }
2285
2286         PUSH_COLOR(pn,
2287                    R_VAL(&cl),
2288                    G_VAL(&cl),
2289                    B_VAL(&cl),
2290                    A_VAL(&cl));
2291      }
2292    if (!flat)
2293      {
2294         shader_array_flush(gc);
2295         gc->foc = 0;
2296         gc->z0 = 0;
2297         gc->px = 0;
2298         gc->py = 0;
2299         gc->change.size = 1;
2300         _evas_gl_common_viewport_set(gc);
2301      }
2302 }
2303
2304 void
2305 evas_gl_common_context_flush(Evas_Engine_GL_Context *gc)
2306 {
2307    shader_array_flush(gc);
2308 }
2309
2310 static void
2311 scissor_rot(Evas_Engine_GL_Context *gc __UNUSED__,
2312             int rot, int gw, int gh, int cx, int cy, int cw, int ch)
2313 {
2314    switch (rot)
2315      {
2316       case 0: // UP this way: ^
2317         glScissor(cx, cy, cw, ch);
2318         break;
2319       case 90: // UP this way: <
2320         glScissor(gh - (cy + ch), cx, ch, cw);
2321         break;
2322       case 180: // UP this way: v
2323         glScissor(gw - (cx + cw), gh - (cy + ch), cw, ch);
2324         break;
2325       case 270: // UP this way: >
2326         glScissor(cy, gw - (cx + cw), ch, cw);
2327         break;
2328       default: // assume up is up
2329         glScissor(cx, cy, cw, ch);
2330         break;
2331      }
2332 }
2333
2334 static void
2335 shader_array_flush(Evas_Engine_GL_Context *gc)
2336 {
2337    int i, gw, gh, setclip, cy, fbo = 0, done = 0;
2338
2339    if (!gc->havestuff) return;
2340    gw = gc->w;
2341    gh = gc->h;
2342    if (!((gc->pipe[0].shader.surface == gc->def_surface) ||
2343          (!gc->pipe[0].shader.surface)))
2344      {
2345         gw = gc->pipe[0].shader.surface->w;
2346         gh = gc->pipe[0].shader.surface->h;
2347         fbo = 1;
2348      }
2349    for (i = 0; i < gc->shared->info.tune.pipes.max; i++)
2350      {
2351         if (gc->pipe[i].array.num <= 0) break;
2352         setclip = 0;
2353         done++;
2354         gc->flushnum++;
2355         GLERR(__FUNCTION__, __FILE__, __LINE__, "<flush err>");
2356         if (gc->pipe[i].shader.cur_prog != gc->state.current.cur_prog)
2357           {
2358              glUseProgram(gc->pipe[i].shader.cur_prog);
2359              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2360           }
2361
2362         if (gc->pipe[i].shader.cur_tex != gc->state.current.cur_tex)
2363           {
2364 #if 0
2365              if (gc->pipe[i].shader.cur_tex)
2366                {
2367                   glEnable(GL_TEXTURE_2D);
2368                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2369                }
2370              else
2371                {
2372                   glDisable(GL_TEXTURE_2D);
2373                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2374                }
2375 #endif
2376              glActiveTexture(GL_TEXTURE0);
2377              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2378              glBindTexture(GL_TEXTURE_2D, gc->pipe[i].shader.cur_tex);
2379              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2380           }
2381         if (gc->pipe[i].array.im)
2382           {
2383 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
2384              if (gc->pipe[i].array.im->tex->pt->dyn.img)
2385                {
2386                   secsym_glEGLImageTargetTexture2DOES
2387                      (GL_TEXTURE_2D, gc->pipe[i].array.im->tex->pt->dyn.img);
2388                }
2389              else
2390 #endif
2391                {
2392                   if (!gc->pipe[i].array.im->native.loose)
2393                     {
2394                        if (gc->pipe[i].array.im->native.func.bind)
2395                           gc->pipe[i].array.im->native.func.bind(gc->pipe[i].array.im->native.func.data,
2396                                                                  gc->pipe[i].array.im);
2397                     }
2398                }
2399           }
2400         if (gc->pipe[i].shader.render_op != gc->state.current.render_op)
2401           {
2402              switch (gc->pipe[i].shader.render_op)
2403                {
2404                case EVAS_RENDER_BLEND: /**< default op: d = d*(1-sa) + s */
2405                   glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2406                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2407                   break;
2408                case EVAS_RENDER_COPY: /**< d = s */
2409                   gc->pipe[i].shader.blend = 0;
2410                   glBlendFunc(GL_ONE, GL_ONE);
2411                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2412                   break;
2413                   // FIXME: fix blend funcs below!
2414                case EVAS_RENDER_BLEND_REL: /**< d = d*(1 - sa) + s*da */
2415                case EVAS_RENDER_COPY_REL: /**< d = s*da */
2416                case EVAS_RENDER_ADD: /**< d = d + s */
2417                case EVAS_RENDER_ADD_REL: /**< d = d + s*da */
2418                case EVAS_RENDER_SUB: /**< d = d - s */
2419                case EVAS_RENDER_SUB_REL: /**< d = d - s*da */
2420                case EVAS_RENDER_TINT: /**< d = d*s + d*(1 - sa) + s*(1 - da) */
2421                case EVAS_RENDER_TINT_REL: /**< d = d*(1 - sa + s) */
2422                case EVAS_RENDER_MASK: /**< d = d*sa */
2423                case EVAS_RENDER_MUL: /**< d = d*s */
2424                default:
2425                   glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2426                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2427                   break;
2428                }
2429           }
2430         if (gc->pipe[i].shader.blend != gc->state.current.blend)
2431           {
2432              if (gc->pipe[i].shader.blend)
2433                {
2434                   glEnable(GL_BLEND);
2435                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2436                }
2437              else
2438                {
2439                   glDisable(GL_BLEND);
2440                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2441                }
2442           }
2443         if ((gc->pipe[i].shader.smooth != gc->state.current.smooth) ||
2444             (gc->pipe[i].shader.cur_tex != gc->state.current.cur_tex))
2445           {
2446              if (gc->pipe[i].shader.smooth)
2447                {
2448 #ifdef GL_TEXTURE_MAX_ANISOTROPY_EXT
2449                   if (shared->info.anisotropic > 0.0)
2450                     {
2451                        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, shared->info.anisotropic);
2452                        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2453                     }
2454 #endif
2455                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2456                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2457                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2458                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2459                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2460                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2461                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2462                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2463                }
2464              else
2465                {
2466 #ifdef GL_TEXTURE_MAX_ANISOTROPY_EXT
2467                   if (shared->info.anisotropic > 0.0)
2468                     {
2469                        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0);
2470                        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2471                     }
2472 #endif
2473                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2474                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2475                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2476                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2477                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2478                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2479                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2480                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2481                }
2482           }
2483         if (gc->pipe[i].shader.clip != gc->state.current.clip)
2484           {
2485
2486              if (gc->pipe[i].shader.clip)
2487                {
2488                   cy = gh - gc->pipe[i].shader.cy - gc->pipe[i].shader.ch;
2489                   if (fbo) cy = gc->pipe[i].shader.cy;
2490                   glEnable(GL_SCISSOR_TEST);
2491                   if (!fbo)
2492                      scissor_rot(gc, gc->rot, gw, gh,
2493                                  gc->pipe[i].shader.cx,
2494                                  cy,
2495                                  gc->pipe[i].shader.cw,
2496                                  gc->pipe[i].shader.ch);
2497                   else
2498                      glScissor(gc->pipe[i].shader.cx, cy,
2499                                gc->pipe[i].shader.cw, gc->pipe[i].shader.ch);
2500                   setclip = 1;
2501                }
2502              else
2503                {
2504                   glDisable(GL_SCISSOR_TEST);
2505                   glScissor(0, 0, 0, 0);
2506                }
2507           }
2508         if ((gc->pipe[i].shader.clip) && (!setclip))
2509           {
2510              if ((gc->pipe[i].shader.cx != gc->state.current.cx) ||
2511                  (gc->pipe[i].shader.cy != gc->state.current.cy) ||
2512                  (gc->pipe[i].shader.cw != gc->state.current.cw) ||
2513                  (gc->pipe[i].shader.ch != gc->state.current.ch))
2514                {
2515                   cy = gh - gc->pipe[i].shader.cy - gc->pipe[i].shader.ch;
2516                   if (fbo) cy = gc->pipe[i].shader.cy;
2517                   if (!fbo)
2518                      scissor_rot(gc, gc->rot, gw, gh,
2519                                  gc->pipe[i].shader.cx,
2520                                  cy,
2521                                  gc->pipe[i].shader.cw,
2522                                  gc->pipe[i].shader.ch);
2523                   else
2524                      glScissor(gc->pipe[i].shader.cx, cy,
2525                                gc->pipe[i].shader.cw, gc->pipe[i].shader.ch);
2526                }
2527           }
2528
2529         glVertexAttribPointer(SHAD_VERTEX, 3, GL_SHORT, GL_FALSE, 0, gc->pipe[i].array.vertex);
2530         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2531         glVertexAttribPointer(SHAD_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, gc->pipe[i].array.color);
2532         GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2533         if (gc->pipe[i].array.use_texuv)
2534           {
2535              glEnableVertexAttribArray(SHAD_TEXUV);
2536              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2537              glVertexAttribPointer(SHAD_TEXUV, 2, GL_FLOAT, GL_FALSE, 0, gc->pipe[i].array.texuv);
2538              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2539           }
2540         else
2541           {
2542              glDisableVertexAttribArray(SHAD_TEXUV);
2543              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2544           }
2545
2546         if (gc->pipe[i].array.line)
2547           {
2548              glDisableVertexAttribArray(SHAD_TEXUV);
2549              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2550              glDisableVertexAttribArray(SHAD_TEXUV2);
2551              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2552              glDisableVertexAttribArray(SHAD_TEXUV3);
2553              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2554              glDrawArrays(GL_LINES, 0, gc->pipe[i].array.num);
2555              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2556           }
2557         else
2558           {
2559              if (gc->pipe[i].array.use_texm)
2560                {
2561                   glEnableVertexAttribArray(SHAD_TEXM);
2562                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2563                   glVertexAttribPointer(SHAD_TEXM, 2, GL_FLOAT, GL_FALSE, 0, gc->pipe[i].array.texm);
2564                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2565                   glActiveTexture(GL_TEXTURE1);
2566                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2567                   glBindTexture(GL_TEXTURE_2D, gc->pipe[i].shader.cur_texm);
2568                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2569                   glActiveTexture(GL_TEXTURE0);
2570                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2571                }
2572              else
2573                {
2574                   glDisableVertexAttribArray(SHAD_TEXM);
2575                }
2576              if ((gc->pipe[i].array.use_texuv2) && (gc->pipe[i].array.use_texuv3))
2577                {
2578                   glEnableVertexAttribArray(SHAD_TEXUV2);
2579                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2580                   glEnableVertexAttribArray(SHAD_TEXUV3);
2581                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2582                   glVertexAttribPointer(SHAD_TEXUV2, 2, GL_FLOAT, GL_FALSE, 0, gc->pipe[i].array.texuv2);
2583                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2584                   glVertexAttribPointer(SHAD_TEXUV3, 2, GL_FLOAT, GL_FALSE, 0, gc->pipe[i].array.texuv3);
2585                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2586
2587                   glActiveTexture(GL_TEXTURE1);
2588                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2589                   glBindTexture(GL_TEXTURE_2D, gc->pipe[i].shader.cur_texu);
2590                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2591 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
2592                   if (gc->pipe[i].shader.cur_texu_dyn)
2593                     secsym_glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, gc->pipe[i].shader.cur_texu_dyn);
2594 #endif
2595
2596                   glActiveTexture(GL_TEXTURE2);
2597                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2598                   glBindTexture(GL_TEXTURE_2D, gc->pipe[i].shader.cur_texv);
2599                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2600 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
2601                   if (gc->pipe[i].shader.cur_texv_dyn)
2602                     secsym_glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, gc->pipe[i].shader.cur_texv_dyn);
2603 #endif
2604                   glActiveTexture(GL_TEXTURE0);
2605                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2606                }
2607              else if (gc->pipe[i].array.use_texuv2)
2608                {
2609                   glEnableVertexAttribArray(SHAD_TEXUV2);
2610                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2611                   glVertexAttribPointer(SHAD_TEXUV2, 2, GL_FLOAT, GL_FALSE, 0, gc->pipe[i].array.texuv2);
2612                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2613
2614                   glActiveTexture(GL_TEXTURE1);
2615                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2616                   glBindTexture(GL_TEXTURE_2D, gc->pipe[i].shader.cur_texu);
2617                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2618 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
2619                   if (gc->pipe[i].shader.cur_texu_dyn)
2620                     secsym_glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, gc->pipe[i].shader.cur_texu_dyn);
2621 #endif
2622                   glActiveTexture(GL_TEXTURE0);
2623                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2624                }
2625              else
2626                {
2627                   glDisableVertexAttribArray(SHAD_TEXUV2);
2628                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2629                   glDisableVertexAttribArray(SHAD_TEXUV3);
2630                   GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2631                }
2632              if (dbgflushnum)
2633                {
2634                   const char *types[6] =
2635                     {"----", "RECT", "IMAG", "FONT", "YUV-", "MAP"};
2636                   printf("  DRAW#%3i %4i -> %p[%4ix%4i] @ %4ix%4i -{ tex %4i type %s }-\n",
2637                          i,
2638                          gc->pipe[i].array.num / 6,
2639                          gc->pipe[0].shader.surface,
2640                          gc->pipe[0].shader.surface->w,
2641                          gc->pipe[0].shader.surface->h,
2642                          gw, gh,
2643                          gc->pipe[i].shader.cur_tex,
2644                          types[gc->pipe[i].region.type]
2645                         );
2646                }
2647              glDrawArrays(GL_TRIANGLES, 0, gc->pipe[i].array.num);
2648              GLERR(__FUNCTION__, __FILE__, __LINE__, "");
2649           }
2650         if (gc->pipe[i].array.im)
2651           {
2652              if (!gc->pipe[i].array.im->native.loose)
2653                {
2654                   if (gc->pipe[i].array.im->native.func.unbind)
2655                      gc->pipe[i].array.im->native.func.unbind(gc->pipe[i].array.im->native.func.data,
2656                                                               gc->pipe[i].array.im);
2657                }
2658              gc->pipe[i].array.im = NULL;
2659           }
2660
2661         gc->state.current.cur_prog  = gc->pipe[i].shader.cur_prog;
2662         gc->state.current.cur_tex   = gc->pipe[i].shader.cur_tex;
2663         gc->state.current.render_op = gc->pipe[i].shader.render_op;
2664         gc->state.current.cx        = gc->pipe[i].shader.cx;
2665         gc->state.current.cy        = gc->pipe[i].shader.cy;
2666         gc->state.current.cw        = gc->pipe[i].shader.cw;
2667         gc->state.current.ch        = gc->pipe[i].shader.ch;
2668         gc->state.current.smooth    = gc->pipe[i].shader.smooth;
2669         gc->state.current.blend     = gc->pipe[i].shader.blend;
2670         gc->state.current.clip      = gc->pipe[i].shader.clip;
2671
2672         if (gc->pipe[i].array.vertex) free(gc->pipe[i].array.vertex);
2673         if (gc->pipe[i].array.color) free(gc->pipe[i].array.color);
2674         if (gc->pipe[i].array.texuv) free(gc->pipe[i].array.texuv);
2675         if (gc->pipe[i].array.texm) free(gc->pipe[i].array.texm);
2676         if (gc->pipe[i].array.texuv2) free(gc->pipe[i].array.texuv2);
2677         if (gc->pipe[i].array.texuv3) free(gc->pipe[i].array.texuv3);
2678
2679         gc->pipe[i].array.vertex = NULL;
2680         gc->pipe[i].array.color = NULL;
2681         gc->pipe[i].array.texuv = NULL;
2682         gc->pipe[i].array.texm = NULL;
2683         gc->pipe[i].array.texuv2 = NULL;
2684         gc->pipe[i].array.texuv3 = NULL;
2685
2686         gc->pipe[i].array.num = 0;
2687         gc->pipe[i].array.alloc = 0;
2688
2689         gc->pipe[i].region.x = 0;
2690         gc->pipe[i].region.y = 0;
2691         gc->pipe[i].region.w = 0;
2692         gc->pipe[i].region.h = 0;
2693         gc->pipe[i].region.type = 0;
2694      }
2695    gc->state.top_pipe = 0;
2696    if (dbgflushnum)
2697      {
2698         if (done > 0) printf("DONE (pipes): %i\n", done);
2699      }
2700    gc->havestuff = EINA_FALSE;
2701 }
2702
2703 Eina_Bool
2704 evas_gl_common_module_open(void)
2705 {
2706    if (_evas_engine_GL_common_log_dom < 0)
2707      _evas_engine_GL_common_log_dom = eina_log_domain_register
2708        ("evas-gl_common", EVAS_DEFAULT_LOG_COLOR);
2709    if (_evas_engine_GL_common_log_dom < 0)
2710      {
2711         EINA_LOG_ERR("Can not create a module log domain.");
2712         return EINA_FALSE;
2713      }
2714    return EINA_TRUE;
2715 }
2716
2717 void
2718 evas_gl_common_module_close(void)
2719 {
2720    if (_evas_engine_GL_common_log_dom < 0) return;
2721    eina_log_domain_unregister(_evas_engine_GL_common_log_dom);
2722    _evas_engine_GL_common_log_dom = -1;
2723 }