2003-09-07 04:24:48 -07:00
|
|
|
#include "evas_gl_private.h"
|
|
|
|
|
2009-11-06 03:32:23 -08:00
|
|
|
static const GLenum rgba_fmt = GL_RGBA;
|
|
|
|
static const GLenum rgba_ifmt = GL_RGBA;
|
2010-02-17 23:10:28 -08:00
|
|
|
//#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
|
|
|
//static const GLenum rgb_fmt = GL_RGBA;
|
|
|
|
//static const GLenum rgb_ifmt = GL_RGBA;
|
|
|
|
//#else
|
2010-01-22 02:52:53 -08:00
|
|
|
static const GLenum rgb_fmt = GL_RGBA;
|
2010-01-27 07:29:24 -08:00
|
|
|
static const GLenum rgb_ifmt = GL_RGB;
|
2010-02-17 23:10:28 -08:00
|
|
|
//#endif
|
|
|
|
#ifdef GL_BGRA
|
2010-08-09 19:35:07 -07:00
|
|
|
# if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-08-01 23:46:38 -07:00
|
|
|
static const GLenum bgra_fmt = GL_BGRA;
|
|
|
|
static const GLenum bgra_ifmt = GL_BGRA;
|
|
|
|
static const GLenum bgr_fmt = GL_BGRA;
|
|
|
|
static const GLenum bgr_ifmt = GL_BGRA;
|
2010-08-09 19:35:07 -07:00
|
|
|
# else
|
2010-02-17 23:10:28 -08:00
|
|
|
static const GLenum bgra_fmt = GL_BGRA;
|
|
|
|
static const GLenum bgra_ifmt = GL_RGBA;
|
|
|
|
static const GLenum bgr_fmt = GL_BGRA;
|
|
|
|
static const GLenum bgr_ifmt = GL_RGB;
|
2010-08-01 23:46:38 -07:00
|
|
|
# endif
|
2010-01-27 07:29:24 -08:00
|
|
|
#endif
|
2011-08-23 08:13:40 -07:00
|
|
|
static const GLenum alpha_fmt = GL_ALPHA;
|
|
|
|
static const GLenum alpha_ifmt = GL_ALPHA;
|
|
|
|
static const GLenum lum_fmt = GL_LUMINANCE;
|
|
|
|
static const GLenum lum_ifmt = GL_LUMINANCE;
|
|
|
|
static const GLenum lum_alpha_fmt = GL_LUMINANCE_ALPHA;
|
|
|
|
static const GLenum lum_alpha_ifmt = GL_LUMINANCE_ALPHA;
|
2011-08-29 14:52:00 -07:00
|
|
|
static const GLenum rgba8_ifmt = GL_RGBA;
|
2011-08-23 08:13:40 -07:00
|
|
|
static const GLenum rgba8_fmt = GL_BGRA;
|
2009-11-06 03:32:23 -08:00
|
|
|
|
2010-08-26 19:02:38 -07:00
|
|
|
static struct {
|
|
|
|
struct {
|
|
|
|
int num, pix;
|
|
|
|
} c, a, v, r, n, d;
|
2010-09-18 19:10:09 -07:00
|
|
|
} texinfo = {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}};
|
2010-08-26 19:02:38 -07:00
|
|
|
|
2010-09-18 16:16:25 -07:00
|
|
|
static void
|
2010-08-26 19:02:38 -07:00
|
|
|
_print_tex_count(void)
|
|
|
|
{
|
|
|
|
if (getenv("EVAS_GL_MEMINFO"))
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
"T: c:%i/%ik | a:%i/%ik | v:%i/%ik | r:%i/%ik | n:%i/%ik | d:%i/%ik\n",
|
|
|
|
texinfo.c.num, (texinfo.c.pix * 4) / 1024,
|
|
|
|
texinfo.a.num, (texinfo.a.pix ) / 1024,
|
|
|
|
texinfo.v.num, (texinfo.v.pix ) / 1024,
|
|
|
|
texinfo.r.num, (texinfo.r.pix * 4) / 1024,
|
|
|
|
texinfo.n.num, (texinfo.n.pix * 4) / 1024,
|
|
|
|
texinfo.d.num, (texinfo.d.pix * 4) / 1024
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
static int
|
|
|
|
_nearest_pow2(int num)
|
2003-09-07 04:24:48 -07:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
unsigned int n = num - 1;
|
|
|
|
n |= n >> 1;
|
|
|
|
n |= n >> 2;
|
|
|
|
n |= n >> 4;
|
|
|
|
n |= n >> 8;
|
|
|
|
n |= n >> 16;
|
|
|
|
return n + 1;
|
|
|
|
}
|
2003-09-07 04:24:48 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
static void
|
2011-03-16 10:32:49 -07:00
|
|
|
_tex_adjust(Evas_Engine_GL_Context *gc, int *w, int *h)
|
2009-10-09 05:10:27 -07:00
|
|
|
{
|
2009-10-22 01:53:25 -07:00
|
|
|
if (gc->shared->info.tex_npo2) return;
|
2009-10-13 02:40:39 -07:00
|
|
|
/*if (gc->shared->info.tex_rect) return;*/
|
2009-10-09 05:10:27 -07:00
|
|
|
*w = _nearest_pow2(*w);
|
|
|
|
*h = _nearest_pow2(*h);
|
|
|
|
}
|
2003-09-07 04:24:48 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
static int
|
2011-03-16 10:32:49 -07:00
|
|
|
_tex_round_slot(Evas_Engine_GL_Context *gc, int h)
|
2009-10-09 05:10:27 -07:00
|
|
|
{
|
2009-10-22 01:53:25 -07:00
|
|
|
if (!gc->shared->info.tex_npo2)
|
2009-10-09 05:10:27 -07:00
|
|
|
h = _nearest_pow2(h);
|
2010-08-25 18:41:48 -07:00
|
|
|
return (h + gc->shared->info.tune.atlas.slot_size - 1) /
|
|
|
|
gc->shared->info.tune.atlas.slot_size;
|
2009-10-09 05:10:27 -07:00
|
|
|
}
|
2003-09-07 04:24:48 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
static int
|
|
|
|
_tex_format_index(GLuint format)
|
|
|
|
{
|
|
|
|
switch (format)
|
2005-10-07 23:22:43 -07:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
case GL_RGBA:
|
2010-02-17 23:10:28 -08:00
|
|
|
#ifdef GL_BGRA
|
|
|
|
case GL_BGRA:
|
2011-06-17 00:47:28 -07:00
|
|
|
#endif
|
2009-10-09 05:10:27 -07:00
|
|
|
return 0;
|
|
|
|
case GL_RGB:
|
|
|
|
return 1;
|
|
|
|
case GL_ALPHA:
|
|
|
|
return 2;
|
2011-01-13 02:41:08 -08:00
|
|
|
case GL_LUMINANCE: // never used in atlas
|
2009-10-10 06:24:15 -07:00
|
|
|
return 3;
|
2009-10-09 05:10:27 -07:00
|
|
|
default:
|
2010-02-17 23:10:28 -08:00
|
|
|
return 0;
|
2005-10-07 23:22:43 -07:00
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-11 17:32:30 -07:00
|
|
|
|
2009-11-06 03:32:23 -08:00
|
|
|
static void
|
2009-11-06 07:13:29 -08:00
|
|
|
_tex_2d(int intfmt, int w, int h, int fmt, int type)
|
2009-11-06 03:32:23 -08:00
|
|
|
{
|
2011-10-21 03:03:17 -07:00
|
|
|
int intfmtret = -1;
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexImage2D(GL_TEXTURE_2D, 0, intfmt, w, h, 0, fmt, type, NULL);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-10-21 05:03:41 -07:00
|
|
|
#ifdef GL_TEXTURE_INTERNAL_FORMAT
|
|
|
|
// this is not in opengles!!! hrrrm
|
2011-10-21 03:03:17 -07:00
|
|
|
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
|
|
|
|
GL_TEXTURE_INTERNAL_FORMAT, &intfmtret);
|
|
|
|
if (intfmtret != intfmt)
|
|
|
|
{
|
|
|
|
ERR("Fail tex alloc %ix%i", w, h);
|
|
|
|
// XXX send async err to evas
|
|
|
|
}
|
2011-10-21 05:03:41 -07:00
|
|
|
#endif
|
2009-11-06 03:32:23 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-11-06 07:13:29 -08:00
|
|
|
_tex_sub_2d(int x, int y, int w, int h, int fmt, int type, const void *pix)
|
2009-11-06 03:32:23 -08:00
|
|
|
{
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, fmt, type, pix);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2009-11-06 03:32:23 -08:00
|
|
|
}
|
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
static Evas_GL_Texture_Pool *
|
2011-03-16 10:32:49 -07:00
|
|
|
_pool_tex_new(Evas_Engine_GL_Context *gc, int w, int h, int intformat, GLenum format)
|
2009-10-09 05:10:27 -07:00
|
|
|
{
|
|
|
|
Evas_GL_Texture_Pool *pt;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
pt = calloc(1, sizeof(Evas_GL_Texture_Pool));
|
|
|
|
if (!pt) return NULL;
|
2010-08-25 18:41:48 -07:00
|
|
|
h = _tex_round_slot(gc, h) * gc->shared->info.tune.atlas.slot_size;
|
2009-10-09 05:10:27 -07:00
|
|
|
_tex_adjust(gc, &w, &h);
|
|
|
|
pt->gc = gc;
|
|
|
|
pt->w = w;
|
|
|
|
pt->h = h;
|
2009-11-06 03:32:23 -08:00
|
|
|
pt->intformat = intformat;
|
2009-10-09 05:10:27 -07:00
|
|
|
pt->format = format;
|
2009-11-06 03:32:23 -08:00
|
|
|
pt->dataformat = GL_UNSIGNED_BYTE;
|
2009-10-09 05:10:27 -07:00
|
|
|
pt->references = 0;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-26 19:02:38 -07:00
|
|
|
if (format == alpha_fmt)
|
|
|
|
{
|
|
|
|
texinfo.a.num++;
|
|
|
|
texinfo.a.pix += pt->w * pt->h;
|
|
|
|
}
|
|
|
|
else if (format == lum_fmt)
|
|
|
|
{
|
|
|
|
texinfo.v.num++;
|
|
|
|
texinfo.v.pix += pt->w * pt->h;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
texinfo.c.num++;
|
|
|
|
texinfo.c.pix += pt->w * pt->h;
|
|
|
|
}
|
|
|
|
|
|
|
|
_print_tex_count();
|
2011-06-17 00:47:28 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glGenTextures(1, &(pt->texture));
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, pt->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_2d(pt->intformat, w, h, pt->format, pt->dataformat);
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, gc->pipe[0].shader.cur_tex);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2009-10-09 05:10:27 -07:00
|
|
|
return pt;
|
|
|
|
}
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
static int
|
2010-09-18 19:10:09 -07:00
|
|
|
_pool_tex_alloc(Evas_GL_Texture_Pool *pt, int w, int h __UNUSED__, int *u, int *v, Eina_List **l_after)
|
2009-10-09 05:10:27 -07:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_GL_Texture *tex, *tex2;
|
|
|
|
int nx, d, b;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
if (pt->allocations)
|
2003-09-07 04:24:48 -07:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
tex = pt->allocations->data;
|
|
|
|
// if firest tex is not at left edge...
|
|
|
|
if (tex->x > (0 + 1))
|
|
|
|
{
|
|
|
|
if ((tex->x - 1) >= w)
|
|
|
|
{
|
|
|
|
*u = 0;
|
|
|
|
*v = 0;
|
|
|
|
*l_after = NULL;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2003-09-07 04:24:48 -07:00
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
EINA_LIST_FOREACH(pt->allocations, l, tex)
|
2003-09-07 04:24:48 -07:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
b = tex->x + tex->w + 2;
|
|
|
|
if (l->next)
|
|
|
|
{
|
|
|
|
tex2 = l->next->data;
|
|
|
|
nx = tex2->x - 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
nx = pt->w - 1;
|
|
|
|
d = nx - b;
|
|
|
|
if (d >= w)
|
|
|
|
{
|
|
|
|
*u = b;
|
|
|
|
*v = 0;
|
|
|
|
*l_after = l;
|
|
|
|
return 1;
|
|
|
|
}
|
2003-09-07 04:24:48 -07:00
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
*l_after = NULL;
|
|
|
|
return 0;
|
2003-09-07 04:24:48 -07:00
|
|
|
}
|
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
static Evas_GL_Texture_Pool *
|
2011-06-17 00:47:28 -07:00
|
|
|
_pool_tex_find(Evas_Engine_GL_Context *gc, int w, int h,
|
|
|
|
int intformat, int format, int *u, int *v,
|
2009-11-06 03:32:23 -08:00
|
|
|
Eina_List **l_after, int atlas_w)
|
2003-09-07 04:24:48 -07:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
Evas_GL_Texture_Pool *pt = NULL;
|
|
|
|
Eina_List *l;
|
|
|
|
int th, th2;
|
2010-08-25 21:37:43 -07:00
|
|
|
|
2010-08-25 18:41:48 -07:00
|
|
|
if (atlas_w > gc->shared->info.max_texture_size)
|
|
|
|
atlas_w = gc->shared->info.max_texture_size;
|
2011-06-17 00:47:28 -07:00
|
|
|
if ((w > gc->shared->info.tune.atlas.max_w) ||
|
2010-08-25 18:41:48 -07:00
|
|
|
(h > gc->shared->info.tune.atlas.max_h))
|
2003-09-07 04:24:48 -07:00
|
|
|
{
|
2009-11-06 03:32:23 -08:00
|
|
|
pt = _pool_tex_new(gc, w, h, intformat, format);
|
2009-10-13 02:40:39 -07:00
|
|
|
gc->shared->tex.whole = eina_list_prepend(gc->shared->tex.whole, pt);
|
2009-10-09 05:10:27 -07:00
|
|
|
pt->slot = -1;
|
|
|
|
pt->fslot = -1;
|
|
|
|
pt->whole = 1;
|
|
|
|
*u = 0;
|
|
|
|
*v = 0;
|
|
|
|
*l_after = NULL;
|
|
|
|
return pt;
|
2003-09-07 04:24:48 -07:00
|
|
|
}
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
th = _tex_round_slot(gc, h);
|
2010-02-17 23:10:28 -08:00
|
|
|
th2 = _tex_format_index(intformat);
|
2009-10-13 02:40:39 -07:00
|
|
|
EINA_LIST_FOREACH(gc->shared->tex.atlas[th][th2], l, pt)
|
2003-09-07 04:24:48 -07:00
|
|
|
{
|
2009-11-06 03:32:23 -08:00
|
|
|
if (_pool_tex_alloc(pt, w, h, u, v, l_after))
|
2009-10-09 05:10:27 -07:00
|
|
|
{
|
2011-06-17 00:47:28 -07:00
|
|
|
gc->shared->tex.atlas[th][th2] =
|
2009-10-13 02:40:39 -07:00
|
|
|
eina_list_remove_list(gc->shared->tex.atlas[th][th2], l);
|
2011-06-17 00:47:28 -07:00
|
|
|
gc->shared->tex.atlas[th][th2] =
|
2009-10-13 02:40:39 -07:00
|
|
|
eina_list_prepend(gc->shared->tex.atlas[th][th2], pt);
|
2009-10-09 05:10:27 -07:00
|
|
|
return pt;
|
|
|
|
}
|
2003-09-07 04:24:48 -07:00
|
|
|
}
|
2009-11-06 03:32:23 -08:00
|
|
|
pt = _pool_tex_new(gc, atlas_w, h, intformat, format);
|
2011-06-17 00:47:28 -07:00
|
|
|
gc->shared->tex.atlas[th][th2] =
|
2009-10-22 01:53:25 -07:00
|
|
|
eina_list_prepend(gc->shared->tex.atlas[th][th2], pt);
|
2009-10-09 05:10:27 -07:00
|
|
|
pt->slot = th;
|
|
|
|
pt->fslot = th2;
|
|
|
|
*u = 0;
|
|
|
|
*v = 0;
|
|
|
|
*l_after = NULL;
|
|
|
|
return pt;
|
|
|
|
}
|
2003-09-07 04:24:48 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
Evas_GL_Texture *
|
2011-03-16 10:32:49 -07:00
|
|
|
evas_gl_common_texture_new(Evas_Engine_GL_Context *gc, RGBA_Image *im)
|
2009-10-09 05:10:27 -07:00
|
|
|
{
|
|
|
|
Evas_GL_Texture *tex;
|
|
|
|
Eina_List *l_after = NULL;
|
|
|
|
int u = 0, v = 0;
|
2003-09-07 04:24:48 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
tex = calloc(1, sizeof(Evas_GL_Texture));
|
|
|
|
if (!tex) return NULL;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2009-10-09 05:10:27 -07:00
|
|
|
tex->gc = gc;
|
|
|
|
tex->references = 1;
|
2010-01-19 06:29:20 -08:00
|
|
|
|
|
|
|
if (im->cache_entry.flags.alpha)
|
|
|
|
{
|
2010-02-17 23:10:28 -08:00
|
|
|
if (gc->shared->info.bgra)
|
2010-08-25 18:41:48 -07:00
|
|
|
tex->pt = _pool_tex_find(gc, im->cache_entry.w + 2,
|
2011-06-17 00:47:28 -07:00
|
|
|
im->cache_entry.h + 1, bgra_ifmt, bgra_fmt,
|
2010-08-25 21:37:43 -07:00
|
|
|
&u, &v, &l_after,
|
|
|
|
gc->shared->info.tune.atlas.max_alloc_size);
|
2010-02-17 23:10:28 -08:00
|
|
|
else
|
2010-08-25 18:41:48 -07:00
|
|
|
tex->pt = _pool_tex_find(gc, im->cache_entry.w + 2,
|
2011-06-17 00:47:28 -07:00
|
|
|
im->cache_entry.h + 1, rgba_ifmt, rgba_fmt,
|
2010-08-25 18:41:48 -07:00
|
|
|
&u, &v, &l_after,
|
2010-08-25 21:37:43 -07:00
|
|
|
gc->shared->info.tune.atlas.max_alloc_size);
|
2010-01-19 06:29:20 -08:00
|
|
|
tex->alpha = 1;
|
|
|
|
}
|
|
|
|
else
|
2010-02-17 23:10:28 -08:00
|
|
|
{
|
|
|
|
if (gc->shared->info.bgra)
|
2011-06-17 00:47:28 -07:00
|
|
|
tex->pt = _pool_tex_find(gc, im->cache_entry.w + 3,
|
2010-08-25 18:41:48 -07:00
|
|
|
im->cache_entry.h + 1, bgr_ifmt, bgr_fmt,
|
|
|
|
&u, &v, &l_after,
|
|
|
|
gc->shared->info.tune.atlas.max_alloc_size);
|
2010-02-17 23:10:28 -08:00
|
|
|
else
|
2010-02-27 02:31:17 -08:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2011-06-17 00:47:28 -07:00
|
|
|
tex->pt = _pool_tex_find(gc, im->cache_entry.w + 3,
|
2010-08-25 18:41:48 -07:00
|
|
|
im->cache_entry.h + 1, rgba_ifmt, rgba_fmt,
|
|
|
|
&u, &v, &l_after,
|
|
|
|
gc->shared->info.tune.atlas.max_alloc_size);
|
2010-02-27 02:31:17 -08:00
|
|
|
#else
|
2011-06-17 00:47:28 -07:00
|
|
|
tex->pt = _pool_tex_find(gc, im->cache_entry.w + 3,
|
2010-08-25 18:41:48 -07:00
|
|
|
im->cache_entry.h + 1, rgb_ifmt, rgb_fmt,
|
|
|
|
&u, &v, &l_after,
|
|
|
|
gc->shared->info.tune.atlas.max_alloc_size);
|
2010-02-27 02:31:17 -08:00
|
|
|
#endif
|
2010-02-17 23:10:28 -08:00
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
if (!tex->pt)
|
2003-09-07 04:24:48 -07:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
free(tex);
|
|
|
|
return NULL;
|
2003-09-07 04:24:48 -07:00
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
tex->x = u + 1;
|
|
|
|
tex->y = v;
|
|
|
|
tex->w = im->cache_entry.w;
|
|
|
|
tex->h = im->cache_entry.h;
|
|
|
|
if (l_after)
|
2011-06-17 00:47:28 -07:00
|
|
|
tex->pt->allocations =
|
2009-10-09 05:10:27 -07:00
|
|
|
eina_list_append_relative_list(tex->pt->allocations, tex, l_after);
|
|
|
|
else
|
2011-06-17 00:47:28 -07:00
|
|
|
tex->pt->allocations =
|
2009-10-09 05:10:27 -07:00
|
|
|
eina_list_prepend(tex->pt->allocations, tex);
|
|
|
|
tex->pt->references++;
|
|
|
|
evas_gl_common_texture_update(tex, im);
|
|
|
|
return tex;
|
2003-09-07 04:24:48 -07:00
|
|
|
}
|
|
|
|
|
2009-11-12 23:22:31 -08:00
|
|
|
static Evas_GL_Texture_Pool *
|
2011-03-16 10:32:49 -07:00
|
|
|
_pool_tex_render_new(Evas_Engine_GL_Context *gc, int w, int h, int intformat, int format)
|
2009-11-12 23:22:31 -08:00
|
|
|
{
|
|
|
|
Evas_GL_Texture_Pool *pt;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2009-11-12 23:22:31 -08:00
|
|
|
pt = calloc(1, sizeof(Evas_GL_Texture_Pool));
|
|
|
|
if (!pt) return NULL;
|
2010-08-25 18:41:48 -07:00
|
|
|
h = _tex_round_slot(gc, h) * gc->shared->info.tune.atlas.slot_size;
|
2009-11-12 23:22:31 -08:00
|
|
|
_tex_adjust(gc, &w, &h);
|
|
|
|
pt->gc = gc;
|
|
|
|
pt->w = w;
|
|
|
|
pt->h = h;
|
|
|
|
pt->intformat = intformat;
|
|
|
|
pt->format = format;
|
2011-08-29 14:52:00 -07:00
|
|
|
pt->dataformat = GL_UNSIGNED_BYTE;
|
2010-01-23 05:49:54 -08:00
|
|
|
pt->render = 1;
|
2009-11-12 23:22:31 -08:00
|
|
|
pt->references = 0;
|
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2009-11-13 03:30:28 -08:00
|
|
|
# ifndef GL_FRAMEBUFFER
|
|
|
|
# define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
|
|
|
|
# endif
|
|
|
|
# ifndef GL_COLOR_ATTACHMENT0
|
|
|
|
# define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
|
|
|
|
# endif
|
2009-11-12 23:22:31 -08:00
|
|
|
#else
|
2009-11-13 03:30:28 -08:00
|
|
|
# ifndef GL_FRAMEBUFFER
|
|
|
|
# define GL_FRAMEBUFFER GL_FRAMEBUFFER_EXT
|
|
|
|
# endif
|
|
|
|
# ifndef GL_COLOR_ATTACHMENT0
|
|
|
|
# define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_EXT
|
|
|
|
# endif
|
2011-06-17 00:47:28 -07:00
|
|
|
#endif
|
2010-08-26 19:02:38 -07:00
|
|
|
texinfo.r.num++;
|
|
|
|
texinfo.r.pix += pt->w * pt->h;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-26 19:02:38 -07:00
|
|
|
_print_tex_count();
|
2011-06-17 00:47:28 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glGenTextures(1, &(pt->texture));
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, pt->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2009-11-12 23:22:31 -08:00
|
|
|
_tex_2d(pt->intformat, w, h, pt->format, pt->dataformat);
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2009-11-21 02:51:51 -08:00
|
|
|
glsym_glGenFramebuffers(1, &(pt->fb));
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2009-11-21 02:51:51 -08:00
|
|
|
glsym_glBindFramebuffer(GL_FRAMEBUFFER, pt->fb);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2009-11-21 02:51:51 -08:00
|
|
|
glsym_glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, pt->texture, 0);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2009-11-21 02:51:51 -08:00
|
|
|
glsym_glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-06-17 00:47:28 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, gc->pipe[0].shader.cur_tex);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2009-11-12 23:22:31 -08:00
|
|
|
return pt;
|
|
|
|
}
|
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
static Evas_GL_Texture_Pool *
|
2011-03-16 10:32:49 -07:00
|
|
|
_pool_tex_native_new(Evas_Engine_GL_Context *gc, int w, int h, int intformat, int format, Evas_GL_Image *im)
|
2010-01-21 00:44:11 -08:00
|
|
|
{
|
|
|
|
Evas_GL_Texture_Pool *pt;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
pt = calloc(1, sizeof(Evas_GL_Texture_Pool));
|
|
|
|
if (!pt) return NULL;
|
|
|
|
pt->gc = gc;
|
2011-06-17 00:47:28 -07:00
|
|
|
#ifdef GL_TEXTURE_RECTANGLE_ARB
|
2010-01-30 18:50:01 -08:00
|
|
|
if (im->native.target == GL_TEXTURE_RECTANGLE_ARB)
|
|
|
|
{
|
|
|
|
printf("REEEEEEEEECT\n");
|
2010-08-26 19:02:38 -07:00
|
|
|
pt->w = w;
|
|
|
|
pt->h = h;
|
2010-01-30 18:50:01 -08:00
|
|
|
}
|
|
|
|
else
|
2011-06-17 00:47:28 -07:00
|
|
|
#endif
|
2010-01-30 18:50:01 -08:00
|
|
|
{
|
2010-02-01 23:00:10 -08:00
|
|
|
// FIXME: handle po2 only textures
|
2010-01-30 18:50:01 -08:00
|
|
|
pt->w = w;
|
|
|
|
pt->h = h;
|
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
pt->intformat = intformat;
|
|
|
|
pt->format = format;
|
|
|
|
pt->dataformat = GL_UNSIGNED_BYTE;
|
|
|
|
pt->references = 0;
|
2010-01-23 05:49:54 -08:00
|
|
|
pt->native = 1;
|
2010-08-26 19:02:38 -07:00
|
|
|
texinfo.n.num++;
|
|
|
|
texinfo.n.pix += pt->w * pt->h;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-26 19:02:38 -07:00
|
|
|
_print_tex_count();
|
2011-06-17 00:47:28 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glGenTextures(1, &(pt->texture));
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(im->native.target, pt->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-01-21 01:42:26 -08:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2010-01-23 21:11:54 -08:00
|
|
|
#else
|
|
|
|
if (im->native.loose)
|
|
|
|
{
|
|
|
|
if (im->native.func.bind)
|
|
|
|
im->native.func.bind(im->native.func.data, im);
|
|
|
|
}
|
2010-01-21 01:42:26 -08:00
|
|
|
#endif
|
2011-06-17 00:47:28 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(im->native.target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(im->native.target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(im->native.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(im->native.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(im->native.target, 0);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(im->native.target, gc->pipe[0].shader.cur_tex);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2010-01-21 00:44:11 -08:00
|
|
|
return pt;
|
|
|
|
}
|
|
|
|
|
2010-08-13 03:34:51 -07:00
|
|
|
static Evas_GL_Texture_Pool *
|
2011-03-16 10:32:49 -07:00
|
|
|
_pool_tex_dynamic_new(Evas_Engine_GL_Context *gc, int w, int h, int intformat, int format)
|
2010-08-13 03:34:51 -07:00
|
|
|
{
|
|
|
|
Evas_GL_Texture_Pool *pt = NULL;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-13 03:34:51 -07:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
|
|
|
int fmt; // EGL_MAP_GL_TEXTURE_RGBA_SEC or EGL_MAP_GL_TEXTURE_RGB_SEC or bust
|
|
|
|
int pixtype; // EGL_MAP_GL_TEXTURE_UNSIGNED_BYTE_SEC or bust
|
2011-09-30 08:51:32 -07:00
|
|
|
int glformat;
|
2010-08-13 03:34:51 -07:00
|
|
|
int attr[] =
|
|
|
|
{
|
|
|
|
EGL_MAP_GL_TEXTURE_WIDTH_SEC, 32,
|
|
|
|
EGL_MAP_GL_TEXTURE_HEIGHT_SEC, 32,
|
|
|
|
EGL_MAP_GL_TEXTURE_FORMAT_SEC, EGL_MAP_GL_TEXTURE_RGBA_SEC,
|
|
|
|
EGL_MAP_GL_TEXTURE_PIXEL_TYPE_SEC, EGL_MAP_GL_TEXTURE_UNSIGNED_BYTE_SEC,
|
|
|
|
EGL_NONE
|
|
|
|
};
|
2010-08-13 04:08:57 -07:00
|
|
|
void *egldisplay;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
if (intformat != format) return NULL;
|
|
|
|
|
|
|
|
switch (intformat)
|
|
|
|
{
|
|
|
|
#ifdef EGL_MAP_GL_TEXTURE_LUMINANCE_SEC
|
|
|
|
case GL_LUMINANCE: attr[5] = EGL_MAP_GL_TEXTURE_LUMINANCE_SEC; break;
|
|
|
|
#endif
|
|
|
|
#ifdef EGL_MAP_GL_TEXTURE_LUMINANCE_ALPHA_SEC
|
|
|
|
case GL_LUMINANCE_ALPHA: attr[5] = EGL_MAP_GL_TEXTURE_LUMINANCE_ALPHA_SEC; break;
|
|
|
|
#endif
|
|
|
|
case GL_RGBA: attr[5] = EGL_MAP_GL_TEXTURE_RGBA_SEC; break;
|
2011-10-10 03:08:29 -07:00
|
|
|
case GL_BGRA: attr[5] = EGL_MAP_GL_TEXTURE_BGRA_SEC; break;
|
2011-09-30 08:51:32 -07:00
|
|
|
default: fprintf(stderr, "unknown format\n"); return NULL;
|
|
|
|
}
|
|
|
|
|
2010-08-13 03:34:51 -07:00
|
|
|
pt = calloc(1, sizeof(Evas_GL_Texture_Pool));
|
|
|
|
if (!pt) return NULL;
|
2010-08-25 21:37:43 -07:00
|
|
|
h = _tex_round_slot(gc, h) * gc->shared->info.tune.atlas.slot_size;
|
2010-08-13 03:34:51 -07:00
|
|
|
_tex_adjust(gc, &w, &h);
|
|
|
|
pt->gc = gc;
|
|
|
|
pt->w = w;
|
|
|
|
pt->h = h;
|
|
|
|
pt->intformat = intformat;
|
|
|
|
pt->format = format;
|
|
|
|
pt->dataformat = GL_UNSIGNED_BYTE;
|
|
|
|
pt->render = 1;
|
|
|
|
pt->references = 0;
|
2010-08-26 19:02:38 -07:00
|
|
|
texinfo.d.num++;
|
|
|
|
texinfo.d.pix += pt->w * pt->h;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-26 19:02:38 -07:00
|
|
|
_print_tex_count();
|
2011-06-17 00:47:28 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glGenTextures(1, &(pt->texture));
|
2010-08-13 03:34:51 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, pt->texture);
|
2010-08-13 03:34:51 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
2010-08-13 03:34:51 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
2010-08-13 03:34:51 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
2010-08-13 03:34:51 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
2010-08-13 03:34:51 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
|
2010-08-13 04:08:57 -07:00
|
|
|
egldisplay = pt->gc->egldisp;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-13 03:34:51 -07:00
|
|
|
attr[1] = pt->w;
|
2010-08-13 04:08:57 -07:00
|
|
|
attr[3] = pt->h;
|
2010-08-13 03:34:51 -07:00
|
|
|
|
2010-08-18 02:53:14 -07:00
|
|
|
// FIXME: seems a bit slower than i'd like - maybe too many flushes?
|
|
|
|
// FIXME: YCbCr no support as yet
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
pt->dyn.img = glsym_eglCreateImage(egldisplay,
|
2011-06-17 00:47:28 -07:00
|
|
|
EGL_NO_CONTEXT,
|
2010-08-13 03:34:51 -07:00
|
|
|
EGL_MAP_GL_TEXTURE_2D_SEC,
|
|
|
|
0, attr);
|
2011-09-30 08:51:32 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2010-08-13 03:34:51 -07:00
|
|
|
if (!pt->dyn.img)
|
|
|
|
{
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, 0);
|
2010-08-13 03:34:51 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glDeleteTextures(1, &(pt->texture));
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
free(pt);
|
|
|
|
return NULL;
|
2010-08-13 03:34:51 -07:00
|
|
|
}
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
if (glsym_eglGetImageAttribSEC(egldisplay,
|
2010-08-13 03:34:51 -07:00
|
|
|
pt->dyn.img,
|
|
|
|
EGL_MAP_GL_TEXTURE_WIDTH_SEC,
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
&(pt->dyn.w)) != EGL_TRUE) goto error;
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
if (glsym_eglGetImageAttribSEC(egldisplay,
|
2010-08-13 03:34:51 -07:00
|
|
|
pt->dyn.img,
|
|
|
|
EGL_MAP_GL_TEXTURE_HEIGHT_SEC,
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
&(pt->dyn.h)) != EGL_TRUE) goto error;
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
if (glsym_eglGetImageAttribSEC(egldisplay,
|
2010-08-13 03:34:51 -07:00
|
|
|
pt->dyn.img,
|
|
|
|
EGL_MAP_GL_TEXTURE_STRIDE_IN_BYTES_SEC,
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
&(pt->dyn.stride)) != EGL_TRUE) goto error;
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
if (glsym_eglGetImageAttribSEC(egldisplay,
|
2010-08-13 03:34:51 -07:00
|
|
|
pt->dyn.img,
|
|
|
|
EGL_MAP_GL_TEXTURE_FORMAT_SEC,
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
&(fmt)) != EGL_TRUE) goto error;
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
if (glsym_eglGetImageAttribSEC(egldisplay,
|
2010-08-13 03:34:51 -07:00
|
|
|
pt->dyn.img,
|
|
|
|
EGL_MAP_GL_TEXTURE_PIXEL_TYPE_SEC,
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
&(pixtype)) != EGL_TRUE) goto error;
|
|
|
|
|
|
|
|
if (pixtype != EGL_MAP_GL_TEXTURE_UNSIGNED_BYTE_SEC) goto error;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, gc->pipe[0].shader.cur_tex);
|
2010-08-13 03:34:51 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2010-09-18 19:10:09 -07:00
|
|
|
#else
|
|
|
|
gc = NULL;
|
|
|
|
w = 0;
|
|
|
|
h = 0;
|
|
|
|
intformat = 0;
|
|
|
|
format = 0;
|
2011-06-17 00:47:28 -07:00
|
|
|
#endif
|
2010-08-13 03:34:51 -07:00
|
|
|
return pt;
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
|
|
|
|
/* ERROR HANDLING */
|
2011-08-24 22:17:43 -07:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
error:
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_eglDestroyImage(egldisplay, pt->dyn.img);
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
pt->dyn.img = NULL;
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, 0);
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glDeleteTextures(1, &(pt->texture));
|
From: Jiyoun Park <jy0703.park@samsung.com>
Subject: [E-devel] [Patch] evas gl engine's texture creation
Hello.
1. _pool_tex_dynamic_new function, it didnt set pt to NULL when secsym_eglCreateImage function failed.
In this case, it returns wrong pt pointer and it has possibility to make crash.
So I add free pt code and return NULL code into _pool_tex_dynamic_new function.
2. I modified eng_image_data_get of gl engine.
If Evas_GL_Image's texture creation failed and evas_gl_image's cache image was droped,
Im->im can be NULL. So I add check code.
Example: evas_gl_common_image_content_hint_set
1) EVAS_IMAGE_CONTENT_HINT_DYNAMIC , it drop cache image
2) if evas_gl_common_texture_dynamic_new failed
3) then, im->im =NULL, im->tex=NULL
In this situation, if application call's evas_object_image_data_get function,
It make crash in evas_cache_image_load_data function.
3. I think function's related with evas_object's engine data have to be return NULL if it failed.
If function's returns null, evas object code can handle error more easily.
But evas object's code was implemented differently each case. Does my suggestion right?
I add engine data null check code to evas_object_image based on upper consumtion.
If it is wrong , the patch code related with evas object image have to be removed.
If it is right , I will survey other evas object type also.
SVN revision: 62775
2011-08-24 21:48:45 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
free(pt);
|
|
|
|
return NULL;
|
2011-08-24 22:17:43 -07:00
|
|
|
#endif
|
2010-08-13 03:34:51 -07:00
|
|
|
}
|
|
|
|
|
2011-01-13 02:41:08 -08:00
|
|
|
void
|
|
|
|
evas_gl_texture_pool_empty(Evas_GL_Texture_Pool *pt)
|
2010-01-19 06:29:20 -08:00
|
|
|
{
|
2011-01-13 02:41:08 -08:00
|
|
|
if (!pt->gc) return;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-26 19:02:38 -07:00
|
|
|
if (pt->format == alpha_fmt)
|
|
|
|
{
|
|
|
|
texinfo.a.num--;
|
|
|
|
texinfo.a.pix -= pt->w * pt->h;
|
|
|
|
}
|
|
|
|
else if (pt->format == lum_fmt)
|
|
|
|
{
|
|
|
|
texinfo.v.num--;
|
|
|
|
texinfo.v.pix -= pt->w * pt->h;
|
|
|
|
}
|
|
|
|
else if (pt->dyn.img)
|
|
|
|
{
|
|
|
|
texinfo.d.num--;
|
|
|
|
texinfo.d.pix -= pt->w * pt->h;
|
|
|
|
}
|
|
|
|
else if (pt->render)
|
|
|
|
{
|
|
|
|
texinfo.r.num--;
|
|
|
|
texinfo.r.pix -= pt->w * pt->h;
|
|
|
|
}
|
|
|
|
else if (pt->native)
|
|
|
|
{
|
|
|
|
texinfo.n.num--;
|
|
|
|
texinfo.n.pix -= pt->w * pt->h;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
texinfo.c.num--;
|
|
|
|
texinfo.c.pix -= pt->w * pt->h;
|
|
|
|
}
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-26 19:02:38 -07:00
|
|
|
_print_tex_count();
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-13 03:34:51 -07:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
|
|
|
if (pt->dyn.img)
|
|
|
|
{
|
2011-11-10 23:43:38 -08:00
|
|
|
if (pt->dyn.checked_out > 0)
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_eglUnmapImageSEC(pt->gc->egldisp, pt->dyn.img);
|
|
|
|
glsym_eglDestroyImage(pt->gc->egldisp, pt->dyn.img);
|
2010-08-13 03:34:51 -07:00
|
|
|
pt->dyn.img = NULL;
|
|
|
|
pt->dyn.data = NULL;
|
|
|
|
pt->dyn.w = 0;
|
|
|
|
pt->dyn.h = 0;
|
|
|
|
pt->dyn.stride = 0;
|
2011-11-10 23:36:15 -08:00
|
|
|
pt->dyn.checked_out = 0;
|
2010-08-13 03:34:51 -07:00
|
|
|
}
|
2011-06-17 00:47:28 -07:00
|
|
|
#endif
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glDeleteTextures(1, &(pt->texture));
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
if (pt->fb)
|
|
|
|
{
|
|
|
|
glsym_glDeleteFramebuffers(1, &(pt->fb));
|
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-01-13 02:41:08 -08:00
|
|
|
pt->fb = 0;
|
|
|
|
}
|
|
|
|
while (pt->allocations)
|
2011-06-17 00:47:28 -07:00
|
|
|
pt->allocations =
|
2011-01-13 02:41:08 -08:00
|
|
|
eina_list_remove_list(pt->allocations, pt->allocations);
|
|
|
|
pt->texture = 0;
|
|
|
|
pt->gc = NULL;
|
|
|
|
pt->w = 0;
|
|
|
|
pt->h = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pt_unref(Evas_GL_Texture_Pool *pt)
|
|
|
|
{
|
2011-09-06 00:56:47 -07:00
|
|
|
if (!pt) return;
|
2011-01-13 02:41:08 -08:00
|
|
|
if (!pt->gc) return;
|
|
|
|
pt->references--;
|
|
|
|
if (pt->references != 0) return;
|
|
|
|
|
|
|
|
if (!((pt->render) || (pt->native)))
|
|
|
|
{
|
|
|
|
if (pt->whole)
|
2011-06-17 00:47:28 -07:00
|
|
|
pt->gc->shared->tex.whole =
|
2011-01-13 02:41:08 -08:00
|
|
|
eina_list_remove(pt->gc->shared->tex.whole, pt);
|
|
|
|
else
|
|
|
|
pt->gc->shared->tex.atlas [pt->slot][pt->fslot] =
|
|
|
|
eina_list_remove(pt->gc->shared->tex.atlas[pt->slot][pt->fslot], pt);
|
2010-02-16 20:21:59 -08:00
|
|
|
}
|
2011-01-13 02:41:08 -08:00
|
|
|
evas_gl_texture_pool_empty(pt);
|
2010-01-19 06:29:20 -08:00
|
|
|
free(pt);
|
|
|
|
}
|
|
|
|
|
2011-09-06 00:56:47 -07:00
|
|
|
static void
|
|
|
|
pt_link(Evas_Engine_GL_Context *gc, Evas_GL_Texture *tex, Evas_GL_Texture_Pool *pt)
|
|
|
|
{
|
|
|
|
gc->shared->tex.whole = eina_list_prepend(gc->shared->tex.whole, pt);
|
|
|
|
pt->slot = -1;
|
|
|
|
pt->fslot = -1;
|
|
|
|
pt->whole = 1;
|
|
|
|
pt->allocations = eina_list_prepend(pt->allocations, tex);
|
|
|
|
pt->references++;
|
|
|
|
}
|
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
Evas_GL_Texture *
|
2011-03-16 10:32:49 -07:00
|
|
|
evas_gl_common_texture_native_new(Evas_Engine_GL_Context *gc, unsigned int w, unsigned int h, int alpha, Evas_GL_Image *im)
|
2010-01-21 00:44:11 -08:00
|
|
|
{
|
|
|
|
Evas_GL_Texture *tex;
|
|
|
|
|
|
|
|
tex = calloc(1, sizeof(Evas_GL_Texture));
|
|
|
|
if (!tex) return NULL;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-01-21 00:44:11 -08:00
|
|
|
tex->gc = gc;
|
|
|
|
tex->references = 1;
|
|
|
|
tex->alpha = alpha;
|
|
|
|
if (alpha)
|
2010-02-17 23:10:28 -08:00
|
|
|
{
|
|
|
|
if (gc->shared->info.bgra)
|
|
|
|
tex->pt = _pool_tex_native_new(gc, w, h, rgba_ifmt, rgba_fmt, im);
|
|
|
|
else
|
|
|
|
tex->pt = _pool_tex_native_new(gc, w, h, rgba_ifmt, rgba_fmt, im);
|
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
else
|
2010-02-17 23:10:28 -08:00
|
|
|
{
|
|
|
|
if (gc->shared->info.bgra)
|
|
|
|
tex->pt = _pool_tex_native_new(gc, w, h, rgb_ifmt, rgb_fmt, im);
|
|
|
|
else
|
|
|
|
tex->pt = _pool_tex_native_new(gc, w, h, rgb_ifmt, rgb_fmt, im);
|
|
|
|
}
|
2010-01-21 00:44:11 -08:00
|
|
|
if (!tex->pt)
|
|
|
|
{
|
|
|
|
free(tex);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
tex->x = 0;
|
|
|
|
tex->y = 0;
|
|
|
|
tex->w = w;
|
|
|
|
tex->h = h;
|
|
|
|
tex->pt->references++;
|
|
|
|
return tex;
|
|
|
|
}
|
|
|
|
|
2009-11-12 23:22:31 -08:00
|
|
|
Evas_GL_Texture *
|
2011-03-16 10:32:49 -07:00
|
|
|
evas_gl_common_texture_render_new(Evas_Engine_GL_Context *gc, unsigned int w, unsigned int h, int alpha)
|
2009-11-12 23:22:31 -08:00
|
|
|
{
|
|
|
|
Evas_GL_Texture *tex;
|
|
|
|
|
|
|
|
tex = calloc(1, sizeof(Evas_GL_Texture));
|
|
|
|
if (!tex) return NULL;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2009-11-12 23:22:31 -08:00
|
|
|
tex->gc = gc;
|
|
|
|
tex->references = 1;
|
2010-01-19 06:29:20 -08:00
|
|
|
tex->alpha = alpha;
|
|
|
|
if (alpha)
|
2010-02-17 23:10:28 -08:00
|
|
|
{
|
|
|
|
if (gc->shared->info.bgra)
|
|
|
|
tex->pt = _pool_tex_render_new(gc, w, h, rgba_ifmt, rgba_fmt);
|
|
|
|
else
|
|
|
|
tex->pt = _pool_tex_render_new(gc, w, h, rgba_ifmt, rgba_fmt);
|
|
|
|
}
|
2010-01-19 06:29:20 -08:00
|
|
|
else
|
2010-02-17 23:10:28 -08:00
|
|
|
{
|
|
|
|
if (gc->shared->info.bgra)
|
|
|
|
tex->pt = _pool_tex_render_new(gc, w, h, rgb_ifmt, rgb_fmt);
|
|
|
|
else
|
|
|
|
tex->pt = _pool_tex_render_new(gc, w, h, rgb_ifmt, rgb_fmt);
|
|
|
|
}
|
2009-11-12 23:22:31 -08:00
|
|
|
if (!tex->pt)
|
|
|
|
{
|
|
|
|
free(tex);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
tex->x = 0;
|
|
|
|
tex->y = 0;
|
|
|
|
tex->w = w;
|
|
|
|
tex->h = h;
|
2011-06-17 00:47:28 -07:00
|
|
|
tex->pt->references++;
|
2010-10-26 00:00:26 -07:00
|
|
|
return tex;
|
2009-11-12 23:22:31 -08:00
|
|
|
}
|
|
|
|
|
2010-08-13 03:34:51 -07:00
|
|
|
Evas_GL_Texture *
|
2011-03-16 10:32:49 -07:00
|
|
|
evas_gl_common_texture_dynamic_new(Evas_Engine_GL_Context *gc, Evas_GL_Image *im)
|
2010-08-13 03:34:51 -07:00
|
|
|
{
|
|
|
|
Evas_GL_Texture *tex;
|
|
|
|
|
|
|
|
tex = calloc(1, sizeof(Evas_GL_Texture));
|
|
|
|
if (!tex) return NULL;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-08-13 03:34:51 -07:00
|
|
|
tex->gc = gc;
|
|
|
|
tex->references = 1;
|
|
|
|
tex->alpha = im->alpha;
|
|
|
|
tex->x = 0;
|
|
|
|
tex->y = 0;
|
|
|
|
tex->w = im->w;
|
|
|
|
tex->h = im->h;
|
|
|
|
if (tex->alpha)
|
|
|
|
{
|
|
|
|
if (gc->shared->info.bgra)
|
2010-08-18 02:53:14 -07:00
|
|
|
tex->pt = _pool_tex_dynamic_new(gc, tex->w, tex->h, bgra_ifmt, bgra_fmt);
|
2010-08-13 03:34:51 -07:00
|
|
|
else
|
2010-08-18 02:53:14 -07:00
|
|
|
tex->pt = _pool_tex_dynamic_new(gc, tex->w, tex->h, bgra_ifmt, bgra_fmt);
|
2010-08-13 03:34:51 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (gc->shared->info.bgra)
|
2010-08-18 02:53:14 -07:00
|
|
|
tex->pt = _pool_tex_dynamic_new(gc, tex->w, tex->h, bgra_ifmt, bgra_fmt);
|
2010-08-13 03:34:51 -07:00
|
|
|
else
|
2010-08-18 02:53:14 -07:00
|
|
|
tex->pt = _pool_tex_dynamic_new(gc, tex->w, tex->h, bgra_ifmt, bgra_fmt);
|
2010-08-13 03:34:51 -07:00
|
|
|
}
|
|
|
|
if (!tex->pt)
|
|
|
|
{
|
|
|
|
free(tex);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-10-04 04:17:11 -07:00
|
|
|
tex->pt->references++;
|
2010-08-13 03:34:51 -07:00
|
|
|
return tex;
|
|
|
|
}
|
|
|
|
|
2003-09-07 04:24:48 -07:00
|
|
|
void
|
2009-10-09 05:10:27 -07:00
|
|
|
evas_gl_common_texture_update(Evas_GL_Texture *tex, RGBA_Image *im)
|
2003-09-07 04:24:48 -07:00
|
|
|
{
|
2010-02-17 23:10:28 -08:00
|
|
|
GLuint fmt;
|
2010-08-25 02:29:56 -07:00
|
|
|
|
2010-01-19 06:29:20 -08:00
|
|
|
if (tex->alpha != im->cache_entry.flags.alpha)
|
|
|
|
{
|
|
|
|
tex->pt->allocations = eina_list_remove(tex->pt->allocations, tex);
|
|
|
|
pt_unref(tex->pt);
|
|
|
|
tex->alpha = im->cache_entry.flags.alpha;
|
|
|
|
if (tex->alpha)
|
2010-02-17 23:10:28 -08:00
|
|
|
{
|
|
|
|
if (tex->gc->shared->info.bgra)
|
|
|
|
tex->pt = _pool_tex_render_new(tex->gc, tex->w, tex->h, bgra_ifmt, bgra_fmt);
|
|
|
|
else
|
|
|
|
tex->pt = _pool_tex_render_new(tex->gc, tex->w, tex->h, rgba_ifmt, rgba_fmt);
|
|
|
|
}
|
2010-01-19 06:29:20 -08:00
|
|
|
else
|
2010-02-17 23:10:28 -08:00
|
|
|
{
|
|
|
|
if (tex->gc->shared->info.bgra)
|
|
|
|
tex->pt = _pool_tex_render_new(tex->gc, tex->w, tex->h, bgr_ifmt, bgr_fmt);
|
|
|
|
else
|
|
|
|
tex->pt = _pool_tex_render_new(tex->gc, tex->w, tex->h, rgb_ifmt, rgb_fmt);
|
|
|
|
}
|
2010-01-19 06:29:20 -08:00
|
|
|
}
|
2010-01-29 02:53:53 -08:00
|
|
|
if (!tex->pt) return;
|
2010-08-25 02:29:56 -07:00
|
|
|
if (!im->image.data) return;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2010-02-17 23:10:28 -08:00
|
|
|
fmt = tex->pt->format;
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->pt->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-06-17 00:47:28 -07:00
|
|
|
#ifdef GL_UNPACK_ROW_LENGTH
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-06-17 00:47:28 -07:00
|
|
|
#endif
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2009-12-19 22:23:13 -08:00
|
|
|
|
2011-02-08 03:41:38 -08:00
|
|
|
// printf("tex upload %ix%i\n", im->cache_entry.w, im->cache_entry.h);
|
2009-10-09 05:10:27 -07:00
|
|
|
// +-+
|
|
|
|
// +-+
|
2011-06-17 00:47:28 -07:00
|
|
|
//
|
|
|
|
_tex_sub_2d(tex->x, tex->y,
|
2009-11-06 03:32:23 -08:00
|
|
|
im->cache_entry.w, im->cache_entry.h,
|
2010-02-17 23:10:28 -08:00
|
|
|
fmt, tex->pt->dataformat,
|
2009-11-06 03:32:23 -08:00
|
|
|
im->image.data);
|
2009-10-09 05:10:27 -07:00
|
|
|
// xxx
|
|
|
|
// xxx
|
|
|
|
// ---
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(tex->x, tex->y + im->cache_entry.h,
|
|
|
|
im->cache_entry.w, 1,
|
2010-02-17 23:10:28 -08:00
|
|
|
fmt, tex->pt->dataformat,
|
2009-11-06 03:32:23 -08:00
|
|
|
im->image.data + ((im->cache_entry.h - 1) * im->cache_entry.w));
|
2009-10-09 05:10:27 -07:00
|
|
|
// xxx
|
|
|
|
// xxx
|
|
|
|
// o
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(tex->x - 1, tex->y + im->cache_entry.h,
|
|
|
|
1, 1,
|
2010-02-17 23:10:28 -08:00
|
|
|
fmt, tex->pt->dataformat,
|
2009-11-06 03:32:23 -08:00
|
|
|
im->image.data + ((im->cache_entry.h - 1) * im->cache_entry.w));
|
2009-10-09 05:10:27 -07:00
|
|
|
// xxx
|
|
|
|
// xxx
|
|
|
|
// o
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(tex->x + im->cache_entry.w, tex->y + im->cache_entry.h,
|
|
|
|
1, 1,
|
2010-02-17 23:10:28 -08:00
|
|
|
fmt, tex->pt->dataformat,
|
2009-11-06 03:32:23 -08:00
|
|
|
im->image.data + ((im->cache_entry.h - 1) * im->cache_entry.w) + (im->cache_entry.w - 1));
|
2011-10-25 02:27:54 -07:00
|
|
|
#ifdef GL_UNPACK_ROW_LENGTH
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, im->cache_entry.w);
|
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
// |xxx
|
|
|
|
// |xxx
|
|
|
|
//
|
|
|
|
_tex_sub_2d(tex->x - 1, tex->y,
|
|
|
|
1, im->cache_entry.h,
|
|
|
|
fmt, tex->pt->dataformat,
|
|
|
|
im->image.data);
|
|
|
|
// xxx|
|
|
|
|
// xxx|
|
|
|
|
//
|
|
|
|
_tex_sub_2d(tex->x + im->cache_entry.w, tex->y,
|
|
|
|
1, im->cache_entry.h,
|
|
|
|
fmt, tex->pt->dataformat,
|
|
|
|
im->image.data + (im->cache_entry.w - 1));
|
|
|
|
#else
|
|
|
|
{
|
|
|
|
DATA32 *tpix, *ps, *pd;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
tpix = alloca(im->cache_entry.h * sizeof(DATA32));
|
|
|
|
pd = tpix;
|
|
|
|
ps = im->image.data;
|
|
|
|
for (i = 0; i < im->cache_entry.h; i++)
|
|
|
|
{
|
|
|
|
*pd = *ps;
|
|
|
|
pd++;
|
|
|
|
ps += im->cache_entry.w;
|
|
|
|
}
|
|
|
|
// |xxx
|
|
|
|
// |xxx
|
|
|
|
//
|
|
|
|
_tex_sub_2d(tex->x - 1, tex->y,
|
|
|
|
1, im->cache_entry.h,
|
|
|
|
fmt, tex->pt->dataformat,
|
|
|
|
tpix);
|
|
|
|
pd = tpix;
|
|
|
|
ps = im->image.data + (im->cache_entry.w - 1);
|
|
|
|
for (i = 0; i < im->cache_entry.h; i++)
|
|
|
|
{
|
|
|
|
*pd = *ps;
|
|
|
|
pd++;
|
|
|
|
ps += im->cache_entry.w;
|
|
|
|
}
|
|
|
|
// xxx|
|
|
|
|
// xxx|
|
|
|
|
//
|
|
|
|
_tex_sub_2d(tex->x + im->cache_entry.w, tex->y,
|
|
|
|
1, im->cache_entry.h,
|
|
|
|
fmt, tex->pt->dataformat,
|
|
|
|
tpix);
|
|
|
|
}
|
|
|
|
#endif
|
2010-08-08 20:27:59 -07:00
|
|
|
if (tex->pt->texture != tex->gc->pipe[0].shader.cur_tex)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->gc->pipe[0].shader.cur_tex);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
}
|
2003-09-07 04:24:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-10-09 05:10:27 -07:00
|
|
|
evas_gl_common_texture_free(Evas_GL_Texture *tex)
|
2003-09-07 04:24:48 -07:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
if (!tex) return;
|
|
|
|
tex->references--;
|
2010-01-29 02:53:53 -08:00
|
|
|
if (tex->references != 0) return;
|
2011-09-06 00:56:47 -07:00
|
|
|
if (tex->double_buffer.pt[0])
|
2010-01-29 02:53:53 -08:00
|
|
|
{
|
2011-09-06 00:56:47 -07:00
|
|
|
tex->double_buffer.pt[0]->allocations = eina_list_remove(tex->double_buffer.pt[0]->allocations, tex);
|
|
|
|
tex->double_buffer.pt[1]->allocations = eina_list_remove(tex->double_buffer.pt[1]->allocations, tex);
|
|
|
|
tex->double_buffer.ptuv[0]->allocations = eina_list_remove(tex->double_buffer.ptuv[0]->allocations, tex);
|
|
|
|
tex->double_buffer.ptuv[1]->allocations = eina_list_remove(tex->double_buffer.ptuv[1]->allocations, tex);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (tex->pt)
|
|
|
|
{
|
|
|
|
tex->pt->allocations = eina_list_remove(tex->pt->allocations, tex);
|
|
|
|
pt_unref(tex->pt);
|
|
|
|
}
|
|
|
|
if (tex->ptu)
|
|
|
|
{
|
|
|
|
tex->ptu->allocations = eina_list_remove(tex->ptu->allocations, tex);
|
|
|
|
pt_unref(tex->ptu);
|
|
|
|
}
|
|
|
|
if (tex->ptv)
|
|
|
|
{
|
|
|
|
tex->ptv->allocations = eina_list_remove(tex->ptv->allocations, tex);
|
|
|
|
pt_unref(tex->ptv);
|
|
|
|
}
|
|
|
|
if (tex->ptuv)
|
|
|
|
{
|
|
|
|
tex->ptuv->allocations = eina_list_remove(tex->ptuv->allocations, tex);
|
|
|
|
pt_unref(tex->ptuv);
|
|
|
|
}
|
2010-01-29 02:53:53 -08:00
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
free(tex);
|
2003-09-07 04:24:48 -07:00
|
|
|
}
|
2006-12-17 07:48:52 -08:00
|
|
|
|
|
|
|
Evas_GL_Texture *
|
2011-03-16 10:32:49 -07:00
|
|
|
evas_gl_common_texture_alpha_new(Evas_Engine_GL_Context *gc, DATA8 *pixels,
|
2010-09-18 16:16:25 -07:00
|
|
|
unsigned int w, unsigned int h, int fh)
|
2006-12-17 07:48:52 -08:00
|
|
|
{
|
|
|
|
Evas_GL_Texture *tex;
|
2009-10-09 05:10:27 -07:00
|
|
|
Eina_List *l_after = NULL;
|
|
|
|
int u = 0, v = 0;
|
|
|
|
|
2006-12-17 07:48:52 -08:00
|
|
|
tex = calloc(1, sizeof(Evas_GL_Texture));
|
|
|
|
if (!tex) return NULL;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2006-12-17 07:48:52 -08:00
|
|
|
tex->gc = gc;
|
2009-10-09 05:10:27 -07:00
|
|
|
tex->references = 1;
|
2010-08-25 21:37:43 -07:00
|
|
|
tex->pt = _pool_tex_find(gc, w + 3, fh, alpha_ifmt, alpha_fmt, &u, &v,
|
2011-06-17 00:47:28 -07:00
|
|
|
&l_after,
|
2010-08-25 18:41:48 -07:00
|
|
|
gc->shared->info.tune.atlas.max_alloc_alpha_size);
|
2009-10-09 05:10:27 -07:00
|
|
|
if (!tex->pt)
|
2006-12-19 06:12:40 -08:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
free(tex);
|
|
|
|
return NULL;
|
2006-12-19 06:12:40 -08:00
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
tex->x = u + 1;
|
|
|
|
tex->y = v;
|
|
|
|
tex->w = w;
|
|
|
|
tex->h = h;
|
|
|
|
if (l_after)
|
2011-06-17 00:47:28 -07:00
|
|
|
tex->pt->allocations =
|
2009-11-13 21:08:00 -08:00
|
|
|
eina_list_append_relative_list(tex->pt->allocations, tex, l_after);
|
2006-12-19 06:12:40 -08:00
|
|
|
else
|
2009-10-09 05:10:27 -07:00
|
|
|
tex->pt->allocations = eina_list_prepend(tex->pt->allocations, tex);
|
|
|
|
tex->pt->references++;
|
|
|
|
evas_gl_common_texture_alpha_update(tex, pixels, w, h, fh);
|
2006-12-17 07:48:52 -08:00
|
|
|
return tex;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-09-18 16:16:25 -07:00
|
|
|
evas_gl_common_texture_alpha_update(Evas_GL_Texture *tex, DATA8 *pixels,
|
2010-09-18 19:10:09 -07:00
|
|
|
unsigned int w, unsigned int h, int fh __UNUSED__)
|
2006-12-17 07:48:52 -08:00
|
|
|
{
|
2010-01-29 02:53:53 -08:00
|
|
|
if (!tex->pt) return;
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->pt->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-06-17 00:47:28 -07:00
|
|
|
#ifdef GL_UNPACK_ROW_LENGTH
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-06-17 00:47:28 -07:00
|
|
|
#endif
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-06-17 00:47:28 -07:00
|
|
|
_tex_sub_2d(tex->x, tex->y, w, h, tex->pt->format, tex->pt->dataformat,
|
2009-11-13 21:08:00 -08:00
|
|
|
pixels);
|
2010-08-08 20:27:59 -07:00
|
|
|
if (tex->pt->texture != tex->gc->pipe[0].shader.cur_tex)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->gc->pipe[0].shader.cur_tex);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
}
|
2006-12-17 07:48:52 -08:00
|
|
|
}
|
2009-10-10 06:24:15 -07:00
|
|
|
|
|
|
|
Evas_GL_Texture *
|
2011-03-16 10:32:49 -07:00
|
|
|
evas_gl_common_texture_yuv_new(Evas_Engine_GL_Context *gc, DATA8 **rows, unsigned int w, unsigned int h)
|
2009-10-10 06:24:15 -07:00
|
|
|
{
|
|
|
|
Evas_GL_Texture *tex;
|
|
|
|
|
|
|
|
tex = calloc(1, sizeof(Evas_GL_Texture));
|
|
|
|
if (!tex) return NULL;
|
2011-06-17 00:47:28 -07:00
|
|
|
|
2009-10-10 06:24:15 -07:00
|
|
|
tex->gc = gc;
|
|
|
|
tex->references = 1;
|
2011-11-13 14:21:58 -08:00
|
|
|
tex->ptu = _pool_tex_new(gc, w / 2 + 1, h / 2 + 1, lum_ifmt, lum_fmt);
|
2010-01-29 02:53:53 -08:00
|
|
|
if (!tex->ptu)
|
|
|
|
{
|
|
|
|
free(tex);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-10-13 02:40:39 -07:00
|
|
|
gc->shared->tex.whole = eina_list_prepend(gc->shared->tex.whole, tex->ptu);
|
2009-10-10 06:24:15 -07:00
|
|
|
tex->ptu->slot = -1;
|
|
|
|
tex->ptu->fslot = -1;
|
|
|
|
tex->ptu->whole = 1;
|
2011-11-13 14:21:58 -08:00
|
|
|
tex->ptv = _pool_tex_new(gc, tex->ptu->w, tex->ptu->h, lum_ifmt, lum_fmt);
|
2010-01-29 02:53:53 -08:00
|
|
|
if (!tex->ptv)
|
|
|
|
{
|
2010-01-30 18:50:01 -08:00
|
|
|
pt_unref(tex->pt);
|
|
|
|
pt_unref(tex->ptu);
|
2010-01-29 02:53:53 -08:00
|
|
|
free(tex);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-10-13 02:40:39 -07:00
|
|
|
gc->shared->tex.whole = eina_list_prepend(gc->shared->tex.whole, tex->ptv);
|
2009-10-10 06:24:15 -07:00
|
|
|
tex->ptv->slot = -1;
|
|
|
|
tex->ptv->fslot = -1;
|
|
|
|
tex->ptv->whole = 1;
|
2011-11-13 14:21:58 -08:00
|
|
|
tex->pt = _pool_tex_new(gc, tex->ptu->w * 2, tex->ptu->h * 2, lum_ifmt, lum_fmt);
|
|
|
|
if (!tex->pt)
|
|
|
|
{
|
|
|
|
free(tex);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
gc->shared->tex.whole = eina_list_prepend(gc->shared->tex.whole, tex->pt);
|
|
|
|
tex->pt->slot = -1;
|
|
|
|
tex->pt->fslot = -1;
|
|
|
|
tex->pt->whole = 1;
|
2009-10-10 06:24:15 -07:00
|
|
|
tex->x = 0;
|
|
|
|
tex->y = 0;
|
|
|
|
tex->w = w;
|
|
|
|
tex->h = h;
|
|
|
|
tex->pt->allocations = eina_list_prepend(tex->pt->allocations, tex);
|
|
|
|
tex->ptu->allocations = eina_list_prepend(tex->ptu->allocations, tex);
|
|
|
|
tex->ptv->allocations = eina_list_prepend(tex->ptv->allocations, tex);
|
|
|
|
tex->pt->references++;
|
|
|
|
tex->ptu->references++;
|
|
|
|
tex->ptv->references++;
|
|
|
|
evas_gl_common_texture_yuv_update(tex, rows, w, h);
|
|
|
|
return tex;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-09-18 16:16:25 -07:00
|
|
|
evas_gl_common_texture_yuv_update(Evas_GL_Texture *tex, DATA8 **rows, unsigned int w, unsigned int h)
|
2009-10-10 06:24:15 -07:00
|
|
|
{
|
2010-01-29 02:53:53 -08:00
|
|
|
if (!tex->pt) return;
|
2009-10-11 20:31:24 -07:00
|
|
|
// FIXME: works on lowest size 4 pixel high buffers. must also be multiple of 2
|
|
|
|
#ifdef GL_UNPACK_ROW_LENGTH
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ROW_LENGTH, rows[1] - rows[0]);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->pt->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->pt->intformat, w, h, tex->pt->format, tex->pt->dataformat);
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(0, 0, w, h, tex->pt->format, tex->pt->dataformat, rows[0]);
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->ptu->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ROW_LENGTH, rows[h + 1] - rows[h]);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->ptu->intformat, w / 2, h / 2, tex->ptu->format, tex->ptu->dataformat);
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(0, 0, w / 2, h / 2, tex->ptu->format, tex->ptu->dataformat, rows[h]);
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->ptv->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ROW_LENGTH, rows[h + (h / 2) + 1] - rows[h + (h / 2)]);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->ptv->intformat, w / 2, h / 2, tex->ptv->format, tex->ptv->dataformat);
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(0, 0, w / 2, h / 2, tex->ptv->format, tex->ptv->dataformat, rows[h + (h / 2)]);
|
2009-10-11 20:31:24 -07:00
|
|
|
#else
|
2011-04-08 21:13:21 -07:00
|
|
|
unsigned int y;
|
2010-08-18 09:08:30 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->pt->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->pt->intformat, w, h, tex->pt->format, tex->pt->dataformat);
|
2011-04-08 21:13:21 -07:00
|
|
|
if ((rows[1] - rows[0]) == (int)w)
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(0, 0, w, h, tex->pt->format, tex->pt->dataformat, rows[0]);
|
2009-10-11 20:31:24 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
for (y = 0; y < h; y++)
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(0, y, w, 1, tex->pt->format, tex->pt->dataformat, rows[y]);
|
2009-10-11 20:31:24 -07:00
|
|
|
}
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->ptu->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->ptu->intformat, w / 2, h / 2, tex->ptu->format, tex->ptu->dataformat);
|
2011-04-08 21:13:21 -07:00
|
|
|
if ((rows[h + 1] - rows[h]) == (int)(w / 2))
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(0, 0, w / 2, h / 2, tex->ptu->format, tex->ptu->dataformat, rows[h]);
|
2009-10-11 20:31:24 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
for (y = 0; y < (h / 2); y++)
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(0, y, w / 2, 1, tex->ptu->format, tex->ptu->dataformat, rows[h + y]);
|
2009-10-11 20:31:24 -07:00
|
|
|
}
|
2011-06-17 00:47:28 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->ptv->texture);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->ptv->intformat, w / 2, h / 2, tex->ptv->format, tex->ptv->dataformat);
|
2011-04-08 21:13:21 -07:00
|
|
|
if ((rows[h + (h / 2) + 1] - rows[h + (h / 2)]) == (int)(w / 2))
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(0, 0, w / 2, h / 2, tex->ptv->format, tex->ptv->dataformat, rows[h + (h / 2)]);
|
2009-10-11 20:31:24 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
for (y = 0; y < (h / 2); y++)
|
2009-11-06 03:32:23 -08:00
|
|
|
_tex_sub_2d(0, y, w / 2, 1, tex->ptv->format, tex->ptv->dataformat, rows[h + (h / 2) + y]);
|
2009-10-11 20:31:24 -07:00
|
|
|
}
|
2011-06-17 00:47:28 -07:00
|
|
|
#endif
|
2010-08-08 20:27:59 -07:00
|
|
|
if (tex->pt->texture != tex->gc->pipe[0].shader.cur_tex)
|
2010-02-16 20:21:59 -08:00
|
|
|
{
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->gc->pipe[0].shader.cur_tex);
|
2010-02-16 20:21:59 -08:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
}
|
2009-10-10 06:24:15 -07:00
|
|
|
}
|
2011-08-23 08:13:40 -07:00
|
|
|
|
2011-08-29 13:56:48 -07:00
|
|
|
static Evas_GL_Texture *
|
|
|
|
_evas_gl_common_texture_y2uv_new(Evas_Engine_GL_Context *gc,
|
|
|
|
unsigned int yw, unsigned int yh,
|
2011-11-13 14:21:58 -08:00
|
|
|
Eina_Bool uv2w, Eina_Bool uv2h,
|
2011-09-04 14:15:04 -07:00
|
|
|
GLenum y_ifmt, GLenum y_fmt,
|
2011-09-30 08:51:32 -07:00
|
|
|
GLenum uv_ifmt, GLenum uv_fmt,
|
|
|
|
Eina_Bool dynamic)
|
2011-08-23 08:13:40 -07:00
|
|
|
{
|
2011-09-06 00:56:47 -07:00
|
|
|
Evas_GL_Texture_Pool *pt[2] = { NULL, NULL };
|
|
|
|
Evas_GL_Texture_Pool *ptuv[2] = { NULL, NULL };
|
2011-08-23 08:13:40 -07:00
|
|
|
Evas_GL_Texture *tex;
|
2011-11-13 14:21:58 -08:00
|
|
|
unsigned int uvw, uvh;
|
|
|
|
|
|
|
|
uvw = uv2w ? yw / 2 + 1 : yw + 1;
|
|
|
|
uvh = uv2h ? yh / 2 + 1 : yh + 1;
|
2011-08-23 08:13:40 -07:00
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
if (!dynamic)
|
|
|
|
{
|
2011-11-13 14:21:58 -08:00
|
|
|
ptuv[0] = _pool_tex_new(gc, uvw, uvh, uv_ifmt, uv_fmt);
|
|
|
|
ptuv[1] = _pool_tex_new(gc, uvw, uvh, uv_ifmt, uv_fmt);
|
|
|
|
|
|
|
|
if (ptuv[0] && ptuv[1])
|
|
|
|
{
|
|
|
|
pt[0] = _pool_tex_new(gc,
|
|
|
|
ptuv[0]->w * (uv2w ? 2 : 1),
|
|
|
|
ptuv[0]->h * (uv2h ? 2 : 1),
|
|
|
|
y_ifmt, y_fmt);
|
|
|
|
pt[1] = _pool_tex_new(gc,
|
|
|
|
ptuv[1]->w * (uv2w ? 2 : 1),
|
|
|
|
ptuv[1]->h * (uv2h ? 2 : 1),
|
|
|
|
y_ifmt, y_fmt);
|
|
|
|
}
|
2011-09-30 08:51:32 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-11-13 14:21:58 -08:00
|
|
|
ptuv[0] = _pool_tex_dynamic_new(gc, uvw, uvh, uv_ifmt, uv_fmt);
|
|
|
|
ptuv[1] = _pool_tex_dynamic_new(gc, uvw, uvh, uv_ifmt, uv_fmt);
|
|
|
|
|
|
|
|
if (ptuv[0] && ptuv[1])
|
|
|
|
{
|
|
|
|
pt[0] = _pool_tex_dynamic_new(gc,
|
|
|
|
ptuv[0]->w * (uv2w ? 2 : 1),
|
|
|
|
ptuv[0]->h * (uv2h ? 2 : 1),
|
|
|
|
y_ifmt, y_fmt);
|
|
|
|
pt[1] = _pool_tex_dynamic_new(gc,
|
|
|
|
ptuv[1]->w * (uv2w ? 2 : 1),
|
|
|
|
ptuv[1]->h * (uv2h ? 2 : 1),
|
|
|
|
y_ifmt, y_fmt);
|
|
|
|
}
|
2011-09-30 08:51:32 -07:00
|
|
|
}
|
2011-09-06 00:56:47 -07:00
|
|
|
|
|
|
|
if (!pt[0] || !pt[1] || !ptuv[0] || !ptuv[1])
|
|
|
|
goto on_error;
|
|
|
|
|
2011-11-13 14:21:58 -08:00
|
|
|
INF("YUV [%i, %i] => Y[%i, %i], UV[%i, %i]",
|
|
|
|
yw, yh,
|
|
|
|
pt[0]->w, pt[0]->h,
|
|
|
|
ptuv[0]->w, ptuv[0]->h);
|
2011-08-23 08:13:40 -07:00
|
|
|
tex = calloc(1, sizeof(Evas_GL_Texture));
|
2011-09-06 00:56:47 -07:00
|
|
|
if (!tex)
|
|
|
|
goto on_error;
|
2011-08-23 08:13:40 -07:00
|
|
|
|
|
|
|
tex->gc = gc;
|
|
|
|
tex->references = 1;
|
2011-09-06 00:56:47 -07:00
|
|
|
tex->pt = pt[0];
|
|
|
|
tex->ptuv = ptuv[0];
|
2011-09-30 08:51:32 -07:00
|
|
|
tex->dyn = dynamic;
|
2011-09-06 00:56:47 -07:00
|
|
|
|
|
|
|
pt_link(gc, tex, pt[0]);
|
|
|
|
pt_link(gc, tex, pt[1]);
|
|
|
|
pt_link(gc, tex, ptuv[0]);
|
|
|
|
pt_link(gc, tex, ptuv[1]);
|
|
|
|
|
2011-08-23 08:13:40 -07:00
|
|
|
tex->x = 0;
|
|
|
|
tex->y = 0;
|
2011-08-29 13:56:48 -07:00
|
|
|
tex->w = yw;
|
|
|
|
tex->h = yh;
|
2011-09-06 00:56:47 -07:00
|
|
|
tex->double_buffer.source = 0;
|
|
|
|
memcpy(tex->double_buffer.pt, pt, sizeof (Evas_GL_Texture_Pool *) * 2);
|
|
|
|
memcpy(tex->double_buffer.ptuv, ptuv, sizeof (Evas_GL_Texture_Pool *) * 2);
|
|
|
|
|
2011-08-29 13:56:48 -07:00
|
|
|
return tex;
|
2011-09-06 00:56:47 -07:00
|
|
|
|
|
|
|
on_error:
|
|
|
|
pt_unref(pt[0]);
|
|
|
|
pt_unref(pt[1]);
|
|
|
|
pt_unref(ptuv[0]);
|
|
|
|
pt_unref(ptuv[1]);
|
|
|
|
return NULL;
|
2011-08-29 13:56:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Evas_GL_Texture *
|
|
|
|
evas_gl_common_texture_yuy2_new(Evas_Engine_GL_Context *gc, DATA8 **rows, unsigned int w, unsigned int h)
|
|
|
|
{
|
|
|
|
Evas_GL_Texture *tex;
|
|
|
|
|
2011-11-13 14:21:58 -08:00
|
|
|
tex = _evas_gl_common_texture_y2uv_new(gc, w, h, EINA_TRUE, EINA_FALSE, lum_alpha_ifmt, lum_alpha_fmt, rgba8_ifmt, rgba8_fmt, 0);
|
2011-08-23 08:13:40 -07:00
|
|
|
evas_gl_common_texture_yuy2_update(tex, rows, w, h);
|
|
|
|
return tex;
|
|
|
|
}
|
|
|
|
|
2011-08-29 13:56:48 -07:00
|
|
|
Evas_GL_Texture *
|
|
|
|
evas_gl_common_texture_nv12_new(Evas_Engine_GL_Context *gc, DATA8 **rows, unsigned int w, unsigned int h)
|
|
|
|
{
|
|
|
|
Evas_GL_Texture *tex;
|
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2011-11-13 14:21:58 -08:00
|
|
|
tex = _evas_gl_common_texture_y2uv_new(gc, w, h, EINA_TRUE, EINA_TRUE, lum_ifmt, lum_fmt, lum_alpha_ifmt, lum_alpha_fmt, 1);
|
2011-09-30 08:51:32 -07:00
|
|
|
if (!tex)
|
|
|
|
#endif
|
2011-11-13 14:21:58 -08:00
|
|
|
tex = _evas_gl_common_texture_y2uv_new(gc, w, h, EINA_TRUE, EINA_TRUE, lum_ifmt, lum_fmt, lum_alpha_ifmt, lum_alpha_fmt, 0);
|
2011-09-30 08:51:32 -07:00
|
|
|
|
2011-08-29 13:56:48 -07:00
|
|
|
evas_gl_common_texture_nv12_update(tex, rows, w, h);
|
|
|
|
return tex;
|
|
|
|
}
|
|
|
|
|
|
|
|
Evas_GL_Texture *
|
|
|
|
evas_gl_common_texture_nv12tiled_new(Evas_Engine_GL_Context *gc, DATA8 **rows, unsigned int w, unsigned int h)
|
|
|
|
{
|
2011-09-30 08:51:32 -07:00
|
|
|
Evas_GL_Texture *tex = NULL;
|
|
|
|
|
|
|
|
#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
|
2011-11-13 14:21:58 -08:00
|
|
|
tex = _evas_gl_common_texture_y2uv_new(gc, w, h, EINA_TRUE, EINA_TRUE, lum_ifmt, lum_fmt, lum_alpha_ifmt, lum_alpha_fmt, 1);
|
2011-09-30 08:51:32 -07:00
|
|
|
if (!tex)
|
|
|
|
#endif
|
2011-11-13 14:21:58 -08:00
|
|
|
tex = _evas_gl_common_texture_y2uv_new(gc, w, h, EINA_TRUE, EINA_TRUE, lum_ifmt, lum_fmt, lum_alpha_ifmt, lum_alpha_fmt, 0);
|
2011-08-29 13:56:48 -07:00
|
|
|
|
|
|
|
evas_gl_common_texture_nv12tiled_update(tex, rows, w, h);
|
|
|
|
return tex;
|
|
|
|
}
|
|
|
|
|
2011-08-23 08:13:40 -07:00
|
|
|
void
|
|
|
|
evas_gl_common_texture_yuy2_update(Evas_GL_Texture *tex, DATA8 **rows, unsigned int w, unsigned int h)
|
|
|
|
{
|
|
|
|
if (!tex->pt) return;
|
|
|
|
// FIXME: works on lowest size 4 pixel high buffers. must also be multiple of 2
|
2011-08-29 13:56:48 -07:00
|
|
|
unsigned int y;
|
|
|
|
|
2011-09-06 00:56:47 -07:00
|
|
|
tex->double_buffer.source = 1 - tex->double_buffer.source;
|
|
|
|
tex->pt = tex->double_buffer.pt[tex->double_buffer.source];
|
|
|
|
tex->ptuv = tex->double_buffer.ptuv[tex->double_buffer.source];
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
2011-08-29 13:56:48 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->pt->texture);
|
2011-08-29 13:56:48 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->pt->intformat, w, h, tex->pt->format, tex->pt->dataformat);
|
2011-08-29 13:56:48 -07:00
|
|
|
if ((rows[1] - rows[0]) == (int)w * 4)
|
|
|
|
_tex_sub_2d(0, 0, w, h, tex->pt->format, tex->pt->dataformat, rows[0]);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (y = 0; y < h; y++)
|
|
|
|
_tex_sub_2d(0, y, w, 1, tex->pt->format, tex->pt->dataformat, rows[y]);
|
|
|
|
}
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->ptuv->texture);
|
2011-08-29 13:56:48 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->ptuv->intformat, w / 2, h, tex->ptuv->format, tex->ptuv->dataformat);
|
2011-11-13 14:21:58 -08:00
|
|
|
#if 0
|
|
|
|
/*
|
|
|
|
FIXME: this piece of code doesn't work anymore since texture width
|
|
|
|
is not anymore exactly w / 2. I don't understand why.
|
|
|
|
*/
|
2011-08-29 13:56:48 -07:00
|
|
|
if ((rows[1] - rows[0]) == (int)(w * 2))
|
|
|
|
_tex_sub_2d(0, 0, w / 2, h, tex->ptuv->format, tex->ptuv->dataformat, rows[0]);
|
|
|
|
else
|
2011-11-13 14:21:58 -08:00
|
|
|
#endif
|
2011-08-29 13:56:48 -07:00
|
|
|
{
|
|
|
|
for (y = 0; y < h; y++)
|
|
|
|
_tex_sub_2d(0, y, w / 2, 1, tex->ptuv->format, tex->ptuv->dataformat, rows[y]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tex->pt->texture != tex->gc->pipe[0].shader.cur_tex)
|
|
|
|
{
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->gc->pipe[0].shader.cur_tex);
|
2011-08-29 13:56:48 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
evas_gl_common_texture_nv12_update(Evas_GL_Texture *tex, DATA8 **rows, unsigned int w, unsigned int h)
|
|
|
|
{
|
|
|
|
if (!tex->pt) return;
|
2011-09-06 00:56:47 -07:00
|
|
|
|
|
|
|
tex->double_buffer.source = 1 - tex->double_buffer.source;
|
|
|
|
tex->pt = tex->double_buffer.pt[tex->double_buffer.source];
|
|
|
|
tex->ptuv = tex->double_buffer.ptuv[tex->double_buffer.source];
|
|
|
|
|
2011-08-29 13:56:48 -07:00
|
|
|
// FIXME: works on lowest size 4 pixel high buffers. must also be multiple of 2
|
2011-08-23 08:13:40 -07:00
|
|
|
#ifdef GL_UNPACK_ROW_LENGTH
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ROW_LENGTH, rows[1] - rows[0]);
|
2011-08-23 08:13:40 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
2011-08-23 08:13:40 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->pt->texture);
|
2011-08-23 08:13:40 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->pt->intformat, w, h, tex->pt->format, tex->pt->dataformat);
|
2011-08-23 08:13:40 -07:00
|
|
|
_tex_sub_2d(0, 0, w, h, tex->pt->format, tex->pt->dataformat, rows[0]);
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->ptuv->texture);
|
2011-08-23 08:13:40 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ROW_LENGTH, rows[h + 1] - rows[h]);
|
2011-08-23 08:13:40 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->ptuv->intformat, w / 2, h / 2, tex->ptuv->format, tex->ptuv->dataformat);
|
2011-08-29 13:56:48 -07:00
|
|
|
_tex_sub_2d(0, 0, w / 2, h / 2, tex->ptuv->format, tex->ptuv->dataformat, rows[h]);
|
2011-08-23 08:13:40 -07:00
|
|
|
#else
|
|
|
|
unsigned int y;
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
2011-08-23 08:13:40 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->pt->texture);
|
2011-08-23 08:13:40 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->pt->intformat, w, h, tex->pt->format, tex->pt->dataformat);
|
2011-08-29 13:56:48 -07:00
|
|
|
if ((rows[1] - rows[0]) == (int)w)
|
2011-08-23 08:13:40 -07:00
|
|
|
_tex_sub_2d(0, 0, w, h, tex->pt->format, tex->pt->dataformat, rows[0]);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (y = 0; y < h; y++)
|
|
|
|
_tex_sub_2d(0, y, w, 1, tex->pt->format, tex->pt->dataformat, rows[y]);
|
|
|
|
}
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->ptuv->texture);
|
2011-08-23 08:13:40 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
2011-09-05 07:58:18 -07:00
|
|
|
_tex_2d(tex->ptuv->intformat, w / 2, h / 2, tex->ptuv->format, tex->ptuv->dataformat);
|
2011-08-29 13:56:48 -07:00
|
|
|
if ((rows[h + 1] - rows[h]) == (int)(w / 2))
|
|
|
|
_tex_sub_2d(0, 0, w / 2, h / 2, tex->ptuv->format, tex->ptuv->dataformat, rows[h]);
|
2011-08-23 08:13:40 -07:00
|
|
|
else
|
|
|
|
{
|
2011-08-29 13:56:48 -07:00
|
|
|
for (y = 0; y < (h / 2); y++)
|
|
|
|
_tex_sub_2d(0, y, w / 2, 1, tex->ptuv->format, tex->ptuv->dataformat, rows[h + y]);
|
2011-08-23 08:13:40 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (tex->pt->texture != tex->gc->pipe[0].shader.cur_tex)
|
|
|
|
{
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->gc->pipe[0].shader.cur_tex);
|
2011-08-23 08:13:40 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
}
|
|
|
|
}
|
2011-08-29 13:56:48 -07:00
|
|
|
|
|
|
|
void
|
|
|
|
evas_gl_common_texture_nv12tiled_update(Evas_GL_Texture *tex, DATA8 **rows, unsigned int w, unsigned int h)
|
|
|
|
{
|
2011-09-04 14:15:04 -07:00
|
|
|
unsigned int mb_x, mb_y, mb_w, mb_h;
|
|
|
|
unsigned int base_h;
|
|
|
|
|
2011-08-29 13:56:48 -07:00
|
|
|
if (!tex->pt) return;
|
2011-09-04 14:15:04 -07:00
|
|
|
|
2011-09-06 00:56:47 -07:00
|
|
|
tex->double_buffer.source = 1 - tex->double_buffer.source;
|
|
|
|
tex->pt = tex->double_buffer.pt[tex->double_buffer.source];
|
|
|
|
tex->ptuv = tex->double_buffer.ptuv[tex->double_buffer.source];
|
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
mb_w = w / 64 + (w % 64 ? 1 : 0);
|
|
|
|
mb_h = h / 32 + (h % 32 ? 1 : 0);
|
|
|
|
|
|
|
|
#if ( defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX) )
|
|
|
|
if (tex->dyn)
|
|
|
|
{
|
|
|
|
char *texture_addr;
|
|
|
|
char *tmp;
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
texture_addr = glsym_eglMapImageSEC(tex->gc->egldisp, tex->pt->dyn.img);
|
2011-09-30 08:51:32 -07:00
|
|
|
|
|
|
|
/* Iterate each Y macroblock like we do in evas_convert_yuv.c */
|
|
|
|
for (mb_y = 0; mb_y < (mb_h >> 1); mb_y++)
|
|
|
|
{
|
|
|
|
int step = 2;
|
|
|
|
int offset = 0;
|
|
|
|
int x = 0;
|
|
|
|
int rmb_x = 0;
|
|
|
|
int ry[2];
|
|
|
|
|
|
|
|
ry[0] = mb_y * 2 * 32 * tex->pt->dyn.stride;
|
|
|
|
ry[1] = ry[0] + 32 * tex->pt->dyn.stride;
|
|
|
|
|
|
|
|
for (mb_x = 0; mb_x < mb_w * 2; mb_x++, rmb_x += 64 * 32)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
tmp = texture_addr + x + ry[offset];
|
|
|
|
|
|
|
|
for (i = 0; i < 32 * 64; i += 64, tmp += tex->pt->dyn.stride)
|
|
|
|
memcpy(tmp, rows[mb_y] + rmb_x + i, 64);
|
|
|
|
|
|
|
|
step++;
|
|
|
|
if ((step & 0x3) == 0)
|
|
|
|
{
|
|
|
|
offset = 1 - offset;
|
|
|
|
x -= 64;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
x += 64;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mb_h & 0x1)
|
|
|
|
{
|
|
|
|
int rmb_x = 0;
|
|
|
|
int x = 0;
|
|
|
|
int ry;
|
|
|
|
|
|
|
|
ry = mb_y * 2 * 32 * tex->pt->dyn.stride;
|
|
|
|
|
|
|
|
for (mb_x = 0; mb_x < mb_w; mb_x++, x += 64, rmb_x += 64 * 32)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
tmp = texture_addr + x + ry;
|
|
|
|
|
|
|
|
for (i = 0; i < 32 * 64; i += 64, tmp += tex->pt->dyn.stride)
|
|
|
|
memcpy(tmp, rows[mb_y] + rmb_x + i, 64);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_eglUnmapImageSEC(tex->gc->egldisp, tex->pt->dyn.img);
|
2011-09-30 08:51:32 -07:00
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
texture_addr = glsym_eglMapImageSEC(tex->gc->egldisp, tex->ptuv->dyn.img);
|
2011-09-30 08:51:32 -07:00
|
|
|
|
|
|
|
/* Iterate each UV macroblock like we do in evas_convert_yuv.c */
|
|
|
|
base_h = (mb_h >> 1) + (mb_h & 0x1);
|
|
|
|
|
|
|
|
/* h is always a multiple of 32 */
|
|
|
|
mb_h = h / 2;
|
|
|
|
mb_h = (mb_h / 32 + (mb_h % 32 ? 1 : 0));
|
|
|
|
|
|
|
|
mb_w = w / 2;
|
|
|
|
mb_w = (mb_w / 32 + (mb_w % 32 ? 1 : 0));
|
|
|
|
|
|
|
|
for (mb_y = 0; mb_y < (mb_h >> 1); mb_y++)
|
|
|
|
{
|
|
|
|
int step = 2;
|
|
|
|
int offset = 0;
|
|
|
|
int x = 0;
|
|
|
|
int rmb_x = 0;
|
|
|
|
int ry[2];
|
|
|
|
|
|
|
|
ry[0] = mb_y * 2 * 32 * tex->ptuv->dyn.stride;
|
|
|
|
ry[1] = ry[0] + 32 * tex->ptuv->dyn.stride;
|
|
|
|
|
|
|
|
for (mb_x = 0; mb_x < mb_w * 4; mb_x++, rmb_x += 64 * 32)
|
|
|
|
{
|
|
|
|
unsigned int i = 0;
|
|
|
|
|
|
|
|
tmp = texture_addr + x + ry[offset];
|
|
|
|
|
|
|
|
for (i = 0; i < 32 * 64; i += 64, tmp += tex->ptuv->dyn.stride)
|
|
|
|
memcpy(tmp, rows[mb_y + base_h] + rmb_x + i, 64);
|
|
|
|
|
|
|
|
step++;
|
|
|
|
if ((step & 0x3) == 0)
|
|
|
|
{
|
|
|
|
offset = 1 - offset;
|
|
|
|
x -= 64;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
x += 64;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mb_h & 0x1)
|
|
|
|
{
|
|
|
|
int rmb_x = 0;
|
|
|
|
int x = 0;
|
|
|
|
int ry;
|
|
|
|
|
|
|
|
ry = mb_y * 2 * 32 * tex->ptuv->dyn.stride;
|
|
|
|
|
|
|
|
for (mb_x = 0; mb_x < mb_w * 2; mb_x++, x += 64, rmb_x += 64 * 32)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
tmp = texture_addr + x + ry;
|
|
|
|
|
|
|
|
/* It has horizontaly half the pixels, but they are double the size*/
|
|
|
|
for (i = 0; i < 32 * 64; i += 64, tmp += tex->ptuv->dyn.stride)
|
|
|
|
memcpy(tmp, rows[mb_y + base_h] + rmb_x + i, 64);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_eglUnmapImageSEC(tex->gc->egldisp, tex->ptuv->dyn.img);
|
2011-09-30 08:51:32 -07:00
|
|
|
return ;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
2011-09-04 14:15:04 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->pt->texture);
|
2011-09-06 00:56:47 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
|
2011-09-05 07:58:18 -07:00
|
|
|
// We are telling the driver to not swizzle back the buffer as we are going to replace all pixel
|
|
|
|
_tex_2d(tex->pt->intformat, w, h, tex->pt->format, tex->pt->dataformat);
|
|
|
|
|
2011-09-04 14:15:04 -07:00
|
|
|
/* Iterate each Y macroblock like we do in evas_convert_yuv.c */
|
|
|
|
for (mb_y = 0; mb_y < (mb_h >> 1); mb_y++)
|
|
|
|
{
|
|
|
|
int step = 2;
|
2011-09-30 08:51:32 -07:00
|
|
|
int offset = 0;
|
|
|
|
int x = 0;
|
|
|
|
int rmb_x = 0;
|
|
|
|
int ry[2];
|
|
|
|
|
|
|
|
ry[0] = mb_y * 2 * 32;
|
|
|
|
ry[1] = ry[0] + 32;
|
|
|
|
|
|
|
|
for (mb_x = 0; mb_x < mb_w * 2; mb_x++, rmb_x += 64 * 32)
|
|
|
|
{
|
|
|
|
_tex_sub_2d(x, ry[offset], 64, 32, tex->pt->format, tex->pt->dataformat, rows[mb_y] + rmb_x);
|
|
|
|
|
|
|
|
step++;
|
|
|
|
if ((step & 0x3) == 0)
|
|
|
|
{
|
|
|
|
offset = 1 - offset;
|
|
|
|
x -= 64;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
x += 64;
|
|
|
|
}
|
|
|
|
}
|
2011-09-04 14:15:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (mb_h & 0x1)
|
|
|
|
{
|
|
|
|
int rmb_x = 0;
|
2011-09-30 08:51:32 -07:00
|
|
|
int x = 0;
|
|
|
|
int ry;
|
2011-09-04 14:15:04 -07:00
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
ry = mb_y * 2 * 32;
|
2011-09-04 14:15:04 -07:00
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
for (mb_x = 0; mb_x < mb_w; mb_x++, x += 64, rmb_x += 64 * 32)
|
|
|
|
_tex_sub_2d(x, ry, 64, 32, tex->pt->format, tex->pt->dataformat, rows[mb_y] + rmb_x);
|
2011-09-04 14:15:04 -07:00
|
|
|
}
|
|
|
|
|
I'm attaching a patch for the initial version of the GL Fastpath
addition to evas gl backend.
Working on different mobile devices, we've noticed that the cost of context
switch (MakeCurrent) in GL can be very expensive depending on the driver
implementation. To minimize the poorly written driver's context switch
overhead, I've implemented a state tracking layer on top of the driver
implemented GL.
Essentially, this layer wraps all the GL/Glue(GLX/EGL) APIs and manages its own
state changes. Internally, only one real GL context is created and logical
contexts are created every time a user requests context creation. The logical
contexts keep track of its states and sets only the necessary states
(the ones that are different than the current ones)
when there is a MakeCurrent request. The real MakeCurrent gets called when
there is a Surface/Window change request.
The GL library is dlopened and all the APIs are dlsym'ed and wrapped
accordingly. All the GL functions are in evas_gl_core.{h,c}.
Here's a very simply flow of the code.
- all the APIs are exported as function pointers (*glsym_glBegin),
(*glsm_eglCreatContext), and etc.
- all the native GL/Glue(GLX/EGL) APIs are dlsym'ed as _sym_glBegin,
_sym_eglCreateContext, and etc.
- all the fastpath APIs are implmemnted as fpgl_glBegin,
fpgl_eglCreateContext, and etc.
- if faspath is seletected, the exported APIs are set accordingly
ie. glsym_glBegin = fpgl_glBegin;
- default mode is the regular gl symbols are directly set.
ie. glsym_glBegin = _sym_glBegin;
I have an Environment variable where you can set it to three different Modes
EVAS_GL_FASTPATH = 0 // Default mode. Regular GL symbols are directly loaded
EVAS_GL_FASTPATH = 1 // Fastpath mode. Takes the path described above.
EVAS_GL_FASTPATH = 2 // Wrapped mode. All the regular GL functions are
wrapped once. This can be used for various
purposes
Since all the GL symbols are now loaded in this library, I took out all
the gl symbol loading parts in the evas gl backend as you'll see in the patch.
The changes to the engine and the backend itself is pretty minor.
There are still some known issues to hammer out but I thought we're at a good
place for an initial version so that my source doesn't diverge too much.
Known Issues and To Do's
* Current GL Fastpath version doesn't support multiple threads. Instead of
having one global real context, I would need to do it for each thread. I'll
get on this soon.
* Issues running Evas GL on certain conditions. When running the elementary
test (with gl engine), if you run ELMGLview test that runs in ON_DEMAND mode,
everything works fine. BUT, when you run the ELMGLView test in ALWAYS
mode, the subsequent elm tests shows blank screen. When you destroy the
GLView window, everything else comes on fine.
* Resource protection code. This actually applies to Evas GL code in general
as well. Since all the resources are shared among all the contexts that get
created, I would like to eventually have a resource protecting mechanism that
prevents access to resources outside of its context unless specifically
specified.
I'm attaching three files
- evas_gl_core.h, evas_gl_core.c, fastpath.patch
To get the code running...
- copy evas_gl_core.{c,h} to src/modules/engine/gl_common/
- apply the fastpath.patch
- compile/install evas
- to run with fastpath GL (ie. % EVAS_GL_FASTPATH=1 ./evasgl_sample1)
SVN revision: 65891
2011-12-05 00:54:14 -08:00
|
|
|
glsym_glBindTexture(GL_TEXTURE_2D, tex->ptuv->texture);
|
2011-09-04 14:15:04 -07:00
|
|
|
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
|
|
|
|
|
2011-09-05 08:21:23 -07:00
|
|
|
_tex_2d(tex->ptuv->intformat, w, h, tex->ptuv->format, tex->ptuv->dataformat);
|
2011-09-05 07:58:18 -07:00
|
|
|
|
2011-09-04 14:15:04 -07:00
|
|
|
/* Iterate each UV macroblock like we do in evas_convert_yuv.c */
|
|
|
|
base_h = (mb_h >> 1) + (mb_h & 0x1);
|
2011-09-30 08:51:32 -07:00
|
|
|
|
|
|
|
/* h is always a multiple of 32 */
|
|
|
|
mb_h = h / 2;
|
|
|
|
mb_h = (mb_h / 32 + (mb_h % 32 ? 1 : 0));
|
|
|
|
|
|
|
|
mb_w = w / 2;
|
|
|
|
mb_w = (mb_w / 32 + (mb_w % 32 ? 1 : 0));
|
|
|
|
|
|
|
|
for (mb_y = 0; mb_y < (mb_h >> 1); mb_y++)
|
2011-09-04 14:15:04 -07:00
|
|
|
{
|
|
|
|
int step = 2;
|
2011-09-30 08:51:32 -07:00
|
|
|
int offset = 0;
|
|
|
|
int x = 0;
|
|
|
|
int rmb_x = 0;
|
|
|
|
int ry[2];
|
2011-09-04 14:15:04 -07:00
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
ry[0] = mb_y * 2 * 32;
|
|
|
|
ry[1] = ry[0] + 32;
|
2011-09-04 14:15:04 -07:00
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
for (mb_x = 0; mb_x < mb_w * 2; mb_x++, rmb_x += 64 * 32)
|
|
|
|
{
|
2011-09-04 14:15:04 -07:00
|
|
|
_tex_sub_2d(x, ry[offset], 32, 32,
|
|
|
|
tex->ptuv->format, tex->ptuv->dataformat,
|
|
|
|
rows[mb_y + base_h] + rmb_x);
|
|
|
|
step++;
|
|
|
|
if ((step & 0x3) == 0)
|
|
|
|
{
|
|
|
|
offset = 1 - offset;
|
|
|
|
x -= 32;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
x += 32;
|
|
|
|
}
|
2011-09-30 08:51:32 -07:00
|
|
|
}
|
2011-09-04 14:15:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (mb_h & 0x1)
|
|
|
|
{
|
|
|
|
int rmb_x = 0;
|
2011-09-30 08:51:32 -07:00
|
|
|
int x = 0;
|
|
|
|
int ry;
|
2011-09-04 14:15:04 -07:00
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
ry = mb_y * 2 * 32;
|
2011-09-04 14:15:04 -07:00
|
|
|
|
2011-09-30 08:51:32 -07:00
|
|
|
for (mb_x = 0; mb_x < mb_w; mb_x++, x += 32, rmb_x += 64 * 32)
|
|
|
|
_tex_sub_2d(x, ry, 64, 32, tex->ptuv->format, tex->ptuv->dataformat, rows[mb_y + base_h] + rmb_x);
|
2011-09-04 14:15:04 -07:00
|
|
|
}
|
2011-08-29 13:56:48 -07:00
|
|
|
}
|