2009-10-09 05:10:27 -07:00
|
|
|
#include "evas_engine.h"
|
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
#include <dlfcn.h> /* dlopen,dlclose,etc */
|
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-01-21 00:44:11 -08:00
|
|
|
// EGL / GLES
|
2009-10-09 05:10:27 -07:00
|
|
|
# if defined(GLES_VARIETY_S3C6410)
|
|
|
|
# elif defined(GLES_VARIETY_SGX)
|
|
|
|
# endif
|
2010-01-21 00:44:11 -08:00
|
|
|
#else
|
2009-10-09 05:10:27 -07:00
|
|
|
// GLX
|
2010-01-21 00:44:11 -08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-01-28 21:32:51 -08:00
|
|
|
|
|
|
|
#ifndef EGL_NATIVE_PIXMAP_KHR
|
|
|
|
# define EGL_NATIVE_PIXMAP_KHR 0x30b0
|
|
|
|
#endif
|
|
|
|
typedef void (*_eng_fn) (void);
|
|
|
|
|
|
|
|
_eng_fn (*glsym_eglGetProcAddress) (const char *a) = NULL;
|
|
|
|
void (*glsym_eglBindTexImage) (EGLDisplay a, EGLSurface b, int c) = NULL;
|
|
|
|
void (*glsym_eglReleaseTexImage) (EGLDisplay a, EGLSurface b, int c) = NULL;
|
|
|
|
void *(*glsym_eglCreateImage) (EGLDisplay a, EGLContext b, EGLenum c, EGLClientBuffer d, const int *e) = NULL;
|
|
|
|
void (*glsym_eglDestroyImage) (EGLDisplay a, void *b) = NULL;
|
|
|
|
void (*glsym_glEGLImageTargetTexture2DOES) (int a, void *b) = NULL;
|
2010-01-21 00:44:11 -08:00
|
|
|
#else
|
|
|
|
typedef void (*_eng_fn) (void);
|
|
|
|
|
2010-01-28 21:32:51 -08:00
|
|
|
_eng_fn (*glsym_glXGetProcAddress) (const char *a) = NULL;
|
|
|
|
void (*glsym_glXBindTexImage) (Display *a, GLXDrawable b, int c, int *d) = NULL;
|
|
|
|
void (*glsym_glXReleaseTexImage) (Display *a, GLXDrawable b, int c) = NULL;
|
2010-01-30 18:50:01 -08:00
|
|
|
int (*glsym_glXGetVideoSync) (unsigned int *a) = NULL;
|
2010-01-29 09:14:50 -08:00
|
|
|
int (*glsym_glXWaitVideoSync) (int a, int b, unsigned int *c) = NULL;
|
2010-02-14 07:12:39 -08:00
|
|
|
XID (*glsym_glXCreatePixmap) (Display *a, void *b, Pixmap c, const int *d) = NULL;
|
|
|
|
void (*glsym_glXDestroyPixmap) (Display *a, XID b) = NULL;
|
|
|
|
void (*glsym_glXQueryDrawable) (Display *a, XID b, int c, unsigned int *d) = NULL;
|
2010-01-21 00:44:11 -08:00
|
|
|
#endif
|
2010-03-01 07:51:22 -08:00
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
static void
|
|
|
|
_sym_init(void)
|
|
|
|
{
|
|
|
|
static int done = 0;
|
|
|
|
|
|
|
|
if (done) return;
|
|
|
|
|
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-01-28 21:32:51 -08:00
|
|
|
#define FINDSYM(dst, sym) \
|
|
|
|
if ((!dst) && (glsym_eglGetProcAddress)) dst = glsym_eglGetProcAddress(sym); \
|
|
|
|
if (!dst) dst = dlsym(RTLD_DEFAULT, sym)
|
|
|
|
|
2010-01-29 00:20:58 -08:00
|
|
|
FINDSYM(glsym_eglGetProcAddress, "eglGetProcAddress");
|
|
|
|
FINDSYM(glsym_eglGetProcAddress, "eglGetProcAddressEXT");
|
|
|
|
FINDSYM(glsym_eglGetProcAddress, "eglGetProcAddressARB");
|
2010-01-29 09:14:50 -08:00
|
|
|
FINDSYM(glsym_eglGetProcAddress, "eglGetProcAddressKHR");
|
2010-01-28 21:32:51 -08:00
|
|
|
|
2010-01-21 01:42:26 -08:00
|
|
|
FINDSYM(glsym_eglBindTexImage, "eglBindTexImage");
|
|
|
|
FINDSYM(glsym_eglBindTexImage, "eglBindTexImageEXT");
|
|
|
|
FINDSYM(glsym_eglBindTexImage, "eglBindTexImageARB");
|
2010-01-28 21:32:51 -08:00
|
|
|
FINDSYM(glsym_eglBindTexImage, "eglBindTexImageKHR");
|
2010-01-21 01:42:26 -08:00
|
|
|
|
|
|
|
FINDSYM(glsym_eglReleaseTexImage, "eglReleaseTexImage");
|
|
|
|
FINDSYM(glsym_eglReleaseTexImage, "eglReleaseTexImageEXT");
|
|
|
|
FINDSYM(glsym_eglReleaseTexImage, "eglReleaseTexImageARB");
|
2010-01-28 21:32:51 -08:00
|
|
|
FINDSYM(glsym_eglReleaseTexImage, "eglReleaseTexImageKHR");
|
|
|
|
|
|
|
|
FINDSYM(glsym_eglCreateImage, "eglCreateImage");
|
|
|
|
FINDSYM(glsym_eglCreateImage, "eglCreateImageEXT");
|
|
|
|
FINDSYM(glsym_eglCreateImage, "eglCreateImageARB");
|
|
|
|
FINDSYM(glsym_eglCreateImage, "eglCreateImageKHR");
|
|
|
|
|
|
|
|
FINDSYM(glsym_eglDestroyImage, "eglDestroyImage");
|
|
|
|
FINDSYM(glsym_eglDestroyImage, "eglDestroyImageEXT");
|
|
|
|
FINDSYM(glsym_eglDestroyImage, "eglDestroyImageARB");
|
|
|
|
FINDSYM(glsym_eglDestroyImage, "eglDestroyImageKHR");
|
|
|
|
|
|
|
|
FINDSYM(glsym_glEGLImageTargetTexture2DOES, "glEGLImageTargetTexture2DOES");
|
2008-04-11 17:32:30 -07:00
|
|
|
#else
|
2010-01-21 01:42:26 -08:00
|
|
|
#define FINDSYM(dst, sym) \
|
|
|
|
if ((!dst) && (glsym_glXGetProcAddress)) dst = glsym_glXGetProcAddress(sym); \
|
|
|
|
if (!dst) dst = dlsym(RTLD_DEFAULT, sym)
|
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
FINDSYM(glsym_glXGetProcAddress, "glXGetProcAddress");
|
|
|
|
FINDSYM(glsym_glXGetProcAddress, "glXGetProcAddressEXT");
|
|
|
|
FINDSYM(glsym_glXGetProcAddress, "glXGetProcAddressARB");
|
|
|
|
|
|
|
|
FINDSYM(glsym_glXBindTexImage, "glXBindTexImage");
|
|
|
|
FINDSYM(glsym_glXBindTexImage, "glXBindTexImageEXT");
|
|
|
|
FINDSYM(glsym_glXBindTexImage, "glXBindTexImageARB");
|
|
|
|
|
|
|
|
FINDSYM(glsym_glXReleaseTexImage, "glXReleaseTexImage");
|
|
|
|
FINDSYM(glsym_glXReleaseTexImage, "glXReleaseTexImageEXT");
|
|
|
|
FINDSYM(glsym_glXReleaseTexImage, "glXReleaseTexImageARB");
|
2010-01-29 09:14:50 -08:00
|
|
|
|
|
|
|
FINDSYM(glsym_glXGetVideoSync, "glXGetVideoSyncSGI");
|
|
|
|
|
|
|
|
FINDSYM(glsym_glXWaitVideoSync, "glXWaitVideoSyncSGI");
|
2010-02-14 07:12:39 -08:00
|
|
|
|
|
|
|
FINDSYM(glsym_glXCreatePixmap, "glXCreatePixmap");
|
|
|
|
FINDSYM(glsym_glXCreatePixmap, "glXCreatePixmapEXT");
|
|
|
|
FINDSYM(glsym_glXCreatePixmap, "glXCreatePixmapARB");
|
|
|
|
|
|
|
|
FINDSYM(glsym_glXDestroyPixmap, "glXDestroyPixmap");
|
|
|
|
FINDSYM(glsym_glXDestroyPixmap, "glXDestroyPixmapEXT");
|
|
|
|
FINDSYM(glsym_glXDestroyPixmap, "glXDestroyPixmapARB");
|
|
|
|
|
|
|
|
FINDSYM(glsym_glXQueryDrawable, "glXQueryDrawable");
|
|
|
|
FINDSYM(glsym_glXQueryDrawable, "glXQueryDrawableEXT");
|
|
|
|
FINDSYM(glsym_glXQueryDrawable, "glXQueryDrawableARB");
|
2008-04-11 17:32:30 -07:00
|
|
|
#endif
|
2010-01-21 00:44:11 -08:00
|
|
|
}
|
2008-04-11 17:32:30 -07:00
|
|
|
|
2009-10-22 08:22:22 -07:00
|
|
|
int _evas_engine_GL_X11_log_dom = -1;
|
2006-12-09 00:52:08 -08:00
|
|
|
/* function tables - filled in later (func and parent func) */
|
|
|
|
static Evas_Func func, pfunc;
|
2006-02-27 20:07:49 -08:00
|
|
|
|
2010-04-29 08:32:47 -07:00
|
|
|
struct xrdb_user
|
|
|
|
{
|
|
|
|
time_t last_stat;
|
|
|
|
time_t last_mtime;
|
|
|
|
XrmDatabase db;
|
|
|
|
};
|
|
|
|
static struct xrdb_user xrdb_user = {0, 0, NULL};
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
xrdb_user_query(const char *name, const char *cls, char **type, XrmValue *val)
|
|
|
|
{
|
|
|
|
time_t last = xrdb_user.last_stat, now = time(NULL);
|
|
|
|
|
|
|
|
xrdb_user.last_stat = now;
|
|
|
|
if (last != now) /* don't stat() more than once every second */
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
const char *home = getenv("HOME");
|
|
|
|
char tmp[PATH_MAX];
|
|
|
|
|
|
|
|
if (!home) goto failed;
|
|
|
|
snprintf(tmp, sizeof(tmp), "%s/.Xdefaults", home);
|
|
|
|
if (stat(tmp, &st) != 0) goto failed;
|
|
|
|
if (xrdb_user.last_mtime != st.st_mtime)
|
|
|
|
{
|
|
|
|
if (xrdb_user.db) XrmDestroyDatabase(xrdb_user.db);
|
|
|
|
xrdb_user.db = XrmGetFileDatabase(tmp);
|
|
|
|
if (!xrdb_user.db) goto failed;
|
|
|
|
xrdb_user.last_mtime = st.st_mtime;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!xrdb_user.db) return EINA_FALSE;
|
|
|
|
return XrmGetResource(xrdb_user.db, name, cls, type, val);
|
|
|
|
|
|
|
|
failed:
|
|
|
|
if (xrdb_user.db)
|
|
|
|
{
|
|
|
|
XrmDestroyDatabase(xrdb_user.db);
|
|
|
|
xrdb_user.db = NULL;
|
|
|
|
}
|
|
|
|
xrdb_user.last_mtime = 0;
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
typedef struct _Render_Engine Render_Engine;
|
|
|
|
|
|
|
|
struct _Render_Engine
|
|
|
|
{
|
2010-01-24 03:01:20 -08:00
|
|
|
Evas_GL_X11_Window *win;
|
|
|
|
Evas_Engine_Info_GL_X11 *info;
|
|
|
|
Evas *evas;
|
|
|
|
int end;
|
2010-01-07 23:10:53 -08:00
|
|
|
|
2010-04-29 08:32:47 -07:00
|
|
|
XrmDatabase xrdb; // xres - dpi
|
2010-01-07 23:10:53 -08:00
|
|
|
struct { // xres - dpi
|
|
|
|
int dpi; // xres - dpi
|
|
|
|
} xr; // xres - dpi
|
2002-11-08 00:02:15 -08:00
|
|
|
};
|
|
|
|
|
|
|
|
static void *
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_info(Evas *e)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Evas_Engine_Info_GL_X11 *info;
|
2010-01-21 00:44:11 -08:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
info = calloc(1, sizeof(Evas_Engine_Info_GL_X11));
|
|
|
|
info->magic.magic = rand();
|
2006-02-27 20:07:49 -08:00
|
|
|
info->func.best_visual_get = eng_best_visual_get;
|
|
|
|
info->func.best_colormap_get = eng_best_colormap_get;
|
|
|
|
info->func.best_depth_get = eng_best_depth_get;
|
2002-11-08 00:02:15 -08:00
|
|
|
return info;
|
|
|
|
e = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_info_free(Evas *e __UNUSED__, void *info)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Evas_Engine_Info_GL_X11 *in;
|
2009-11-13 00:28:47 -08:00
|
|
|
// dont free! why bother? its not worth it
|
|
|
|
// eina_log_domain_unregister(_evas_engine_GL_X11_log_dom);
|
2002-11-08 00:02:15 -08:00
|
|
|
in = (Evas_Engine_Info_GL_X11 *)info;
|
|
|
|
free(in);
|
|
|
|
}
|
|
|
|
|
2009-03-24 02:05:32 -07:00
|
|
|
static int
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_setup(Evas *e, void *in)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
|
|
|
Evas_Engine_Info_GL_X11 *info;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
info = (Evas_Engine_Info_GL_X11 *)in;
|
|
|
|
if (!e->engine.data.output)
|
2006-12-09 00:52:08 -08:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
|
|
|
#else
|
2010-01-21 21:55:46 -08:00
|
|
|
int eb, evb;
|
|
|
|
|
2009-03-24 02:05:32 -07:00
|
|
|
if (!glXQueryExtension(info->info.display, &eb, &evb)) return 0;
|
2009-10-09 05:10:27 -07:00
|
|
|
#endif
|
2006-12-09 00:52:08 -08:00
|
|
|
re = calloc(1, sizeof(Render_Engine));
|
2009-03-24 02:05:32 -07:00
|
|
|
if (!re) return 0;
|
2010-01-24 03:01:20 -08:00
|
|
|
re->info = info;
|
|
|
|
re->evas = e;
|
2006-12-09 00:52:08 -08:00
|
|
|
e->engine.data.output = re;
|
|
|
|
re->win = eng_window_new(info->info.display,
|
|
|
|
info->info.drawable,
|
2010-05-08 22:15:20 -07:00
|
|
|
info->info.screen,
|
2006-12-09 00:52:08 -08:00
|
|
|
info->info.visual,
|
|
|
|
info->info.colormap,
|
|
|
|
info->info.depth,
|
|
|
|
e->output.w,
|
2010-02-14 07:12:39 -08:00
|
|
|
e->output.h,
|
2010-02-28 20:44:23 -08:00
|
|
|
info->indirect,
|
2010-05-08 22:15:20 -07:00
|
|
|
info->info.destination_alpha,
|
|
|
|
info->info.rotation);
|
2006-12-09 00:52:08 -08:00
|
|
|
if (!re->win)
|
|
|
|
{
|
|
|
|
free(re);
|
|
|
|
e->engine.data.output = NULL;
|
2009-03-24 02:05:32 -07:00
|
|
|
return 0;
|
2006-12-09 00:52:08 -08:00
|
|
|
}
|
2010-01-07 23:10:53 -08:00
|
|
|
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
char *type = NULL;
|
|
|
|
XrmValue val;
|
|
|
|
|
|
|
|
re->xr.dpi = 75000; // dpy * 1000
|
Load Xft.dpi from ~/.Xdefaults as well.
Do this for consistency with other applications, some people just set
.Xdefaults but do not have xrdb to load it to screen. This works with
most of the systems, like Gtk and Qt, but not in Evas, so we get
different font sizes as they calculate based on DPI.
HOWEVER, and this may be a big thing, so RASTERMAN take a look, this
might impose a performance hit on window creation... remember that
every E17 popup/tooltip will hit this process of reading the file (if
exists) and then query X server (round trip).
I'd rather make this a global resource, loaded just once for all
created windows, we can store the mtime to know when it changed and
invalidate the pointer... but as Raster did not keep the
XrmGetDatabase() result as global, I'm not doing it here either.
SVN revision: 48403
2010-04-28 13:26:04 -07:00
|
|
|
|
2010-04-29 08:32:47 -07:00
|
|
|
status = xrdb_user_query("Xft.dpi", "Xft.Dpi", &type, &val);
|
Load Xft.dpi from ~/.Xdefaults as well.
Do this for consistency with other applications, some people just set
.Xdefaults but do not have xrdb to load it to screen. This works with
most of the systems, like Gtk and Qt, but not in Evas, so we get
different font sizes as they calculate based on DPI.
HOWEVER, and this may be a big thing, so RASTERMAN take a look, this
might impose a performance hit on window creation... remember that
every E17 popup/tooltip will hit this process of reading the file (if
exists) and then query X server (round trip).
I'd rather make this a global resource, loaded just once for all
created windows, we can store the mtime to know when it changed and
invalidate the pointer... but as Raster did not keep the
XrmGetDatabase() result as global, I'm not doing it here either.
SVN revision: 48403
2010-04-28 13:26:04 -07:00
|
|
|
if ((!status) || (!type))
|
|
|
|
{
|
2010-04-29 08:32:47 -07:00
|
|
|
if (!re->xrdb) re->xrdb = XrmGetDatabase(info->info.display);
|
|
|
|
if (re->xrdb)
|
|
|
|
status = XrmGetResource(re->xrdb,
|
Load Xft.dpi from ~/.Xdefaults as well.
Do this for consistency with other applications, some people just set
.Xdefaults but do not have xrdb to load it to screen. This works with
most of the systems, like Gtk and Qt, but not in Evas, so we get
different font sizes as they calculate based on DPI.
HOWEVER, and this may be a big thing, so RASTERMAN take a look, this
might impose a performance hit on window creation... remember that
every E17 popup/tooltip will hit this process of reading the file (if
exists) and then query X server (round trip).
I'd rather make this a global resource, loaded just once for all
created windows, we can store the mtime to know when it changed and
invalidate the pointer... but as Raster did not keep the
XrmGetDatabase() result as global, I'm not doing it here either.
SVN revision: 48403
2010-04-28 13:26:04 -07:00
|
|
|
"Xft.dpi", "Xft.Dpi", &type, &val);
|
|
|
|
}
|
|
|
|
|
2010-01-07 23:10:53 -08:00
|
|
|
if ((status) && (type))
|
|
|
|
{
|
|
|
|
if (!strcmp(type, "String"))
|
|
|
|
{
|
|
|
|
const char *str, *dp;
|
|
|
|
|
|
|
|
str = val.addr;
|
|
|
|
dp = strchr(str, '.');
|
|
|
|
if (!dp) dp = strchr(str, ',');
|
|
|
|
|
|
|
|
if (dp)
|
|
|
|
{
|
|
|
|
int subdpi, len, i;
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
buf = alloca(dp - str + 1);
|
|
|
|
strncpy(buf, str, dp - str);
|
|
|
|
buf[dp - str] = 0;
|
|
|
|
len = strlen(dp + 1);
|
|
|
|
subdpi = atoi(dp + 1);
|
|
|
|
|
|
|
|
if (len < 3)
|
|
|
|
{
|
|
|
|
for (i = len; i < 3; i++) subdpi *= 10;
|
|
|
|
}
|
|
|
|
else if (len > 3)
|
|
|
|
{
|
|
|
|
for (i = len; i > 3; i--) subdpi /= 10;
|
|
|
|
}
|
|
|
|
re->xr.dpi = atoi(buf) * 1000;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
re->xr.dpi = atoi(str) * 1000;
|
2010-01-30 18:50:01 -08:00
|
|
|
evas_common_font_dpi_set(re->xr.dpi / 1000);
|
2010-01-07 23:10:53 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-09 00:52:08 -08:00
|
|
|
evas_common_cpu_init();
|
2010-01-07 23:10:53 -08:00
|
|
|
|
2006-12-09 00:52:08 -08:00
|
|
|
evas_common_blend_init();
|
|
|
|
evas_common_image_init();
|
|
|
|
evas_common_convert_init();
|
|
|
|
evas_common_scale_init();
|
|
|
|
evas_common_rectangle_init();
|
|
|
|
evas_common_gradient_init();
|
|
|
|
evas_common_polygon_init();
|
|
|
|
evas_common_line_init();
|
|
|
|
evas_common_font_init();
|
|
|
|
evas_common_draw_init();
|
|
|
|
evas_common_tilebuf_init();
|
|
|
|
}
|
2006-03-08 00:02:34 -08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
re = e->engine.data.output;
|
2010-01-25 06:02:14 -08:00
|
|
|
if ((info->info.display != re->win->disp) ||
|
|
|
|
(info->info.drawable != re->win->win) ||
|
2010-05-08 22:15:20 -07:00
|
|
|
(info->info.screen != re->win->screen) ||
|
2010-01-25 06:02:14 -08:00
|
|
|
(info->info.visual != re->win->visual) ||
|
|
|
|
(info->info.colormap != re->win->colormap) ||
|
2010-02-28 20:44:23 -08:00
|
|
|
(info->info.depth != re->win->depth) ||
|
2010-05-08 22:15:20 -07:00
|
|
|
(info->info.destination_alpha != re->win->alpha) ||
|
|
|
|
(info->info.rotation != re->win->rot))
|
2010-01-25 06:02:14 -08:00
|
|
|
{
|
|
|
|
eng_window_free(re->win);
|
|
|
|
re->win = eng_window_new(info->info.display,
|
|
|
|
info->info.drawable,
|
2010-05-08 22:15:20 -07:00
|
|
|
info->info.screen,
|
2010-01-25 06:02:14 -08:00
|
|
|
info->info.visual,
|
|
|
|
info->info.colormap,
|
|
|
|
info->info.depth,
|
|
|
|
e->output.w,
|
2010-02-14 07:12:39 -08:00
|
|
|
e->output.h,
|
2010-02-28 20:44:23 -08:00
|
|
|
info->indirect,
|
2010-05-08 22:15:20 -07:00
|
|
|
info->info.destination_alpha,
|
|
|
|
info->info.rotation);
|
2010-01-25 06:02:14 -08:00
|
|
|
}
|
|
|
|
else if ((re->win->w != e->output.w) ||
|
|
|
|
(re->win->h != e->output.h))
|
|
|
|
{
|
|
|
|
re->win->w = e->output.w;
|
|
|
|
re->win->h = e->output.h;
|
|
|
|
eng_window_use(re->win);
|
2010-05-08 22:15:20 -07:00
|
|
|
evas_gl_common_context_resize(re->win->gl_context, re->win->w, re->win->h, re->win->rot);
|
2010-01-25 06:02:14 -08:00
|
|
|
}
|
2009-10-13 02:40:39 -07:00
|
|
|
|
2006-03-08 00:02:34 -08:00
|
|
|
}
|
2009-03-24 02:05:32 -07:00
|
|
|
if (!e->engine.data.output) return 0;
|
2002-11-08 00:02:15 -08:00
|
|
|
if (!e->engine.data.context)
|
2005-05-21 19:49:50 -07:00
|
|
|
e->engine.data.context =
|
|
|
|
e->engine.func->context_new(e->engine.data.output);
|
2009-10-13 02:40:39 -07:00
|
|
|
eng_window_use(re->win);
|
|
|
|
|
2010-02-28 20:44:23 -08:00
|
|
|
if (re->win->alpha)
|
|
|
|
{
|
|
|
|
glClearColor(0.0, 0.0, 0.0, 0.0);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
}
|
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
_sym_init();
|
|
|
|
|
2009-03-24 02:05:32 -07:00
|
|
|
return 1;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_output_free(void *data)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2010-04-29 08:32:47 -07:00
|
|
|
|
|
|
|
// NOTE: XrmGetDatabase() result is shared per connection, do not free it.
|
|
|
|
// if (re->xrdb) XrmDestroyDatabase(re->xrdb);
|
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
eng_window_free(re->win);
|
2002-11-08 00:02:15 -08:00
|
|
|
free(re);
|
2004-01-12 10:12:41 -08:00
|
|
|
|
|
|
|
evas_common_font_shutdown();
|
2004-01-17 08:27:58 -08:00
|
|
|
evas_common_image_shutdown();
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_output_resize(void *data, int w, int h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2003-09-04 00:40:34 -07:00
|
|
|
re->win->w = w;
|
|
|
|
re->win->h = h;
|
2009-10-13 02:40:39 -07:00
|
|
|
eng_window_use(re->win);
|
2010-05-08 22:15:20 -07:00
|
|
|
evas_gl_common_context_resize(re->win->gl_context, w, h, re->win->rot);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_output_tile_size_set(void *data, int w __UNUSED__, int h __UNUSED__)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
|
|
|
//
|
|
|
|
// re = (Render_Engine *)data;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_output_redraws_rect_add(void *data, int x, int y, int w, int h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2010-05-08 22:15:20 -07:00
|
|
|
evas_gl_common_context_resize(re->win->gl_context, re->win->w, re->win->h, re->win->rot);
|
2003-09-04 00:40:34 -07:00
|
|
|
/* smple bounding box */
|
2010-02-11 06:41:44 -08:00
|
|
|
RECTS_CLIP_TO_RECT(x, y, w, h, 0, 0, re->win->w, re->win->h);
|
|
|
|
if ((w <= 0) || (h <= 0)) return;
|
2003-09-04 00:40:34 -07:00
|
|
|
if (!re->win->draw.redraw)
|
|
|
|
{
|
2005-05-21 19:49:50 -07:00
|
|
|
#if 0
|
2003-09-04 00:40:34 -07:00
|
|
|
re->win->draw.x1 = x;
|
|
|
|
re->win->draw.y1 = y;
|
|
|
|
re->win->draw.x2 = x + w - 1;
|
|
|
|
re->win->draw.y2 = y + h - 1;
|
2004-06-18 08:56:30 -07:00
|
|
|
#else
|
|
|
|
re->win->draw.x1 = 0;
|
|
|
|
re->win->draw.y1 = 0;
|
|
|
|
re->win->draw.x2 = re->win->w - 1;
|
|
|
|
re->win->draw.y2 = re->win->h - 1;
|
2005-05-21 19:49:50 -07:00
|
|
|
#endif
|
2003-09-04 00:40:34 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (x < re->win->draw.x1) re->win->draw.x1 = x;
|
|
|
|
if (y < re->win->draw.y1) re->win->draw.y1 = y;
|
|
|
|
if ((x + w - 1) > re->win->draw.x2) re->win->draw.x2 = x + w - 1;
|
|
|
|
if ((y + h - 1) > re->win->draw.y2) re->win->draw.y2 = y + h - 1;
|
|
|
|
}
|
|
|
|
re->win->draw.redraw = 1;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_output_redraws_rect_del(void *data, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
|
|
|
//
|
|
|
|
// re = (Render_Engine *)data;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_output_redraws_clear(void *data)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2003-09-04 00:40:34 -07:00
|
|
|
re->win->draw.redraw = 0;
|
2009-10-22 08:22:22 -07:00
|
|
|
// INF("GL: finish update cycle!");
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2007-03-03 08:05:15 -08:00
|
|
|
/* vsync games - not for now though */
|
2010-01-29 09:14:50 -08:00
|
|
|
#define VSYNC_TO_SCREEN 1
|
2007-03-03 08:05:15 -08:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
static void *
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_output_redraws_next_update_get(void *data, int *x, int *y, int *w, int *h, int *cx, int *cy, int *cw, int *ch)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2009-10-14 20:25:22 -07:00
|
|
|
evas_gl_common_context_flush(re->win->gl_context);
|
2003-09-04 00:40:34 -07:00
|
|
|
/* get the upate rect surface - return engine data as dummy */
|
2010-02-11 06:41:44 -08:00
|
|
|
if (!re->win->draw.redraw) return NULL;
|
2003-09-04 00:40:34 -07:00
|
|
|
if (x) *x = re->win->draw.x1;
|
|
|
|
if (y) *y = re->win->draw.y1;
|
|
|
|
if (w) *w = re->win->draw.x2 - re->win->draw.x1 + 1;
|
|
|
|
if (h) *h = re->win->draw.y2 - re->win->draw.y1 + 1;
|
|
|
|
if (cx) *cx = re->win->draw.x1;
|
|
|
|
if (cy) *cy = re->win->draw.y1;
|
|
|
|
if (cw) *cw = re->win->draw.x2 - re->win->draw.x1 + 1;
|
|
|
|
if (ch) *ch = re->win->draw.y2 - re->win->draw.y1 + 1;
|
2009-11-12 23:22:31 -08:00
|
|
|
return re->win->gl_context->def_surface;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2010-03-31 02:25:21 -07:00
|
|
|
//#define FRAMECOUNT 1
|
|
|
|
|
|
|
|
#ifdef FRAMECOUNT
|
|
|
|
double
|
|
|
|
get_time(void)
|
|
|
|
{
|
|
|
|
struct timeval timev;
|
|
|
|
|
|
|
|
gettimeofday(&timev, NULL);
|
|
|
|
return (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_output_redraws_next_update_push(void *data, void *surface __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2010-03-31 02:25:21 -07:00
|
|
|
#ifdef FRAMECOUNT
|
|
|
|
static double pt = 0.0;
|
|
|
|
double ta, tb;
|
|
|
|
#endif
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2003-09-04 00:40:34 -07:00
|
|
|
/* put back update surface.. in this case just unflag redraw */
|
|
|
|
re->win->draw.redraw = 0;
|
2007-03-04 09:06:13 -08:00
|
|
|
re->win->draw.drew = 1;
|
2009-10-09 05:10:27 -07:00
|
|
|
evas_gl_common_context_flush(re->win->gl_context);
|
2010-02-01 21:30:19 -08:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-02-06 00:38:26 -08:00
|
|
|
// this is needed to make sure all previous rendering is flushed to
|
|
|
|
// buffers/surfaces
|
2010-03-31 02:25:21 -07:00
|
|
|
#ifdef FRAMECOUNT
|
|
|
|
double t0 = get_time();
|
|
|
|
ta = t0 - pt;
|
|
|
|
pt = t0;
|
|
|
|
#endif
|
2010-02-06 00:38:26 -08:00
|
|
|
eglWaitNative(EGL_CORE_NATIVE_ENGINE); // previous rendering should be done and swapped
|
2010-03-31 02:25:21 -07:00
|
|
|
#ifdef FRAMECOUNT
|
|
|
|
double t1 = get_time();
|
|
|
|
tb = t1 - t0;
|
|
|
|
printf("... %1.5f -> %1.5f | ", ta, tb);
|
|
|
|
#endif
|
2010-02-16 23:34:22 -08:00
|
|
|
// if (eglGetError() != EGL_SUCCESS)
|
|
|
|
// {
|
|
|
|
// printf("Error: eglWaitNative(EGL_CORE_NATIVE_ENGINE) fail.\n");
|
|
|
|
// }
|
2010-02-01 21:30:19 -08:00
|
|
|
#else
|
|
|
|
glXWaitGL();
|
|
|
|
#endif
|
2009-10-09 05:10:27 -07:00
|
|
|
//x// printf("frame -> push\n");
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_output_flush(void *data)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2007-03-04 09:06:13 -08:00
|
|
|
if (!re->win->draw.drew) return;
|
2009-10-09 05:10:27 -07:00
|
|
|
//x// printf("frame -> flush\n");
|
2007-03-04 09:06:13 -08:00
|
|
|
re->win->draw.drew = 0;
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2003-09-04 00:40:34 -07:00
|
|
|
|
2010-01-24 03:01:20 -08:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-03-31 02:25:21 -07:00
|
|
|
#ifdef FRAMECOUNT
|
|
|
|
double t0 = get_time();
|
|
|
|
#endif
|
2009-10-09 05:10:27 -07:00
|
|
|
eglSwapBuffers(re->win->egl_disp, re->win->egl_surface[0]);
|
2010-03-31 02:25:21 -07:00
|
|
|
#ifdef FRAMECOUNT
|
|
|
|
double t1 = get_time();
|
|
|
|
printf("%1.5f\n", t1 - t0);
|
|
|
|
#endif
|
2010-02-16 23:34:22 -08:00
|
|
|
// if (eglGetError() != EGL_SUCCESS)
|
|
|
|
// {
|
|
|
|
// printf("Error: eglSwapBuffers() fail.\n");
|
|
|
|
// }
|
2009-10-09 05:10:27 -07:00
|
|
|
#else
|
2010-01-29 09:14:50 -08:00
|
|
|
#ifdef VSYNC_TO_SCREEN
|
2010-02-11 06:41:44 -08:00
|
|
|
if ((re->info->vsync)/* || (1)*/)
|
2010-01-29 09:14:50 -08:00
|
|
|
{
|
|
|
|
if ((glsym_glXGetVideoSync) && (glsym_glXWaitVideoSync))
|
|
|
|
{
|
|
|
|
unsigned int rc;
|
|
|
|
|
|
|
|
glsym_glXGetVideoSync(&rc);
|
|
|
|
glsym_glXWaitVideoSync(1, 0, &rc);
|
|
|
|
}
|
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
# endif
|
2010-01-24 03:01:20 -08:00
|
|
|
if (re->info->callback.pre_swap)
|
|
|
|
{
|
|
|
|
re->info->callback.pre_swap(re->info->callback.data, re->evas);
|
|
|
|
}
|
2010-02-14 07:12:39 -08:00
|
|
|
if ((1)
|
|
|
|
// (re->win->draw.x1 == 0) &&
|
|
|
|
// (re->win->draw.y1 == 0) &&
|
|
|
|
// (re->win->draw.x2 == (re->win->w - 1)) &&
|
|
|
|
// (re->win->draw.y2 == (re->win->h - 1))
|
|
|
|
)
|
|
|
|
{
|
|
|
|
glXSwapBuffers(re->win->disp, re->win->win);
|
|
|
|
}
|
2010-02-11 06:41:44 -08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// FIXME: this doesnt work.. why oh why?
|
|
|
|
int sx, sy, sw, sh;
|
|
|
|
|
|
|
|
// fimxe - reset when done
|
|
|
|
// glEnable(GL_SCISSOR_TEST);
|
|
|
|
glDrawBuffer(GL_FRONT);
|
|
|
|
|
|
|
|
sx = re->win->draw.x1;
|
|
|
|
sy = re->win->draw.y1;
|
|
|
|
sw = (re->win->draw.x2 - re->win->draw.x1) + 1;
|
|
|
|
sh = (re->win->draw.y2 - re->win->draw.y1) + 1;
|
|
|
|
sy = re->win->h - sy - sh;
|
|
|
|
|
|
|
|
// glScissor(sx, sy, sw, sh);
|
|
|
|
glRasterPos2i(sx, re->win->h - sy);
|
|
|
|
glCopyPixels(sx, sy, sw, sh, GL_COLOR);
|
|
|
|
glRasterPos2i(0, 0);
|
|
|
|
|
|
|
|
// glDisable(GL_SCISSOR_TEST);
|
|
|
|
glDrawBuffer(GL_BACK);
|
|
|
|
glFlush();
|
|
|
|
}
|
2010-01-24 03:01:20 -08:00
|
|
|
if (re->info->callback.post_swap)
|
|
|
|
{
|
|
|
|
re->info->callback.post_swap(re->info->callback.data, re->evas);
|
|
|
|
}
|
2010-02-28 20:44:23 -08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if (re->win->alpha)
|
|
|
|
{
|
|
|
|
glClearColor(0.0, 0.0, 0.0, 0.0);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2007-06-16 19:56:59 -07:00
|
|
|
static void
|
|
|
|
eng_output_idle_flush(void *data)
|
|
|
|
{
|
2010-04-12 01:23:53 -07:00
|
|
|
Render_Engine *re;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eng_output_dump(void *data)
|
|
|
|
{
|
|
|
|
Render_Engine *re;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
|
|
|
evas_common_image_image_all_unload();
|
|
|
|
evas_common_font_font_all_unload();
|
|
|
|
evas_gl_common_image_all_unload(re->win->gl_context);
|
2007-06-16 19:56:59 -07:00
|
|
|
}
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
static void
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_context_cutout_add(void *data, void *context, int x, int y, int w, int h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
|
|
|
//
|
|
|
|
// re = (Render_Engine *)data;
|
|
|
|
// re->win->gl_context->dc = context;
|
2009-02-20 19:13:49 -08:00
|
|
|
evas_common_draw_context_add_cutout(context, x, y, w, h);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_context_cutout_clear(void *data, void *context)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
|
|
|
//
|
|
|
|
// re = (Render_Engine *)data;
|
|
|
|
// re->win->gl_context->dc = context;
|
2009-02-20 19:13:49 -08:00
|
|
|
evas_common_draw_context_clear_cutouts(context);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-11-12 23:22:31 -08:00
|
|
|
eng_rectangle_draw(void *data, void *context, void *surface, int x, int y, int w, int h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2009-11-12 23:22:31 -08:00
|
|
|
evas_gl_common_context_target_surface_set(re->win->gl_context, surface);
|
2006-09-30 03:18:37 -07:00
|
|
|
re->win->gl_context->dc = context;
|
|
|
|
evas_gl_common_rect_draw(re->win->gl_context, x, y, w, h);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-11-12 23:22:31 -08:00
|
|
|
eng_line_draw(void *data, void *context, void *surface, int x1, int y1, int x2, int y2)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2009-10-09 05:10:27 -07:00
|
|
|
eng_window_use(re->win);
|
2009-11-12 23:22:31 -08:00
|
|
|
evas_gl_common_context_target_surface_set(re->win->gl_context, surface);
|
2006-09-30 03:18:37 -07:00
|
|
|
re->win->gl_context->dc = context;
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_gl_common_line_draw(re->win->gl_context, x1, y1, x2, y2);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_polygon_point_add(void *data, void *context __UNUSED__, void *polygon, int x, int y)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2009-12-26 16:40:25 -08:00
|
|
|
return evas_gl_common_poly_point_add(polygon, x, y);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_polygon_points_clear(void *data, void *context __UNUSED__, void *polygon)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2009-12-26 16:40:25 -08:00
|
|
|
return evas_gl_common_poly_points_clear(polygon);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-03-16 06:23:37 -07:00
|
|
|
eng_polygon_draw(void *data, void *context, void *surface __UNUSED__, void *polygon, int x, int y)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2009-10-09 05:10:27 -07:00
|
|
|
eng_window_use(re->win);
|
2009-11-12 23:22:31 -08:00
|
|
|
evas_gl_common_context_target_surface_set(re->win->gl_context, surface);
|
2006-09-30 03:18:37 -07:00
|
|
|
re->win->gl_context->dc = context;
|
2010-03-16 06:23:37 -07:00
|
|
|
evas_gl_common_poly_draw(re->win->gl_context, polygon, x, y);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2008-08-25 22:45:04 -07:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_color_np_stop_insert(void *data __UNUSED__, void *gradient __UNUSED__, int r __UNUSED__, int g __UNUSED__, int b __UNUSED__, int a __UNUSED__, float pos __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient2_color_np_stop_insert(gradient, r, g, b, a, pos);
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_clear(void *data __UNUSED__, void *gradient __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient2_clear(gradient);
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
2008-11-04 01:19:35 -08:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_fill_transform_set(void *data __UNUSED__, void *gradient __UNUSED__, void *transform __UNUSED__)
|
2008-11-04 01:19:35 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient2_fill_transform_set(gradient, transform);
|
2008-11-04 01:19:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-12-30 03:35:40 -08:00
|
|
|
eng_gradient2_fill_spread_set(void *data __UNUSED__, void *gradient __UNUSED__, int spread __UNUSED__)
|
2008-11-04 01:19:35 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient2_fill_spread_set(gradient, spread);
|
2008-11-04 01:19:35 -08:00
|
|
|
}
|
|
|
|
|
2008-08-25 22:45:04 -07:00
|
|
|
static void *
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_linear_new(void *data __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
return evas_common_gradient2_linear_new();
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_linear_free(void *data __UNUSED__, void *linear_gradient __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient2_free(linear_gradient);
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
2008-11-04 01:19:35 -08:00
|
|
|
static void
|
2009-12-21 07:52:12 -08:00
|
|
|
eng_gradient2_linear_fill_set(void *data __UNUSED__, void *linear_gradient __UNUSED__, float x0 __UNUSED__, float y0 __UNUSED__, float x1 __UNUSED__, float y1 __UNUSED__)
|
2008-11-04 01:19:35 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient2_linear_fill_set(linear_gradient, x0, y0, x1, y1);
|
2008-11-04 01:19:35 -08:00
|
|
|
}
|
|
|
|
|
2008-08-25 22:45:04 -07:00
|
|
|
static int
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_linear_is_opaque(void *data __UNUSED__, void *context __UNUSED__, void *linear_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
|
|
|
|
RGBA_Gradient2 *gr = (RGBA_Gradient2 *)linear_gradient;
|
|
|
|
|
|
|
|
if (!dc || !gr || !gr->type.geometer) return 0;
|
|
|
|
return !(gr->type.geometer->has_alpha(gr, dc->render_op) |
|
|
|
|
gr->type.geometer->has_mask(gr, dc->render_op));
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_linear_is_visible(void *data __UNUSED__, void *context __UNUSED__, void *linear_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
|
|
|
|
|
|
|
|
if (!dc || !linear_gradient) return 0;
|
2008-08-25 22:45:04 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_linear_render_pre(void *data __UNUSED__, void *context __UNUSED__, void *linear_gradient __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
|
|
|
|
RGBA_Gradient2 *gr = (RGBA_Gradient2 *)linear_gradient;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!dc || !gr || !gr->type.geometer) return;
|
|
|
|
gr->type.geometer->geom_update(gr);
|
|
|
|
len = gr->type.geometer->get_map_len(gr);
|
|
|
|
evas_common_gradient2_map(dc, gr, len);
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_linear_render_post(void *data __UNUSED__, void *linear_gradient __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_linear_draw(void *data __UNUSED__, void *context __UNUSED__, void *surface __UNUSED__, void *linear_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
Render_Engine *re;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
|
|
|
eng_window_use(re->win);
|
|
|
|
re->win->gl_context->dc = context;
|
|
|
|
{
|
|
|
|
Evas_GL_Image *gim;
|
|
|
|
RGBA_Image *im;
|
|
|
|
RGBA_Draw_Context *dc = context;
|
|
|
|
int op = dc->render_op, cuse = dc->clip.use;
|
|
|
|
|
|
|
|
im = (RGBA_Image *)evas_cache_image_empty(evas_common_image_cache_get());
|
|
|
|
im = (RGBA_Image *)evas_cache_image_size_set(&im->cache_entry, w, h);
|
|
|
|
|
|
|
|
dc->render_op = _EVAS_RENDER_FILL;
|
|
|
|
dc->clip.use = 0;
|
|
|
|
|
|
|
|
// draw to buf, copy to tex, draw tex
|
|
|
|
evas_common_gradient2_draw(im, dc, 0, 0, w, h, linear_gradient);
|
|
|
|
|
|
|
|
gim = evas_gl_common_image_new_from_data(re->win->gl_context, w, h,
|
|
|
|
im->image.data, 1,
|
|
|
|
EVAS_COLORSPACE_ARGB8888);
|
|
|
|
dc->render_op = op;
|
|
|
|
dc->clip.use = cuse;
|
|
|
|
evas_gl_common_image_draw(re->win->gl_context, gim, 0, 0, w, h, x, y, w, h, 0);
|
|
|
|
evas_cache_image_drop(&im->cache_entry);
|
|
|
|
evas_gl_common_image_free(gim);
|
|
|
|
}
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_radial_new(void *data __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
return evas_common_gradient2_radial_new();
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_radial_free(void *data __UNUSED__, void *radial_gradient __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient2_free(radial_gradient);
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
2008-11-04 01:19:35 -08:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_radial_fill_set(void *data __UNUSED__, void *radial_gradient __UNUSED__, float cx __UNUSED__, float cy __UNUSED__, float rx __UNUSED__, float ry __UNUSED__)
|
2008-11-04 01:19:35 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient2_radial_fill_set(radial_gradient, cx, cy, rx, ry);
|
2008-11-04 01:19:35 -08:00
|
|
|
}
|
|
|
|
|
2008-08-25 22:45:04 -07:00
|
|
|
static int
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_radial_is_opaque(void *data __UNUSED__, void *context __UNUSED__, void *radial_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
|
|
|
|
RGBA_Gradient2 *gr = (RGBA_Gradient2 *)radial_gradient;
|
|
|
|
|
|
|
|
if (!dc || !gr || !gr->type.geometer) return 0;
|
|
|
|
return !(gr->type.geometer->has_alpha(gr, dc->render_op) |
|
|
|
|
gr->type.geometer->has_mask(gr, dc->render_op));
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_radial_is_visible(void *data __UNUSED__, void *context __UNUSED__, void *radial_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
|
|
|
|
|
|
|
|
if (!dc || !radial_gradient) return 0;
|
2008-08-25 22:45:04 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_radial_render_pre(void *data __UNUSED__, void *context __UNUSED__, void *radial_gradient __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
|
|
|
|
RGBA_Gradient2 *gr = (RGBA_Gradient2 *)radial_gradient;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!dc || !gr || !gr->type.geometer) return;
|
|
|
|
gr->type.geometer->geom_update(gr);
|
|
|
|
len = gr->type.geometer->get_map_len(gr);
|
|
|
|
evas_common_gradient2_map(dc, gr, len);
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_radial_render_post(void *data __UNUSED__, void *radial_gradient __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient2_radial_draw(void *data __UNUSED__, void *context __UNUSED__, void *surface __UNUSED__, void *radial_gradient __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
|
2008-08-25 22:45:04 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
Render_Engine *re;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
|
|
|
eng_window_use(re->win);
|
|
|
|
re->win->gl_context->dc = context;
|
|
|
|
{
|
|
|
|
Evas_GL_Image *gim;
|
|
|
|
RGBA_Image *im;
|
|
|
|
RGBA_Draw_Context *dc = context;
|
|
|
|
int op = dc->render_op, cuse = dc->clip.use;
|
|
|
|
|
|
|
|
im = (RGBA_Image *)evas_cache_image_empty(evas_common_image_cache_get());
|
|
|
|
im = (RGBA_Image *)evas_cache_image_size_set(&im->cache_entry, w, h);
|
|
|
|
|
|
|
|
dc->render_op = _EVAS_RENDER_FILL;
|
|
|
|
dc->clip.use = 0;
|
|
|
|
|
|
|
|
// draw to buf, copy to tex, draw tex
|
|
|
|
evas_common_gradient2_draw(im, dc, 0, 0, w, h, radial_gradient);
|
|
|
|
|
|
|
|
gim = evas_gl_common_image_new_from_data(re->win->gl_context, w, h,
|
|
|
|
im->image.data, 1,
|
|
|
|
EVAS_COLORSPACE_ARGB8888);
|
|
|
|
dc->render_op = op;
|
|
|
|
dc->clip.use = cuse;
|
|
|
|
evas_gl_common_image_draw(re->win->gl_context, gim, 0, 0, w, h, x, y, w, h, 0);
|
|
|
|
evas_cache_image_drop(&im->cache_entry);
|
|
|
|
evas_gl_common_image_free(gim);
|
|
|
|
}
|
2008-08-25 22:45:04 -07:00
|
|
|
}
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
static void *
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_new(void *data __UNUSED__)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
return evas_common_gradient_new();
|
2006-09-30 03:18:37 -07:00
|
|
|
}
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
static void
|
2009-12-30 03:35:40 -08:00
|
|
|
eng_gradient_free(void *data __UNUSED__, void *gradient)
|
2006-09-30 03:18:37 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_free(gradient);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
static void
|
2009-12-30 03:35:40 -08:00
|
|
|
eng_gradient_color_stop_add(void *data __UNUSED__, void *gradient, int r, int g, int b, int a, int delta)
|
2006-05-02 00:28:49 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_color_stop_add(gradient, r, g, b, a, delta);
|
2006-09-30 03:18:37 -07:00
|
|
|
}
|
2006-05-02 00:28:49 -07:00
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
static void
|
2009-12-30 03:35:40 -08:00
|
|
|
eng_gradient_alpha_stop_add(void *data __UNUSED__, void *gradient, int a, int delta)
|
2006-09-30 03:18:37 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_alpha_stop_add(gradient, a, delta);
|
2006-05-02 00:28:49 -07:00
|
|
|
}
|
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_color_data_set(void *data __UNUSED__, void *gradient, void *map, int len, int has_alpha)
|
2006-05-02 00:28:49 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_color_data_set(gradient, map, len, has_alpha);
|
2006-09-30 03:18:37 -07:00
|
|
|
}
|
2006-05-02 00:28:49 -07:00
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_alpha_data_set(void *data __UNUSED__, void *gradient, void *alpha_map, int len)
|
2006-09-30 03:18:37 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_alpha_data_set(gradient, alpha_map, len);
|
2006-05-02 00:28:49 -07:00
|
|
|
}
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
static void
|
2009-12-30 03:35:40 -08:00
|
|
|
eng_gradient_clear(void *data __UNUSED__, void *gradient)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_clear(gradient);
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_fill_set(void *data __UNUSED__, void *gradient, int x, int y, int w, int h)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_fill_set(gradient, x, y, w, h);
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
2006-05-04 04:52:46 -07:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_fill_angle_set(void *data __UNUSED__, void *gradient, double angle)
|
2006-05-04 04:52:46 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_fill_angle_set(gradient, angle);
|
2006-09-30 03:18:37 -07:00
|
|
|
}
|
2006-05-04 04:52:46 -07:00
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_fill_spread_set(void *data __UNUSED__, void *gradient, int spread)
|
2006-09-30 03:18:37 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_fill_spread_set(gradient, spread);
|
2006-05-04 04:52:46 -07:00
|
|
|
}
|
|
|
|
|
2005-12-03 01:27:53 -08:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_angle_set(void *data __UNUSED__, void *gradient, double angle)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_map_angle_set(gradient, angle);
|
2006-09-30 03:18:37 -07:00
|
|
|
}
|
2005-12-03 01:27:53 -08:00
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_offset_set(void *data __UNUSED__, void *gradient, float offset)
|
2006-09-30 03:18:37 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_map_offset_set(gradient, offset);
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_direction_set(void *data __UNUSED__, void *gradient, int direction)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_map_direction_set(gradient, direction);
|
2006-09-30 03:18:37 -07:00
|
|
|
}
|
2005-12-03 01:27:53 -08:00
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_type_set(void *data __UNUSED__, void *gradient, char *name, char *params)
|
2006-09-30 03:18:37 -07:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
evas_common_gradient_type_set(gradient, name, params);
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
2006-09-30 03:18:37 -07:00
|
|
|
static int
|
|
|
|
eng_gradient_is_opaque(void *data, void *context, void *gradient, int x, int y, int w, int h)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
|
|
|
|
RGBA_Gradient *gr = (RGBA_Gradient *)gradient;
|
|
|
|
|
|
|
|
if (!dc || !gr || !gr->type.geometer) return 0;
|
|
|
|
return !(gr->type.geometer->has_alpha(gr, dc->render_op) |
|
|
|
|
gr->type.geometer->has_mask(gr, dc->render_op));
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-09-30 03:18:37 -07:00
|
|
|
eng_gradient_is_visible(void *data, void *context, void *gradient, int x, int y, int w, int h)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
|
|
|
|
|
|
|
|
if (!dc || !gradient) return 0;
|
|
|
|
return 1;
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-09-30 03:18:37 -07:00
|
|
|
eng_gradient_render_pre(void *data, void *context, void *gradient)
|
2005-12-03 01:27:53 -08:00
|
|
|
{
|
2009-12-30 03:35:40 -08:00
|
|
|
RGBA_Draw_Context *dc = (RGBA_Draw_Context *)context;
|
|
|
|
RGBA_Gradient *gr = (RGBA_Gradient *)gradient;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!dc || !gr || !gr->type.geometer) return;
|
|
|
|
gr->type.geometer->geom_set(gr);
|
|
|
|
len = gr->type.geometer->get_map_len(gr);
|
|
|
|
evas_common_gradient_map(dc, gr, len);
|
2006-09-30 03:18:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_render_post(void *data __UNUSED__, void *gradient)
|
2006-09-30 03:18:37 -07:00
|
|
|
{
|
2005-12-03 01:27:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_gradient_draw(void *data, void *context, void *surface __UNUSED__, void *gradient, int x, int y, int w, int h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2006-09-30 03:18:37 -07:00
|
|
|
re->win->gl_context->dc = context;
|
2009-12-30 03:35:40 -08:00
|
|
|
{
|
|
|
|
Evas_GL_Image *gim;
|
|
|
|
RGBA_Image *im;
|
|
|
|
RGBA_Draw_Context *dc = context;
|
|
|
|
int op = dc->render_op, cuse = dc->clip.use;
|
|
|
|
|
|
|
|
im = (RGBA_Image *)evas_cache_image_empty(evas_common_image_cache_get());
|
|
|
|
im = (RGBA_Image *)evas_cache_image_size_set(&im->cache_entry, w, h);
|
|
|
|
|
|
|
|
dc->render_op = _EVAS_RENDER_FILL;
|
|
|
|
dc->clip.use = 0;
|
|
|
|
|
|
|
|
// draw to buf, copy to tex, draw tex
|
|
|
|
evas_common_gradient_draw(im, dc, 0, 0, w, h, gradient);
|
|
|
|
|
|
|
|
gim = evas_gl_common_image_new_from_data(re->win->gl_context, w, h,
|
|
|
|
im->image.data, 1,
|
|
|
|
EVAS_COLORSPACE_ARGB8888);
|
|
|
|
dc->render_op = op;
|
|
|
|
dc->clip.use = cuse;
|
|
|
|
evas_gl_common_image_draw(re->win->gl_context, gim, 0, 0, w, h, x, y, w, h, 0);
|
|
|
|
evas_cache_image_drop(&im->cache_entry);
|
|
|
|
evas_gl_common_image_free(gim);
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2006-12-17 07:48:52 -08:00
|
|
|
static int
|
|
|
|
eng_image_alpha_get(void *data, void *image)
|
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
2006-12-17 07:48:52 -08:00
|
|
|
Evas_GL_Image *im;
|
|
|
|
|
2009-10-12 08:22:38 -07:00
|
|
|
// re = (Render_Engine *)data;
|
2006-12-17 08:46:30 -08:00
|
|
|
if (!image) return 1;
|
2006-12-17 07:48:52 -08:00
|
|
|
im = image;
|
2010-01-21 04:43:53 -08:00
|
|
|
return im->alpha;
|
2006-12-17 07:48:52 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
eng_image_colorspace_get(void *data, void *image)
|
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
2006-12-17 07:48:52 -08:00
|
|
|
Evas_GL_Image *im;
|
2009-02-21 00:19:58 -08:00
|
|
|
|
2009-10-12 08:22:38 -07:00
|
|
|
// re = (Render_Engine *)data;
|
2006-12-17 08:46:30 -08:00
|
|
|
if (!image) return EVAS_COLORSPACE_ARGB8888;
|
2006-12-17 07:48:52 -08:00
|
|
|
im = image;
|
|
|
|
return im->cs.space;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
|
|
|
eng_image_alpha_set(void *data, void *image, int has_alpha)
|
|
|
|
{
|
|
|
|
Render_Engine *re;
|
|
|
|
Evas_GL_Image *im;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
2006-12-19 06:12:40 -08:00
|
|
|
if (!image) return NULL;
|
2006-12-17 07:48:52 -08:00
|
|
|
im = image;
|
2010-01-21 01:42:26 -08:00
|
|
|
if (im->native.data)
|
|
|
|
{
|
|
|
|
im->alpha = has_alpha;
|
|
|
|
return image;
|
|
|
|
}
|
2010-01-21 04:43:53 -08:00
|
|
|
eng_window_use(re->win);
|
2006-12-17 07:48:52 -08:00
|
|
|
/* FIXME: can move to gl_common */
|
|
|
|
if (im->cs.space != EVAS_COLORSPACE_ARGB8888) return im;
|
2008-06-03 02:09:39 -07:00
|
|
|
if ((has_alpha) && (im->im->cache_entry.flags.alpha)) return image;
|
|
|
|
else if ((!has_alpha) && (!im->im->cache_entry.flags.alpha)) return image;
|
2006-12-17 07:48:52 -08:00
|
|
|
if (im->references > 1)
|
2009-10-09 05:10:27 -07:00
|
|
|
{
|
|
|
|
Evas_GL_Image *im_new;
|
|
|
|
|
|
|
|
im_new = evas_gl_common_image_new_from_copied_data(im->gc, im->im->cache_entry.w, im->im->cache_entry.h, im->im->image.data,
|
|
|
|
eng_image_alpha_get(data, image),
|
|
|
|
eng_image_colorspace_get(data, image));
|
|
|
|
if (!im_new) return im;
|
|
|
|
evas_gl_common_image_free(im);
|
|
|
|
im = im_new;
|
2006-12-17 07:48:52 -08:00
|
|
|
}
|
|
|
|
else
|
2009-12-19 22:23:13 -08:00
|
|
|
evas_gl_common_image_dirty(im, 0, 0, 0, 0);
|
2010-02-21 07:49:44 -08:00
|
|
|
return evas_gl_common_image_alpha_set(im, has_alpha ? 1 : 0);
|
|
|
|
// im->im->cache_entry.flags.alpha = has_alpha ? 1 : 0;
|
|
|
|
// return image;
|
2006-12-17 07:48:52 -08:00
|
|
|
}
|
|
|
|
|
2008-11-04 01:19:35 -08:00
|
|
|
static void *
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_image_border_set(void *data, void *image, int l __UNUSED__, int r __UNUSED__, int t __UNUSED__, int b __UNUSED__)
|
2008-11-04 01:19:35 -08:00
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
|
|
|
//
|
|
|
|
// re = (Render_Engine *)data;
|
2008-11-04 01:19:35 -08:00
|
|
|
return image;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_image_border_get(void *data, void *image __UNUSED__, int *l __UNUSED__, int *r __UNUSED__, int *t __UNUSED__, int *b __UNUSED__)
|
2008-11-04 01:19:35 -08:00
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
|
|
|
//
|
|
|
|
// re = (Render_Engine *)data;
|
2008-11-04 01:19:35 -08:00
|
|
|
}
|
|
|
|
|
2006-12-17 07:48:52 -08:00
|
|
|
static char *
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_image_comment_get(void *data, void *image, char *key __UNUSED__)
|
2006-12-17 07:48:52 -08:00
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
2006-12-17 07:48:52 -08:00
|
|
|
Evas_GL_Image *im;
|
|
|
|
|
2009-10-12 08:22:38 -07:00
|
|
|
// re = (Render_Engine *)data;
|
2006-12-19 06:12:40 -08:00
|
|
|
if (!image) return NULL;
|
2006-12-17 07:48:52 -08:00
|
|
|
im = image;
|
2010-01-21 04:43:53 -08:00
|
|
|
if (!im->im) return NULL;
|
2006-12-17 07:48:52 -08:00
|
|
|
return im->im->info.comment;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
eng_image_format_get(void *data, void *image)
|
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
2006-12-17 07:48:52 -08:00
|
|
|
Evas_GL_Image *im;
|
|
|
|
|
2009-10-12 08:22:38 -07:00
|
|
|
// re = (Render_Engine *)data;
|
2006-12-17 07:48:52 -08:00
|
|
|
im = image;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eng_image_colorspace_set(void *data, void *image, int cspace)
|
|
|
|
{
|
|
|
|
Render_Engine *re;
|
|
|
|
Evas_GL_Image *im;
|
2009-02-21 00:19:58 -08:00
|
|
|
|
2006-12-17 07:48:52 -08:00
|
|
|
re = (Render_Engine *)data;
|
2006-12-19 06:12:40 -08:00
|
|
|
if (!image) return;
|
2006-12-17 07:48:52 -08:00
|
|
|
im = image;
|
2010-01-21 01:42:26 -08:00
|
|
|
if (im->native.data) return;
|
2006-12-17 07:48:52 -08:00
|
|
|
/* FIXME: can move to gl_common */
|
|
|
|
if (im->cs.space == cspace) return;
|
2009-10-09 05:10:27 -07:00
|
|
|
eng_window_use(re->win);
|
2008-04-11 17:32:30 -07:00
|
|
|
evas_cache_image_colorspace(&im->im->cache_entry, cspace);
|
2006-12-17 07:48:52 -08:00
|
|
|
switch (cspace)
|
|
|
|
{
|
|
|
|
case EVAS_COLORSPACE_ARGB8888:
|
|
|
|
if (im->cs.data)
|
|
|
|
{
|
|
|
|
if (!im->cs.no_free) free(im->cs.data);
|
|
|
|
im->cs.data = NULL;
|
|
|
|
im->cs.no_free = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EVAS_COLORSPACE_YCBCR422P601_PL:
|
|
|
|
case EVAS_COLORSPACE_YCBCR422P709_PL:
|
2009-10-09 05:10:27 -07:00
|
|
|
if (im->tex) evas_gl_common_texture_free(im->tex);
|
|
|
|
im->tex = NULL;
|
2006-12-17 07:48:52 -08:00
|
|
|
if (im->cs.data)
|
|
|
|
{
|
|
|
|
if (!im->cs.no_free) free(im->cs.data);
|
|
|
|
}
|
2010-03-01 06:37:37 -08:00
|
|
|
if (im->im->cache_entry.h > 0)
|
|
|
|
im->cs.data =
|
|
|
|
calloc(1, im->im->cache_entry.h * sizeof(unsigned char *) * 2);
|
|
|
|
else
|
|
|
|
im->cs.data = NULL;
|
2006-12-17 07:48:52 -08:00
|
|
|
im->cs.no_free = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
im->cs.space = cspace;
|
|
|
|
}
|
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
//
|
|
|
|
typedef struct _Native Native;
|
|
|
|
|
|
|
|
struct _Native
|
|
|
|
{
|
|
|
|
Evas_Native_Surface ns;
|
|
|
|
Pixmap pixmap;
|
|
|
|
Visual *visual;
|
|
|
|
|
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-01-28 21:32:51 -08:00
|
|
|
void *egl_surface;
|
2010-01-21 00:44:11 -08:00
|
|
|
#else
|
2010-02-14 07:12:39 -08:00
|
|
|
void *fbc;
|
|
|
|
XID glx_pixmap;
|
2010-01-21 00:44:11 -08:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2010-01-23 21:11:54 -08:00
|
|
|
// FIXME: this is enabled so updates happen - but its SLOOOOOOOOOOOOOOOW
|
|
|
|
// (i am sure this is the reason) not to mention seemingly superfluous. but
|
|
|
|
// i need to enable it for it to work on fglrx at least. havent tried nvidia.
|
|
|
|
//
|
|
|
|
// why is this the case? does anyone know? has anyone tried it on other gfx
|
|
|
|
// drivers?
|
|
|
|
//
|
2010-01-30 18:50:01 -08:00
|
|
|
//#define GLX_TEX_PIXMAP_RECREATE 1
|
2010-01-23 21:11:54 -08:00
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
static void
|
|
|
|
_native_bind_cb(void *data, void *image)
|
|
|
|
{
|
|
|
|
Render_Engine *re = data;
|
|
|
|
Evas_GL_Image *im = image;
|
|
|
|
Native *n = im->native.data;
|
|
|
|
|
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-01-28 21:32:51 -08:00
|
|
|
if (n->egl_surface)
|
|
|
|
{
|
|
|
|
if (glsym_glEGLImageTargetTexture2DOES)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
|
|
|
glsym_glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, n->egl_surface);
|
|
|
|
if (eglGetError() != EGL_SUCCESS)
|
|
|
|
{
|
|
|
|
printf("Error: glEGLImageTargetTexture2DOES() fail.\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("Try glEGLImageTargetTexture2DOES on EGL with no support\n");
|
|
|
|
}
|
2010-01-28 21:32:51 -08:00
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
#else
|
|
|
|
# ifdef GLX_BIND_TO_TEXTURE_TARGETS_EXT
|
|
|
|
if (glsym_glXBindTexImage)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
|
|
|
glsym_glXBindTexImage(re->win->disp, n->glx_pixmap,
|
|
|
|
GLX_FRONT_LEFT_EXT, NULL);
|
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("Try glXBindTexImage on GLX with no support\n");
|
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_native_unbind_cb(void *data, void *image)
|
|
|
|
{
|
|
|
|
Render_Engine *re = data;
|
|
|
|
Evas_GL_Image *im = image;
|
|
|
|
Native *n = im->native.data;
|
|
|
|
|
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-02-01 23:00:10 -08:00
|
|
|
// nothing
|
2010-01-21 00:44:11 -08:00
|
|
|
#else
|
|
|
|
# ifdef GLX_BIND_TO_TEXTURE_TARGETS_EXT
|
|
|
|
if (glsym_glXReleaseTexImage)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
|
|
|
glsym_glXReleaseTexImage(re->win->disp, n->glx_pixmap,
|
|
|
|
GLX_FRONT_LEFT_EXT);
|
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("Try glXReleaseTexImage on GLX with no support\n");
|
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-12-17 07:48:52 -08:00
|
|
|
static void
|
2010-01-21 00:44:11 -08:00
|
|
|
_native_free_cb(void *data, void *image)
|
2006-12-17 07:48:52 -08:00
|
|
|
{
|
2010-01-21 00:44:11 -08:00
|
|
|
Render_Engine *re = data;
|
|
|
|
Evas_GL_Image *im = image;
|
|
|
|
Native *n = im->native.data;
|
|
|
|
|
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-01-28 21:32:51 -08:00
|
|
|
if (n->egl_surface)
|
|
|
|
{
|
|
|
|
if (glsym_eglDestroyImage)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
|
|
|
glsym_eglDestroyImage(re->win->egl_disp,
|
|
|
|
n->egl_surface);
|
|
|
|
if (eglGetError() != EGL_SUCCESS)
|
|
|
|
{
|
|
|
|
printf("Error: eglDestroyImage() fail.\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("Try eglDestroyImage on EGL with no support\n");
|
|
|
|
}
|
2010-01-28 21:32:51 -08:00
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
#else
|
|
|
|
# ifdef GLX_BIND_TO_TEXTURE_TARGETS_EXT
|
|
|
|
if (n->glx_pixmap)
|
|
|
|
{
|
2010-01-23 21:11:54 -08:00
|
|
|
if (im->native.loose)
|
|
|
|
{
|
|
|
|
if (glsym_glXReleaseTexImage)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
|
|
|
glsym_glXReleaseTexImage(re->win->disp, n->glx_pixmap,
|
|
|
|
GLX_FRONT_LEFT_EXT);
|
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("Try glXReleaseTexImage on GLX with no support\n");
|
|
|
|
}
|
2010-01-23 21:11:54 -08:00
|
|
|
}
|
2010-02-14 07:12:39 -08:00
|
|
|
if (glsym_glXDestroyPixmap)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
|
|
|
glsym_glXDestroyPixmap(re->win->disp, n->glx_pixmap);
|
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("Try glXDestroyPixmap on GLX with no support\n");
|
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
n->glx_pixmap = 0;
|
|
|
|
}
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
im->native.data = NULL;
|
|
|
|
im->native.func.data = NULL;
|
|
|
|
im->native.func.bind = NULL;
|
|
|
|
im->native.func.unbind = NULL;
|
|
|
|
im->native.func.free = NULL;
|
|
|
|
free(n);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eng_image_native_set(void *data, void *image, void *native)
|
|
|
|
{
|
|
|
|
Render_Engine *re = (Render_Engine *)data;
|
|
|
|
Evas_Native_Surface *ns = native;
|
|
|
|
Evas_GL_Image *im = image;
|
|
|
|
Visual *vis = NULL;
|
|
|
|
Pixmap pm = 0;
|
|
|
|
|
2010-02-17 18:51:27 -08:00
|
|
|
if (!im) return;
|
2010-01-21 00:44:11 -08:00
|
|
|
if (ns)
|
|
|
|
{
|
|
|
|
vis = ns->data.x11.visual;
|
|
|
|
pm = ns->data.x11.pixmap;
|
|
|
|
if (im->native.data)
|
|
|
|
{
|
|
|
|
Evas_Native_Surface *n = im->native.data;
|
|
|
|
if ((n->data.x11.visual == vis) && (n->data.x11.pixmap == pm))
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((!ns) && (!im->native.data)) return;
|
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-01-21 01:42:26 -08:00
|
|
|
if (im->native.data)
|
2010-01-21 00:44:11 -08:00
|
|
|
{
|
2010-01-21 01:42:26 -08:00
|
|
|
if (im->native.func.free)
|
|
|
|
im->native.func.free(im->native.func.data, im);
|
|
|
|
evas_gl_common_image_native_disable(im);
|
2010-01-25 06:29:30 -08:00
|
|
|
im->native.data = NULL;
|
2010-01-21 01:42:26 -08:00
|
|
|
}
|
|
|
|
if (native)
|
|
|
|
{
|
|
|
|
Native *n;
|
|
|
|
|
|
|
|
n = calloc(1, sizeof(Native));
|
|
|
|
if (n)
|
|
|
|
{
|
|
|
|
EGLConfig egl_config;
|
|
|
|
int config_attrs[20];
|
|
|
|
int num_config, i;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
config_attrs[i++] = EGL_RED_SIZE;
|
|
|
|
config_attrs[i++] = 8;
|
|
|
|
config_attrs[i++] = EGL_GREEN_SIZE;
|
|
|
|
config_attrs[i++] = 8;
|
|
|
|
config_attrs[i++] = EGL_BLUE_SIZE;
|
|
|
|
config_attrs[i++] = 8;
|
|
|
|
config_attrs[i++] = EGL_ALPHA_SIZE;
|
|
|
|
config_attrs[i++] = 8;
|
|
|
|
config_attrs[i++] = EGL_DEPTH_SIZE;
|
2010-01-25 06:29:30 -08:00
|
|
|
config_attrs[i++] = 0;
|
|
|
|
config_attrs[i++] = EGL_STENCIL_SIZE;
|
|
|
|
config_attrs[i++] = 0;
|
2010-01-21 01:42:26 -08:00
|
|
|
config_attrs[i++] = EGL_RENDERABLE_TYPE;
|
|
|
|
config_attrs[i++] = EGL_OPENGL_ES2_BIT;
|
|
|
|
config_attrs[i++] = EGL_SURFACE_TYPE;
|
|
|
|
config_attrs[i++] = EGL_PIXMAP_BIT;
|
|
|
|
config_attrs[i++] = EGL_NONE;
|
|
|
|
|
2010-01-25 06:29:30 -08:00
|
|
|
if (!eglChooseConfig(re->win->egl_disp, config_attrs,
|
|
|
|
&egl_config, 1, &num_config))
|
|
|
|
{
|
2010-01-28 22:33:10 -08:00
|
|
|
printf("ERROR: eglChooseConfig() failed for pixmap 0x%x, num_config = %i\n", (unsigned int)pm, num_config);
|
2010-01-25 06:29:30 -08:00
|
|
|
}
|
2010-01-21 01:42:26 -08:00
|
|
|
n->pixmap = pm;
|
|
|
|
n->visual = vis;
|
|
|
|
im->native.yinvert = 1;
|
2010-01-23 21:11:54 -08:00
|
|
|
im->native.loose = 0;
|
2010-01-21 01:42:26 -08:00
|
|
|
im->native.data = n;
|
|
|
|
im->native.func.data = re;
|
|
|
|
im->native.func.bind = _native_bind_cb;
|
|
|
|
im->native.func.unbind = _native_unbind_cb;
|
|
|
|
im->native.func.free = _native_free_cb;
|
2010-02-01 21:30:19 -08:00
|
|
|
im->native.target = GL_TEXTURE_2D;
|
|
|
|
im->native.mipmap = 0;
|
2010-01-28 21:32:51 -08:00
|
|
|
if (glsym_eglCreateImage)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
|
|
|
n->egl_surface = glsym_eglCreateImage(re->win->egl_disp,
|
|
|
|
EGL_NO_CONTEXT,
|
|
|
|
EGL_NATIVE_PIXMAP_KHR,
|
|
|
|
(void *)pm,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("Try eglCreateImage on EGL with no support\n");
|
|
|
|
}
|
2010-01-25 06:44:02 -08:00
|
|
|
if (!n->egl_surface)
|
|
|
|
{
|
2010-01-28 22:33:10 -08:00
|
|
|
printf("ERROR: eglCreatePixmapSurface() for 0x%x failed\n", (unsigned int)pm);
|
2010-01-25 06:44:02 -08:00
|
|
|
}
|
2010-01-23 21:11:54 -08:00
|
|
|
evas_gl_common_image_native_enable(im);
|
2010-01-21 01:42:26 -08:00
|
|
|
}
|
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
#else
|
|
|
|
# ifdef GLX_BIND_TO_TEXTURE_TARGETS_EXT
|
|
|
|
if (im->native.data)
|
|
|
|
{
|
|
|
|
if (im->native.func.free)
|
|
|
|
im->native.func.free(im->native.func.data, im);
|
|
|
|
evas_gl_common_image_native_disable(im);
|
|
|
|
}
|
|
|
|
if (native)
|
|
|
|
{
|
2010-01-30 18:50:01 -08:00
|
|
|
int dummy;
|
|
|
|
unsigned int w, h, depth = 32, border;
|
|
|
|
Window wdummy;
|
|
|
|
Native *n;
|
2010-02-16 20:21:59 -08:00
|
|
|
|
|
|
|
// fixme: round trip :(
|
2010-01-30 18:50:01 -08:00
|
|
|
XGetGeometry(re->win->disp, pm, &wdummy, &dummy, &dummy,
|
|
|
|
&w, &h, &border, &depth);
|
|
|
|
n = calloc(1, sizeof(Native));
|
|
|
|
if (n)
|
2010-01-21 00:44:11 -08:00
|
|
|
{
|
2010-01-30 18:50:01 -08:00
|
|
|
int pixmap_att[20];
|
|
|
|
int target = 0;
|
|
|
|
int i = 0;
|
2010-02-09 22:24:21 -08:00
|
|
|
|
2010-01-30 18:50:01 -08:00
|
|
|
if ((re->win->depth_cfg[depth].tex_target &
|
2010-02-09 22:24:21 -08:00
|
|
|
GLX_TEXTURE_2D_BIT_EXT)
|
|
|
|
// && (1) // we assume npo2 for now
|
2010-01-30 18:50:01 -08:00
|
|
|
// size is pow2 || mnpo2 supported
|
|
|
|
)
|
2010-01-21 00:44:11 -08:00
|
|
|
{
|
2010-01-30 18:50:01 -08:00
|
|
|
target = GLX_TEXTURE_2D_EXT;
|
|
|
|
}
|
|
|
|
else if ((re->win->depth_cfg[depth].tex_target &
|
|
|
|
GLX_TEXTURE_RECTANGLE_BIT_EXT))
|
|
|
|
{
|
2010-02-09 22:24:21 -08:00
|
|
|
printf("rect!!! (not handled)\n");
|
2010-01-30 18:50:01 -08:00
|
|
|
target = GLX_TEXTURE_RECTANGLE_EXT;
|
|
|
|
}
|
|
|
|
if (!target)
|
|
|
|
{
|
|
|
|
printf("broken text-from-pixmap\n");
|
|
|
|
if (!(re->win->depth_cfg[depth].tex_target &
|
|
|
|
GLX_TEXTURE_2D_BIT_EXT))
|
2010-01-21 00:44:11 -08:00
|
|
|
{
|
2010-01-30 18:50:01 -08:00
|
|
|
target = GLX_TEXTURE_RECTANGLE_EXT;
|
|
|
|
}
|
|
|
|
else if (!(re->win->depth_cfg[depth].tex_target &
|
|
|
|
GLX_TEXTURE_RECTANGLE_BIT_EXT))
|
|
|
|
{
|
|
|
|
target = GLX_TEXTURE_2D_EXT;
|
2010-01-21 00:44:11 -08:00
|
|
|
}
|
|
|
|
}
|
2010-01-30 18:50:01 -08:00
|
|
|
|
|
|
|
|
|
|
|
pixmap_att[i++] = GLX_TEXTURE_FORMAT_EXT;
|
|
|
|
pixmap_att[i++] = re->win->depth_cfg[depth].tex_format;
|
|
|
|
pixmap_att[i++] = GLX_MIPMAP_TEXTURE_EXT;
|
|
|
|
pixmap_att[i++] = re->win->depth_cfg[depth].mipmap;
|
|
|
|
|
|
|
|
if (target)
|
2010-01-21 00:44:11 -08:00
|
|
|
{
|
2010-01-30 18:50:01 -08:00
|
|
|
pixmap_att[i++] = GLX_TEXTURE_TARGET_EXT;
|
|
|
|
pixmap_att[i++] = target;
|
|
|
|
}
|
|
|
|
|
|
|
|
pixmap_att[i++] = 0;
|
2010-02-01 23:00:10 -08:00
|
|
|
|
2010-01-30 18:50:01 -08:00
|
|
|
memcpy(&(n->ns), ns, sizeof(Evas_Native_Surface));
|
|
|
|
n->pixmap = pm;
|
|
|
|
n->visual = vis;
|
|
|
|
n->fbc = re->win->depth_cfg[depth].fbc;
|
|
|
|
im->native.yinvert = re->win->depth_cfg[depth].yinvert;
|
2010-02-14 20:12:50 -08:00
|
|
|
im->native.loose = re->win->detected.loose_binding;
|
2010-01-30 18:50:01 -08:00
|
|
|
im->native.data = n;
|
|
|
|
im->native.func.data = re;
|
|
|
|
im->native.func.bind = _native_bind_cb;
|
|
|
|
im->native.func.unbind = _native_unbind_cb;
|
|
|
|
im->native.func.free = _native_free_cb;
|
2010-02-14 07:12:39 -08:00
|
|
|
if (glsym_glXCreatePixmap)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
|
|
|
n->glx_pixmap = glsym_glXCreatePixmap(re->win->disp, n->fbc,
|
|
|
|
n->pixmap, pixmap_att);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("Try glXCreatePixmap on GLX with no support\n");
|
|
|
|
}
|
2010-02-14 07:12:39 -08:00
|
|
|
if (n->glx_pixmap)
|
|
|
|
{
|
2010-02-10 05:36:33 -08:00
|
|
|
// printf("new native texture for %x | %4i x %4i @ %2i = %p\n",
|
|
|
|
// pm, w, h, depth, n->glx_pixmap);
|
2010-02-14 07:12:39 -08:00
|
|
|
if (!target)
|
|
|
|
{
|
|
|
|
printf("no target :(\n");
|
|
|
|
if (glsym_glXQueryDrawable)
|
|
|
|
glsym_glXQueryDrawable(re->win->disp, n->pixmap, GLX_TEXTURE_TARGET_EXT, &target);
|
|
|
|
}
|
|
|
|
if (target == GLX_TEXTURE_2D_EXT)
|
|
|
|
{
|
|
|
|
im->native.target = GL_TEXTURE_2D;
|
|
|
|
im->native.mipmap = re->win->depth_cfg[depth].mipmap;
|
|
|
|
}
|
2010-02-09 22:24:21 -08:00
|
|
|
#ifdef GL_TEXTURE_RECTANGLE_ARB
|
2010-02-14 07:12:39 -08:00
|
|
|
else if (target == GLX_TEXTURE_RECTANGLE_EXT)
|
|
|
|
{
|
|
|
|
im->native.target = GL_TEXTURE_RECTANGLE_ARB;
|
|
|
|
im->native.mipmap = 0;
|
|
|
|
}
|
2010-02-09 22:24:21 -08:00
|
|
|
#endif
|
2010-02-14 07:12:39 -08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
im->native.target = GL_TEXTURE_2D;
|
|
|
|
im->native.mipmap = 0;
|
|
|
|
printf("still unknown target\n");
|
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
}
|
2010-02-16 20:21:59 -08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("ERROR: GLX Pixmap create fail\n");
|
|
|
|
}
|
2010-02-01 23:00:10 -08:00
|
|
|
|
2010-01-30 18:50:01 -08:00
|
|
|
evas_gl_common_image_native_enable(im);
|
2010-01-21 00:44:11 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
# endif
|
|
|
|
#endif
|
2006-12-17 07:48:52 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2010-01-21 00:44:11 -08:00
|
|
|
eng_image_native_get(void *data, void *image)
|
2006-12-17 07:48:52 -08:00
|
|
|
{
|
2010-01-21 00:44:11 -08:00
|
|
|
Render_Engine *re = (Render_Engine *)data;
|
|
|
|
Evas_GL_Image *im = image;
|
|
|
|
Native *n;
|
|
|
|
if (!im) return NULL;
|
|
|
|
n = im->native.data;
|
|
|
|
if (!n) return NULL;
|
|
|
|
return &(n->ns);
|
2006-12-17 07:48:52 -08:00
|
|
|
}
|
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
//
|
|
|
|
//
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
static void *
|
2007-03-04 08:19:32 -08:00
|
|
|
eng_image_load(void *data, const char *file, const char *key, int *error, Evas_Image_Load_Opts *lo)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_NONE;
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2009-12-22 15:11:57 -08:00
|
|
|
return evas_gl_common_image_load(re->win->gl_context, file, key, lo, error);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2006-12-17 07:48:52 -08:00
|
|
|
eng_image_new_from_data(void *data, int w, int h, DATA32 *image_data, int alpha, int cspace)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2006-12-17 07:48:52 -08:00
|
|
|
return evas_gl_common_image_new_from_data(re->win->gl_context, w, h, image_data, alpha, cspace);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2006-12-17 07:48:52 -08:00
|
|
|
eng_image_new_from_copied_data(void *data, int w, int h, DATA32 *image_data, int alpha, int cspace)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2006-12-17 07:48:52 -08:00
|
|
|
return evas_gl_common_image_new_from_copied_data(re->win->gl_context, w, h, image_data, alpha, cspace);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_image_free(void *data, void *image)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
2006-12-19 06:12:40 -08:00
|
|
|
if (!image) return;
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2003-09-04 00:40:34 -07:00
|
|
|
evas_gl_common_image_free(image);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_image_size_get(void *data, void *image, int *w, int *h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-10-12 08:22:38 -07:00
|
|
|
// Render_Engine *re;
|
|
|
|
//
|
|
|
|
// re = (Render_Engine *)data;
|
2006-12-19 06:12:40 -08:00
|
|
|
if (!image)
|
|
|
|
{
|
|
|
|
*w = 0;
|
|
|
|
*h = 0;
|
|
|
|
return;
|
|
|
|
}
|
2010-01-21 01:42:26 -08:00
|
|
|
if (w) *w = ((Evas_GL_Image *)image)->w;
|
|
|
|
if (h) *h = ((Evas_GL_Image *)image)->h;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_image_size_set(void *data, void *image, int w, int h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2010-01-21 01:42:26 -08:00
|
|
|
Evas_GL_Image *im = image;
|
|
|
|
Evas_GL_Image *im_old;
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2010-01-21 01:42:26 -08:00
|
|
|
if (!im) return NULL;
|
|
|
|
if (im->native.data)
|
|
|
|
{
|
|
|
|
im->w = w;
|
|
|
|
im->h = h;
|
|
|
|
return image;
|
|
|
|
}
|
2006-12-19 06:12:40 -08:00
|
|
|
eng_window_use(re->win);
|
2003-09-04 00:40:34 -07:00
|
|
|
im_old = image;
|
2007-06-02 08:30:59 -07:00
|
|
|
if ((eng_image_colorspace_get(data, image) == EVAS_COLORSPACE_YCBCR422P601_PL) ||
|
|
|
|
(eng_image_colorspace_get(data, image) == EVAS_COLORSPACE_YCBCR422P709_PL))
|
|
|
|
w &= ~0x1;
|
2008-04-11 17:32:30 -07:00
|
|
|
if ((im_old) && (im_old->im->cache_entry.w == w) && (im_old->im->cache_entry.h == h))
|
2003-09-04 22:37:14 -07:00
|
|
|
return image;
|
2003-09-04 00:40:34 -07:00
|
|
|
if (im_old)
|
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
im = evas_gl_common_image_new(re->win->gl_context, w, h,
|
|
|
|
eng_image_alpha_get(data, image),
|
|
|
|
eng_image_colorspace_get(data, image));
|
2009-02-21 00:19:58 -08:00
|
|
|
/*
|
2003-09-04 00:40:34 -07:00
|
|
|
evas_common_load_image_data_from_file(im_old->im);
|
|
|
|
if (im_old->im->image->data)
|
|
|
|
{
|
|
|
|
evas_common_blit_rectangle(im_old->im, im->im, 0, 0, w, h, 0, 0);
|
|
|
|
evas_common_cpu_end_opt();
|
|
|
|
}
|
2006-12-17 07:48:52 -08:00
|
|
|
*/
|
2009-10-09 05:10:27 -07:00
|
|
|
evas_gl_common_image_free(im_old);
|
2003-09-04 00:40:34 -07:00
|
|
|
}
|
2006-12-17 07:48:52 -08:00
|
|
|
else
|
|
|
|
im = evas_gl_common_image_new(re->win->gl_context, w, h, 1, EVAS_COLORSPACE_ARGB8888);
|
2003-09-04 00:40:34 -07:00
|
|
|
return im;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2009-12-19 22:23:13 -08:00
|
|
|
eng_image_dirty_region(void *data, void *image, int x, int y, int w, int h)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2010-01-21 01:42:26 -08:00
|
|
|
Evas_GL_Image *im = image;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2006-12-19 06:12:40 -08:00
|
|
|
if (!image) return NULL;
|
2010-01-21 01:42:26 -08:00
|
|
|
if (im->native.data) return image;
|
2010-01-21 04:43:53 -08:00
|
|
|
eng_window_use(re->win);
|
2009-12-19 22:23:13 -08:00
|
|
|
evas_gl_common_image_dirty(image, x, y, w, h);
|
2003-09-04 00:40:34 -07:00
|
|
|
return image;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_image_data_get(void *data, void *image, int to_write, DATA32 **image_data)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2003-09-04 00:40:34 -07:00
|
|
|
Evas_GL_Image *im;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2006-12-19 06:12:40 -08:00
|
|
|
if (!image)
|
|
|
|
{
|
|
|
|
*image_data = NULL;
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-09-04 00:40:34 -07:00
|
|
|
im = image;
|
2010-01-21 01:42:26 -08:00
|
|
|
if (im->native.data)
|
|
|
|
{
|
|
|
|
*image_data = NULL;
|
|
|
|
return im;
|
|
|
|
}
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2008-04-11 17:32:30 -07:00
|
|
|
evas_cache_image_load_data(&im->im->cache_entry);
|
2006-12-17 07:48:52 -08:00
|
|
|
switch (im->cs.space)
|
2003-09-04 00:40:34 -07:00
|
|
|
{
|
2006-12-17 07:48:52 -08:00
|
|
|
case EVAS_COLORSPACE_ARGB8888:
|
|
|
|
if (to_write)
|
2003-09-04 00:40:34 -07:00
|
|
|
{
|
2006-12-17 07:48:52 -08:00
|
|
|
if (im->references > 1)
|
2003-09-04 22:37:14 -07:00
|
|
|
{
|
2006-12-17 07:48:52 -08:00
|
|
|
Evas_GL_Image *im_new;
|
2009-02-21 00:19:58 -08:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
im_new = evas_gl_common_image_new_from_copied_data(im->gc, im->im->cache_entry.w, im->im->cache_entry.h, im->im->image.data,
|
|
|
|
eng_image_alpha_get(data, image),
|
|
|
|
eng_image_colorspace_get(data, image));
|
|
|
|
if (!im_new)
|
|
|
|
{
|
|
|
|
*image_data = NULL;
|
|
|
|
return im;
|
|
|
|
}
|
|
|
|
evas_gl_common_image_free(im);
|
|
|
|
im = im_new;
|
2003-09-04 22:37:14 -07:00
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
else
|
2009-12-19 22:23:13 -08:00
|
|
|
evas_gl_common_image_dirty(im, 0, 0, 0, 0);
|
2003-09-04 00:40:34 -07:00
|
|
|
}
|
2008-04-11 17:32:30 -07:00
|
|
|
*image_data = im->im->image.data;
|
2006-12-17 07:48:52 -08:00
|
|
|
break;
|
|
|
|
case EVAS_COLORSPACE_YCBCR422P601_PL:
|
|
|
|
case EVAS_COLORSPACE_YCBCR422P709_PL:
|
|
|
|
*image_data = im->cs.data;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
break;
|
2003-09-04 00:40:34 -07:00
|
|
|
}
|
|
|
|
return im;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
2006-02-27 20:07:49 -08:00
|
|
|
eng_image_data_put(void *data, void *image, DATA32 *image_data)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2006-12-17 08:46:30 -08:00
|
|
|
Evas_GL_Image *im, *im2;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2006-12-19 06:12:40 -08:00
|
|
|
if (!image) return NULL;
|
2003-09-04 00:40:34 -07:00
|
|
|
im = image;
|
2010-01-21 01:42:26 -08:00
|
|
|
if (im->native.data) return image;
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2006-12-17 07:48:52 -08:00
|
|
|
switch (im->cs.space)
|
2003-09-04 00:40:34 -07:00
|
|
|
{
|
2006-12-17 07:48:52 -08:00
|
|
|
case EVAS_COLORSPACE_ARGB8888:
|
2008-04-11 17:32:30 -07:00
|
|
|
if (image_data != im->im->image.data)
|
2006-12-17 07:48:52 -08:00
|
|
|
{
|
|
|
|
int w, h;
|
2009-02-21 00:19:58 -08:00
|
|
|
|
2008-04-11 17:32:30 -07:00
|
|
|
w = im->im->cache_entry.w;
|
|
|
|
h = im->im->cache_entry.h;
|
2006-12-17 08:46:30 -08:00
|
|
|
im2 = eng_image_new_from_data(data, w, h, image_data,
|
|
|
|
eng_image_alpha_get(data, image),
|
|
|
|
eng_image_colorspace_get(data, image));
|
2009-10-09 05:10:27 -07:00
|
|
|
if (!im2) return im;
|
|
|
|
evas_gl_common_image_free(im);
|
|
|
|
im = im2;
|
2006-12-17 07:48:52 -08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EVAS_COLORSPACE_YCBCR422P601_PL:
|
|
|
|
case EVAS_COLORSPACE_YCBCR422P709_PL:
|
|
|
|
if (image_data != im->cs.data)
|
|
|
|
{
|
|
|
|
if (im->cs.data)
|
|
|
|
{
|
|
|
|
if (!im->cs.no_free) free(im->cs.data);
|
|
|
|
}
|
|
|
|
im->cs.data = image_data;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
break;
|
2003-09-04 00:40:34 -07:00
|
|
|
}
|
|
|
|
/* hmmm - but if we wrote... why bother? */
|
2009-12-19 22:23:13 -08:00
|
|
|
evas_gl_common_image_dirty(im, 0, 0, 0, 0);
|
2003-09-04 00:40:34 -07:00
|
|
|
return im;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2008-09-16 07:52:57 -07:00
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_image_data_preload_request(void *data __UNUSED__, void *image, const void *target)
|
2008-09-16 07:52:57 -07:00
|
|
|
{
|
|
|
|
Evas_GL_Image *gim = image;
|
|
|
|
RGBA_Image *im;
|
|
|
|
|
2010-01-21 01:42:26 -08:00
|
|
|
if (!gim) return;
|
|
|
|
if (gim->native.data) return;
|
|
|
|
im = (RGBA_Image *)gim->im;
|
|
|
|
if (!im) return;
|
2008-09-16 07:52:57 -07:00
|
|
|
evas_cache_image_preload_data(&im->cache_entry, target);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-28 02:08:45 -08:00
|
|
|
eng_image_data_preload_cancel(void *data __UNUSED__, void *image, const void *target)
|
2008-09-16 07:52:57 -07:00
|
|
|
{
|
|
|
|
Evas_GL_Image *gim = image;
|
|
|
|
RGBA_Image *im;
|
|
|
|
|
2010-01-21 01:42:26 -08:00
|
|
|
if (!gim) return;
|
|
|
|
if (gim->native.data) return;
|
|
|
|
im = (RGBA_Image *)gim->im;
|
|
|
|
if (!im) return;
|
2009-01-20 06:56:37 -08:00
|
|
|
evas_cache_image_preload_cancel(&im->cache_entry, target);
|
2008-09-16 07:52:57 -07:00
|
|
|
}
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
static void
|
2009-11-12 23:22:31 -08:00
|
|
|
eng_image_draw(void *data, void *context, void *surface, void *image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int dst_w, int dst_h, int smooth)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
re = (Render_Engine *)data;
|
2006-12-19 06:12:40 -08:00
|
|
|
if (!image) return;
|
2006-03-06 18:44:16 -08:00
|
|
|
eng_window_use(re->win);
|
2009-11-12 23:22:31 -08:00
|
|
|
evas_gl_common_context_target_surface_set(re->win->gl_context, surface);
|
2006-09-30 03:18:37 -07:00
|
|
|
re->win->gl_context->dc = context;
|
|
|
|
evas_gl_common_image_draw(re->win->gl_context, image,
|
2009-10-09 05:10:27 -07:00
|
|
|
src_x, src_y, src_w, src_h,
|
|
|
|
dst_x, dst_y, dst_w, dst_h,
|
|
|
|
smooth);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2009-05-07 06:29:56 -07:00
|
|
|
static void
|
|
|
|
eng_image_scale_hint_set(void *data __UNUSED__, void *image, int hint)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2009-11-06 03:32:23 -08:00
|
|
|
static void
|
|
|
|
eng_image_map4_draw(void *data __UNUSED__, void *context, void *surface, void *image, RGBA_Map_Point *p, int smooth, int level)
|
|
|
|
{
|
2009-11-11 03:39:25 -08:00
|
|
|
Render_Engine *re;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
2009-11-12 23:22:31 -08:00
|
|
|
eng_window_use(re->win);
|
|
|
|
evas_gl_common_context_target_surface_set(re->win->gl_context, surface);
|
|
|
|
re->win->gl_context->dc = context;
|
2009-11-11 03:39:25 -08:00
|
|
|
evas_gl_common_image_map4_draw(re->win->gl_context, image, p, smooth, level);
|
2009-11-06 03:32:23 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
|
|
|
eng_image_map_surface_new(void *data __UNUSED__, int w, int h, int alpha)
|
|
|
|
{
|
2009-11-12 23:22:31 -08:00
|
|
|
Render_Engine *re;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
|
|
|
return evas_gl_common_image_surface_new(re->win->gl_context, w, h, alpha);
|
2009-11-06 03:32:23 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eng_image_map_surface_free(void *data __UNUSED__, void *surface)
|
|
|
|
{
|
2009-11-12 23:22:31 -08:00
|
|
|
evas_gl_common_image_free(surface);
|
2009-11-06 03:32:23 -08:00
|
|
|
}
|
|
|
|
|
2009-05-07 06:29:56 -07:00
|
|
|
static int
|
|
|
|
eng_image_scale_hint_get(void *data __UNUSED__, void *image)
|
|
|
|
{
|
|
|
|
return EVAS_IMAGE_SCALE_HINT_NONE;
|
|
|
|
}
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
static void
|
2009-11-12 23:22:31 -08:00
|
|
|
eng_font_draw(void *data, void *context, void *surface, void *font, int x, int y, int w __UNUSED__, int h __UNUSED__, int ow __UNUSED__, int oh __UNUSED__, const char *text)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
Render_Engine *re;
|
|
|
|
|
|
|
|
re = (Render_Engine *)data;
|
2009-10-09 05:10:27 -07:00
|
|
|
eng_window_use(re->win);
|
2009-11-12 23:22:31 -08:00
|
|
|
evas_gl_common_context_target_surface_set(re->win->gl_context, surface);
|
|
|
|
re->win->gl_context->dc = context;
|
2003-09-04 00:40:34 -07:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
// FIXME: put im into context so we can free it
|
2003-09-10 07:33:39 -07:00
|
|
|
static RGBA_Image *im = NULL;
|
2009-10-09 05:10:27 -07:00
|
|
|
|
|
|
|
if (!im)
|
|
|
|
im = (RGBA_Image *)evas_cache_image_empty(evas_common_image_cache_get());
|
|
|
|
im->cache_entry.w = re->win->w;
|
|
|
|
im->cache_entry.h = re->win->h;
|
|
|
|
evas_common_draw_context_font_ext_set(context,
|
|
|
|
re->win->gl_context,
|
|
|
|
evas_gl_font_texture_new,
|
|
|
|
evas_gl_font_texture_free,
|
|
|
|
evas_gl_font_texture_draw);
|
2003-09-08 22:51:03 -07:00
|
|
|
evas_common_font_draw(im, context, font, x, y, text);
|
2005-05-21 19:49:50 -07:00
|
|
|
evas_common_draw_context_font_ext_set(context,
|
|
|
|
NULL,
|
2003-09-08 22:51:03 -07:00
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL);
|
2003-09-04 00:40:34 -07:00
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2009-08-14 10:11:08 -07:00
|
|
|
static Eina_Bool
|
|
|
|
eng_canvas_alpha_get(void *data __UNUSED__, void *info __UNUSED__)
|
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
// FIXME: support ARGB gl targets!!!
|
2009-08-14 10:11:08 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2009-06-16 06:01:36 -07:00
|
|
|
static int
|
2006-09-06 00:28:46 -07:00
|
|
|
module_open(Evas_Module *em)
|
2006-01-14 04:13:38 -08:00
|
|
|
{
|
2010-04-29 08:32:47 -07:00
|
|
|
static Eina_Bool xrm_inited = EINA_FALSE;
|
|
|
|
if (!xrm_inited)
|
|
|
|
{
|
|
|
|
xrm_inited = EINA_TRUE;
|
|
|
|
XrmInitialize();
|
|
|
|
}
|
|
|
|
|
2006-01-14 04:13:38 -08:00
|
|
|
if (!em) return 0;
|
2006-12-09 00:52:08 -08:00
|
|
|
/* get whatever engine module we inherit from */
|
|
|
|
if (!_evas_module_engine_inherit(&pfunc, "software_generic")) return 0;
|
2009-11-13 00:28:47 -08:00
|
|
|
if (_evas_engine_GL_X11_log_dom < 0)
|
|
|
|
_evas_engine_GL_X11_log_dom = eina_log_domain_register("EvasEngineGLX11", EVAS_DEFAULT_LOG_COLOR);
|
|
|
|
if (_evas_engine_GL_X11_log_dom < 0)
|
2009-10-22 08:22:22 -07:00
|
|
|
{
|
2009-11-13 00:28:47 -08:00
|
|
|
EINA_LOG_ERR("Impossible to create a log domain for GL X11 engine.\n");
|
|
|
|
return 0;
|
2009-10-22 08:22:22 -07:00
|
|
|
}
|
2006-12-09 00:52:08 -08:00
|
|
|
/* store it for later use */
|
|
|
|
func = pfunc;
|
|
|
|
/* now to override methods */
|
|
|
|
#define ORD(f) EVAS_API_OVERRIDE(f, &func, eng_)
|
|
|
|
ORD(info);
|
|
|
|
ORD(info_free);
|
|
|
|
ORD(setup);
|
2009-08-14 10:11:08 -07:00
|
|
|
ORD(canvas_alpha_get);
|
2006-12-09 00:52:08 -08:00
|
|
|
ORD(output_free);
|
|
|
|
ORD(output_resize);
|
|
|
|
ORD(output_tile_size_set);
|
|
|
|
ORD(output_redraws_rect_add);
|
|
|
|
ORD(output_redraws_rect_del);
|
|
|
|
ORD(output_redraws_clear);
|
|
|
|
ORD(output_redraws_next_update_get);
|
|
|
|
ORD(output_redraws_next_update_push);
|
|
|
|
ORD(context_cutout_add);
|
|
|
|
ORD(context_cutout_clear);
|
|
|
|
ORD(output_flush);
|
2007-06-16 19:56:59 -07:00
|
|
|
ORD(output_idle_flush);
|
2010-04-12 01:23:53 -07:00
|
|
|
ORD(output_dump);
|
2006-12-09 00:52:08 -08:00
|
|
|
ORD(rectangle_draw);
|
|
|
|
ORD(line_draw);
|
|
|
|
ORD(polygon_point_add);
|
|
|
|
ORD(polygon_points_clear);
|
|
|
|
ORD(polygon_draw);
|
2008-08-25 22:45:04 -07:00
|
|
|
|
|
|
|
ORD(gradient2_color_np_stop_insert);
|
|
|
|
ORD(gradient2_clear);
|
2008-11-04 01:19:35 -08:00
|
|
|
ORD(gradient2_fill_transform_set);
|
|
|
|
ORD(gradient2_fill_spread_set);
|
2008-08-25 22:45:04 -07:00
|
|
|
ORD(gradient2_linear_new);
|
|
|
|
ORD(gradient2_linear_free);
|
2008-11-04 01:19:35 -08:00
|
|
|
ORD(gradient2_linear_fill_set);
|
2008-08-25 22:45:04 -07:00
|
|
|
ORD(gradient2_linear_is_opaque);
|
|
|
|
ORD(gradient2_linear_is_visible);
|
|
|
|
ORD(gradient2_linear_render_pre);
|
|
|
|
ORD(gradient2_linear_render_post);
|
|
|
|
ORD(gradient2_linear_draw);
|
|
|
|
ORD(gradient2_radial_new);
|
|
|
|
ORD(gradient2_radial_free);
|
2008-11-04 01:19:35 -08:00
|
|
|
ORD(gradient2_radial_fill_set);
|
2008-08-25 22:45:04 -07:00
|
|
|
ORD(gradient2_radial_is_opaque);
|
|
|
|
ORD(gradient2_radial_is_visible);
|
|
|
|
ORD(gradient2_radial_render_pre);
|
|
|
|
ORD(gradient2_radial_render_post);
|
|
|
|
ORD(gradient2_radial_draw);
|
|
|
|
|
2006-12-09 00:52:08 -08:00
|
|
|
ORD(gradient_new);
|
|
|
|
ORD(gradient_free);
|
|
|
|
ORD(gradient_color_stop_add);
|
|
|
|
ORD(gradient_alpha_stop_add);
|
|
|
|
ORD(gradient_color_data_set);
|
|
|
|
ORD(gradient_alpha_data_set);
|
|
|
|
ORD(gradient_clear);
|
|
|
|
ORD(gradient_fill_set);
|
|
|
|
ORD(gradient_fill_angle_set);
|
|
|
|
ORD(gradient_fill_spread_set);
|
|
|
|
ORD(gradient_angle_set);
|
|
|
|
ORD(gradient_offset_set);
|
|
|
|
ORD(gradient_direction_set);
|
|
|
|
ORD(gradient_type_set);
|
|
|
|
ORD(gradient_is_opaque);
|
|
|
|
ORD(gradient_is_visible);
|
|
|
|
ORD(gradient_render_pre);
|
|
|
|
ORD(gradient_render_post);
|
|
|
|
ORD(gradient_draw);
|
|
|
|
ORD(image_load);
|
|
|
|
ORD(image_new_from_data);
|
|
|
|
ORD(image_new_from_copied_data);
|
|
|
|
ORD(image_free);
|
|
|
|
ORD(image_size_get);
|
|
|
|
ORD(image_size_set);
|
|
|
|
ORD(image_dirty_region);
|
|
|
|
ORD(image_data_get);
|
|
|
|
ORD(image_data_put);
|
2008-09-16 07:52:57 -07:00
|
|
|
ORD(image_data_preload_request);
|
|
|
|
ORD(image_data_preload_cancel);
|
2006-12-09 00:52:08 -08:00
|
|
|
ORD(image_alpha_set);
|
|
|
|
ORD(image_alpha_get);
|
2008-11-04 01:19:35 -08:00
|
|
|
ORD(image_border_set);
|
|
|
|
ORD(image_border_get);
|
2006-12-09 00:52:08 -08:00
|
|
|
ORD(image_draw);
|
|
|
|
ORD(image_comment_get);
|
|
|
|
ORD(image_format_get);
|
|
|
|
ORD(image_colorspace_set);
|
|
|
|
ORD(image_colorspace_get);
|
|
|
|
ORD(image_native_set);
|
|
|
|
ORD(image_native_get);
|
|
|
|
ORD(font_draw);
|
2009-05-07 06:29:56 -07:00
|
|
|
|
|
|
|
ORD(image_scale_hint_set);
|
|
|
|
ORD(image_scale_hint_get);
|
|
|
|
|
2009-11-06 03:32:23 -08:00
|
|
|
ORD(image_map4_draw);
|
|
|
|
ORD(image_map_surface_new);
|
|
|
|
ORD(image_map_surface_free);
|
2009-10-28 01:59:01 -07:00
|
|
|
|
2006-12-09 00:52:08 -08:00
|
|
|
/* now advertise out own api */
|
|
|
|
em->functions = (void *)(&func);
|
2006-01-14 04:13:38 -08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-06-16 06:01:36 -07:00
|
|
|
static void
|
|
|
|
module_close(Evas_Module *em)
|
2006-01-14 04:13:38 -08:00
|
|
|
{
|
2009-10-22 08:22:22 -07:00
|
|
|
eina_log_domain_unregister(_evas_engine_GL_X11_log_dom);
|
2010-04-29 08:32:47 -07:00
|
|
|
if (xrdb_user.db)
|
|
|
|
{
|
|
|
|
XrmDestroyDatabase(xrdb_user.db);
|
|
|
|
xrdb_user.last_stat = 0;
|
|
|
|
xrdb_user.last_mtime = 0;
|
|
|
|
xrdb_user.db = NULL;
|
|
|
|
}
|
2006-01-14 04:13:38 -08:00
|
|
|
}
|
|
|
|
|
2009-06-16 06:01:36 -07:00
|
|
|
static Evas_Module_Api evas_modapi =
|
2006-01-14 04:13:38 -08:00
|
|
|
{
|
|
|
|
EVAS_MODULE_API_VERSION,
|
2009-06-16 06:01:36 -07:00
|
|
|
"gl_x11",
|
|
|
|
"none",
|
|
|
|
{
|
|
|
|
module_open,
|
|
|
|
module_close
|
|
|
|
}
|
2006-01-14 04:13:38 -08:00
|
|
|
};
|
2009-06-16 06:01:36 -07:00
|
|
|
|
|
|
|
EVAS_MODULE_DEFINE(EVAS_MODULE_TYPE_ENGINE, engine, gl_x11);
|
|
|
|
|
|
|
|
#ifndef EVAS_STATIC_BUILD_GL_X11
|
|
|
|
EVAS_EINA_MODULE_DEFINE(engine, gl_x11);
|
|
|
|
#endif
|