aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/evas/src/modules/engines/gl_common/evas_gl_context.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/evas/src/modules/engines/gl_common/evas_gl_context.c')
-rw-r--r--libraries/evas/src/modules/engines/gl_common/evas_gl_context.c2723
1 files changed, 2723 insertions, 0 deletions
diff --git a/libraries/evas/src/modules/engines/gl_common/evas_gl_context.c b/libraries/evas/src/modules/engines/gl_common/evas_gl_context.c
new file mode 100644
index 0000000..62e72bd
--- /dev/null
+++ b/libraries/evas/src/modules/engines/gl_common/evas_gl_context.c
@@ -0,0 +1,2723 @@
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
12static int sym_done = 0;
13int _evas_engine_GL_common_log_dom = -1;
14
15typedef void (*glsym_func_void) ();
16
17void (*glsym_glGenFramebuffers) (GLsizei a, GLuint *b) = NULL;
18void (*glsym_glBindFramebuffer) (GLenum a, GLuint b) = NULL;
19void (*glsym_glFramebufferTexture2D) (GLenum a, GLenum b, GLenum c, GLuint d, GLint e) = NULL;
20void (*glsym_glDeleteFramebuffers) (GLsizei a, const GLuint *b) = NULL;
21void (*glsym_glGetProgramBinary) (GLuint a, GLsizei b, GLsizei *c, GLenum *d, void *e) = NULL;
22void (*glsym_glProgramBinary) (GLuint a, GLenum b, const void *c, GLint d) = NULL;
23void (*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 :)
27typedef void (*_eng_fn) (void);
28
29typedef _eng_fn (*secsym_func_eng_fn) ();
30typedef unsigned int (*secsym_func_uint) ();
31typedef void *(*secsym_func_void_ptr) ();
32
33static _eng_fn (*secsym_eglGetProcAddress) (const char *a) = NULL;
34
35void *(*secsym_eglCreateImage) (void *a, void *b, GLenum c, void *d, const int *e) = NULL;
36unsigned int (*secsym_eglDestroyImage) (void *a, void *b) = NULL;
37void (*secsym_glEGLImageTargetTexture2DOES) (int a, void *b) = NULL;
38void *(*secsym_eglMapImageSEC) (void *a, void *b) = NULL;
39unsigned int (*secsym_eglUnmapImageSEC) (void *a, void *b) = NULL;
40unsigned int (*secsym_eglGetImageAttribSEC) (void *a, void *b, int c, int *d) = NULL;
41#endif
42
43static int dbgflushnum = -1;
44
45static void
46sym_missing(void)
47{
48 ERR("GL symbols missing!");
49}
50
51static void
52gl_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
151static void shader_array_flush(Evas_Engine_GL_Context *gc);
152
153static Evas_Engine_GL_Context *_evas_gl_common_context = NULL;
154static Evas_GL_Shared *shared = NULL;
155
156void
157glerr(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
185static void
186matrix_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
242static 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
330static 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
470Evas_Engine_GL_Context *
471evas_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
744void
745evas_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
800void
801evas_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
808void
809evas_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
918void
919evas_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
930void
931evas_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
998static inline void
999array_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
1025static int
1026pipe_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
1065static void
1066pipe_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
1093static Eina_Bool
1094vertex_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
1106static inline Evas_GL_Shader
1107evas_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
1124static 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
1220void
1221evas_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
1276void
1277evas_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
1302again:
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
1423void
1424evas_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
1544void
1545evas_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
1672void
1673evas_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
1754void
1755evas_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
1857void
1858evas_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
1951void
1952evas_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
2047void
2048evas_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
2304void
2305evas_gl_common_context_flush(Evas_Engine_GL_Context *gc)
2306{
2307 shader_array_flush(gc);
2308}
2309
2310static void
2311scissor_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
2334static void
2335shader_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
2703Eina_Bool
2704evas_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
2717void
2718evas_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}
generated by cgit v1.1 at 2024-07-17 14:58:41 +0000