modules/evas/engines/gl_common/evas_gl_api_gles3_def.h \
modules/evas/engines/gl_common/evas_gl_api_ext.c \
modules/evas/engines/gl_common/shader/evas_gl_shaders.x \
-modules/evas/engines/gl_common/shader/evas_gl_shaders_bigendian.x \
modules/evas/engines/gl_common/shader_3d/evas_gl_3d_shaders.x \
-modules/evas/engines/gl_common/shader/evas_gl_enum.x
+$(NULL)
# 3D
GL_COMMON_SOURCES += \
GL_SHADERS_GEN = \
modules/evas/engines/gl_common/shader/gen_shaders.sh \
-modules/evas/engines/gl_common/shader/shaders.txt \
modules/evas/engines/gl_common/shader/fragment.glsl \
modules/evas/engines/gl_common/shader/vertex.glsl \
+modules/evas/engines/gl_common/shader/include.glsl \
$(NULL)
EXTRA_DIST += $(GL_SHADERS_GEN)
-EXTRA_lib_evas_libevas_la_DEPENDENCIES = modules/evas/engines/gl_common/shader/evas_gl_enum.x
modules/evas/engines/gl_common/shader/evas_gl_shaders.x: $(GL_SHADERS_GEN)
@echo " SHADERS $@"
@bash $(srcdir)/modules/evas/engines/gl_common/shader/gen_shaders.sh
-modules/evas/engines/gl_common/shader/evas_gl_shaders_bigendian.x: $(GL_SHADERS_GEN)
- @echo " SHADERS $@"
- @bash $(srcdir)/modules/evas/engines/gl_common/shader/gen_shaders.sh _bigendian
-
-modules/evas/engines/gl_common/shader/evas_gl_enum.x: modules/evas/engines/gl_common/shader/evas_gl_shaders.x modules/evas/engines/gl_common/shader/evas_gl_shaders_bigendian.x
-
# NOTE: order here should be equal with modes in file Evas_Eo.h
GL_SHADERS_3D_GEN = \
modules/evas/engines/gl_common/shader_3d/vertex_color_vert.shd \
EAPI int eina_file_statat(void *container, Eina_File_Direct_Info *info, Eina_Stat *buf) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1, 2, 3);
/**
- * @brief Generates and creates a uniquely named temporary file from template.
- * Generated file is opened with the open(2) O_EXCL flag.
+ * @brief Generates and creates a uniquely named temporary file from a template name.
+ * The generated file is opened with the open(2) @c O_EXCL flag.
*
* @param[in] templatename This is a string. It must contain the six characters 'XXXXXX'
- * at the end or directly followed by an extension as in
+ * at the end or directly followed by an extension as in
* 'prefixXXXXXX.ext'.
- * @param[out] path Where to put the name of the created file. If not @c NULL
- * should be released by eina_tmpstr_del().
- * @return On success @c file descriptor of the temporary file is returned,
+ * @param[out] path The path to the created temporary file, or @c NULL in case of failure.
+ * It must be released by eina_tmpstr_del().
+ * @return On success @c file descriptor of the temporary file is returned,
* On error @c -1 is returned, in which case @c errno is set appropriately.
*
* @details This function calls mkstemp(), generates a unique temporary filename
- * from template, creates and opens the file, and returns an open file
+ * from template, creates and opens the file, and returns an open file
* descriptor for the file.
*
* @note If a filename extension was specified in @p templatename, then the new @p path
* will also contain this extension (since 1.10).
*
+ * @note If the @p templatename is a simple file name (no relative or absolute
+ * path to another directory), then a temporary file will be created inside
+ * the system temporary directory (@see eina_environment_tmp_get()). If the
+ * @p templatename contains a directory separator ('/', or '\\' on Windows)
+ * then the file will be created inside this directory, which must exist and
+ * be writable. Use ./filename.XXXXXX to create files in the current
+ * working directory. (since 1.17)
+ *
* @see eina_file_mkdtemp()
* @since 1.8
*/
-EAPI int eina_file_mkstemp(const char *templatename, Eina_Tmpstr **path);
+EAPI int eina_file_mkstemp(const char *templatename, Eina_Tmpstr **path) EINA_ARG_NONNULL(1);
/**
- * @brief Generates and creates a uniquely named temporary directory from template.
+ * @brief Generates and creates a uniquely named temporary directory from a template name.
*
- * @param[in] templatename This is a string. The last six characters of @p templatename
+ * @param[in] templatename This is a string. The last six characters of @p templatename
* must be XXXXXX.
- * @param[out] path Where to put the name of the created directory. If not @c NULL
- * should be released by eina_tmpstr_del().
- * @return On success @c EINA_TRUE is returned, On error @c EINA_FALSE is returned,
+ * @param[out] path The path to the created temporary directory, or @c NULL in case of failure.
+ * It must be released by eina_tmpstr_del().
+ * @return On success @c EINA_TRUE is returned, On error @c EINA_FALSE is returned,
* in which case @c errno is set appropriately.
*
- * @details This function calls mkdtemp(). The directory is then created with
- * permissions 0700.
+ * @details This function calls mkdtemp(). The directory is then created with
+ * permissions 0700.
+ *
+ * @note If the @p templatename is a simple directory name (no relative or absolute
+ * path to another directory), then a temporary directory will be created inside
+ * the system temporary directory (@see eina_environment_tmp_get()). If the
+ * @p templatename contains a directory separator ('/', or '\\' on Windows)
+ * then the temporary directory will be created inside that other directory,
+ * which must exist and be writable. (since 1.17)
*
* @see eina_file_mkstemp()
* @since 1.8
*/
-EAPI Eina_Bool eina_file_mkdtemp(const char *templatename, Eina_Tmpstr **path);
+EAPI Eina_Bool eina_file_mkdtemp(const char *templatename, Eina_Tmpstr **path) EINA_ARG_NONNULL(1,2);
/**
* @brief Gets an iterator to list the content of a directory, with direct
mode_t old_umask;
#endif
-#ifndef HAVE_EVIL
-#if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
+ EINA_SAFETY_ON_NULL_RETURN_VAL(templatename, -1);
+
+# if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
if (getuid() == geteuid())
-#endif
+# endif
{
tmpdir = getenv("TMPDIR");
- if (!tmpdir) tmpdir = getenv("XDG_RUNTIME_DIR");
+ if (!tmpdir) tmpdir = getenv("XDG_RUNTIME_DIR");
}
if (!tmpdir) tmpdir = "/tmp";
-#else
- tmpdir = (char *)evil_tmpdir_get();
-#endif /* ! HAVE_EVIL */
+#ifdef _WIN32
+ if (strchr(templatename, '\\'))
+#else
+ if (strchr(templatename, '/'))
+#endif
+ len = snprintf(buffer, PATH_MAX, "%s", templatename);
+else
len = snprintf(buffer, PATH_MAX, "%s/%s", tmpdir, templatename);
/*
umask(old_umask);
#endif
- if (path) *path = eina_tmpstr_add(buffer);
if (fd < 0)
- return -1;
+ {
+ if (path) *path = NULL;
+ return -1;
+ }
+ if (path) *path = eina_tmpstr_add(buffer);
return fd;
}
const char *tmpdir = NULL;
char *tmpdirname;
-#ifndef HAVE_EVIL
-#if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
+ EINA_SAFETY_ON_NULL_RETURN_VAL(templatename, EINA_FALSE);
+
+# if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
if (getuid() == geteuid())
-#endif
- tmpdir = getenv("TMPDIR");
+# endif
+ {
+ tmpdir = getenv("TMPDIR");
+ if (!tmpdir) tmpdir = getenv("XDG_RUNTIME_DIR");
+ }
if (!tmpdir) tmpdir = "/tmp";
-#else
- tmpdir = (char *)evil_tmpdir_get();
-#endif /* ! HAVE_EVIL */
+#ifdef _WIN32
+ if (strchr(templatename, '\\'))
+#else
+ if (strchr(templatename, '/'))
+#endif
+ snprintf(buffer, PATH_MAX, "%s", templatename);
+else
snprintf(buffer, PATH_MAX, "%s/%s", tmpdir, templatename);
tmpdirname = mkdtemp(buffer);
- if (path) *path = eina_tmpstr_add(buffer);
if (tmpdirname == NULL)
- return EINA_FALSE;
+ {
+ if (path) *path = NULL;
+ return EINA_FALSE;
+ }
+ if (path) *path = eina_tmpstr_add(tmpdirname);
return EINA_TRUE;
}
static FILE *
bc_tmp_open(const char *fname, char *buf, size_t buflen)
{
+ Eina_Tmpstr *tmp_file;
int fd;
-#ifndef _WIN32
- mode_t old_umask;
-#endif
- char *fs = strrchr(fname, '/'), *bs = strrchr(fname, '\\');
- if (!fs && !bs)
- snprintf(buf, buflen, "./XXXXXX");
- else
- {
- char *ss = (fs > bs) ? fs : bs;
- snprintf(buf, buflen, "%.*sXXXXXX", (int)(ss - fname + 1), fname);
- }
-#ifndef _WIN32
- old_umask = umask(S_IRWXG|S_IRWXO);
-#endif
- fd = mkstemp(buf);
-#ifndef _WIN32
- umask(old_umask);
-#endif
+ snprintf(buf, buflen, "%s.XXXXXX.cache", fname);
+ fd = eina_file_mkstemp(buf, &tmp_file);
if (fd < 0)
return NULL;
- return fdopen(fd, "w");
+ eina_strlcpy(buf, tmp_file, buflen);
+ eina_tmpstr_del(tmp_file);
+ return fdopen(fd, "wb");
}
static void
fclose(f);
/* there really is nothing to handle here */
(void)!!remove(buf);
+ return;
}
else fclose(f);
snprintf(buf2, sizeof(buf2), "%sc", fname);
}
static void
-eng_output_idle_flush(void *data EINA_UNUSED)
-{
-}
-
-static void
eng_context_cutout_add(void *data EINA_UNUSED, void *context, int x, int y, int w, int h)
{
evas_common_draw_context_add_cutout(context, x, y, w, h);
typedef Eina_Bool (*evas_gl_make_current_cb)(void *engine_data, void *doit);
-/* enum Evas_GL_Shader is defined below */
-#include "shader/evas_gl_enum.x"
-
#ifdef EAPI
# undef EAPI
#endif
# endif
#endif /* ! _WIN32 */
+#define PROGRAM_HITCOUNT_MAX 0x1000000
+
struct _Evas_GL_Program
{
- GLuint vert, frag, prog;
+ unsigned int flags, hitcount, tex_count;
+ GLuint prog;
- int tex_count;
- Eina_Bool reset;
+ Eina_Bool reset : 1;
+ Eina_Bool bin_saved : 1;
+ Eina_Bool delete_me : 1;
};
struct _Evas_GL_Shared
Eina_Hash *native_tbm_hash;
Eina_Hash *native_evasgl_hash;
+ Eet_File *shaders_cache;
+ Eina_Hash *shaders_hash;
+ Eina_Stringshare *shaders_checksum;
+
#ifdef GL_GLES
// FIXME: hack.
void *eglctxt;
#endif
- Evas_GL_Program shader[SHADER_LAST];
int references;
int w, h;
int foc, z0, px, py;
int ax, ay;
GLfloat proj[16];
+
+ Eina_Bool needs_shaders_flush : 1;
};
typedef enum _Shader_Sampling Shader_Sampling;
enum _Shader_Type {
SHD_UNKNOWN,
SHD_RECT,
+ SHD_LINE,
SHD_FONT,
SHD_IMAGE,
SHD_IMAGENATIVE,
SHD_YUV_709,
SHD_YUY2_709,
SHD_NV12_709,
- SHD_LINE,
SHD_RGB_A_PAIR,
- SHD_TEX_EXTERNAL,
SHD_MAP,
SHD_TYPE_LAST
};
struct {
int top_pipe;
struct {
- Evas_GL_Shader id;
- GLuint cur_prog;
+ Evas_GL_Program *prog;
GLuint cur_tex, cur_texu, cur_texv, cur_texa, cur_texm;
int tex_target;
int render_op;
Eina_Bool active : 1;
} clip;
struct {
- Evas_GL_Shader id;
+ Evas_GL_Program *prog;
Evas_GL_Image *surface;
- GLuint cur_prog;
GLuint cur_tex, cur_texu, cur_texv, cur_texa, cur_texm;
void *cur_tex_dyn, *cur_texu_dyn, *cur_texv_dyn;
int tex_target;
Evas_Colorspace cspace);
int evas_gl_common_shader_program_init(Evas_GL_Shared *shared);
-void evas_gl_common_shader_program_init_done(void);
-void evas_gl_common_shader_program_shutdown(Evas_GL_Program *p);
-Evas_GL_Shader evas_gl_common_img_shader_select(Shader_Type type, Shader_Sampling sam, int nomul, int afill, int bgra, int mask, int masksam);
-const char *evas_gl_common_shader_name_get(Evas_GL_Shader shd);
+void evas_gl_common_shader_program_shutdown(Evas_GL_Shared *shared);
+EAPI void evas_gl_common_shaders_flush(Evas_GL_Shared *shared);
+
+Evas_GL_Program *evas_gl_common_shader_program_get(Evas_Engine_GL_Context *gc,
+ Shader_Type type,
+ RGBA_Map_Point *p, int npoints,
+ int r, int g, int b, int a,
+ int sw, int sh, int w, int h, Eina_Bool smooth,
+ Evas_GL_Texture *tex, Eina_Bool tex_only,
+ Evas_GL_Texture *mtex, Eina_Bool mask_smooth,
+ int mw, int mh,
+ Shader_Sampling *psam, int *pnomul,
+ Shader_Sampling *pmasksam);
+void evas_gl_common_shader_textures_bind(Evas_GL_Program *p);
Eina_Bool evas_gl_common_file_cache_is_dir(const char *file);
Eina_Bool evas_gl_common_file_cache_mkdir(const char *dir);
Eina_Bool evas_gl_common_file_cache_mkpath(const char *path);
int evas_gl_common_file_cache_dir_check(char *cache_dir, int num);
int evas_gl_common_file_cache_file_check(const char *cache_dir, const char *cache_name, char *cache_file, int dir_num);
-int evas_gl_common_file_cache_save(Evas_GL_Shared *shared);
void evas_gl_common_rect_draw(Evas_Engine_GL_Context *gc, int x, int y, int w, int h);
extern Eina_Bool _need_context_restore;
extern void _context_restore(void);
-EAPI void evas_gl_context_restore_set(Eina_Bool enable);
#endif
# error gl_common should not get compiled if dlsym is not found on the system!
#endif
-#define PRG_INVALID 0xffffffff
+#define PRG_INVALID NULL
#define GLPIPES 1
static int sym_done = 0;
static void
_evas_gl_common_viewport_set(Evas_Engine_GL_Context *gc, int force_update)
{
- unsigned int i;
int w = 1, h = 1, m = 1, rot = 1, foc = 0;
+ Evas_GL_Program *prog;
+ Eina_Iterator *it;
EINA_SAFETY_ON_NULL_RETURN(gc);
foc = gc->foc;
gc->shared->ay = ay;
}
- for (i = 0; i < SHADER_LAST; ++i)
- {
- gc->shared->shader[i].reset = EINA_TRUE;
- }
+ // FIXME: Is this heavy work?
+ it = eina_hash_iterator_data_new(gc->shared->shaders_hash);
+ EINA_ITERATOR_FOREACH(it, prog)
+ prog->reset = EINA_TRUE;
+ eina_iterator_free(it);
- if (gc->state.current.cur_prog == PRG_INVALID)
+ if (gc->state.current.prog != PRG_INVALID)
+ /*
{
glUseProgram(gc->shared->shader[0].prog);
glUniformMatrix4fv(glGetUniformLocation(gc->shared->shader[0].prog, "mvp"), 1, GL_FALSE, gc->shared->proj);
gc->shared->shader[0].reset = EINA_FALSE;
}
else
+ */
{
- glUseProgram(gc->state.current.cur_prog);
- glUniformMatrix4fv(glGetUniformLocation(gc->state.current.cur_prog, "mvp"), 1, GL_FALSE, gc->shared->proj);
+ glUseProgram(gc->state.current.prog->prog);
+ glUniformMatrix4fv(glGetUniformLocation(gc->state.current.prog->prog, "mvp"), 1, GL_FALSE, gc->shared->proj);
}
}
if (!shared)
{
const char *ext;
- int shd;
shared = calloc(1, sizeof(Evas_GL_Shared));
ext = (const char *) glGetString(GL_EXTENSIONS);
glEnableVertexAttribArray(SHAD_VERTEX);
glEnableVertexAttribArray(SHAD_COLOR);
- if (!evas_gl_common_shader_program_init(shared)) goto error;
+ if (!evas_gl_common_shader_program_init(shared))
+ goto error;
- /* Bind textures */
- for (shd = 0; _shaders_textures[shd].id != SHADER_LAST; shd++)
- {
- GLuint loc;
- glUseProgram(shared->shader[_shaders_textures[shd].id].prog);
- loc = glGetUniformLocation(shared->shader[_shaders_textures[shd].id].prog, _shaders_textures[shd].tname);
- glUniform1i(loc, shared->shader[_shaders_textures[shd].id].tex_count++);
- }
-
- if (gc->state.current.cur_prog == PRG_INVALID)
- glUseProgram(shared->shader[0].prog);
- else glUseProgram(gc->state.current.cur_prog);
+ if (gc->state.current.prog)
+ glUseProgram(gc->state.current.prog->prog);
- evas_gl_common_shader_program_init_done();
// in shader:
// uniform sampler2D tex[8];
//
{
Evas_GL_Texture_Pool *pt;
- for (i = 0; i < SHADER_LAST; ++i)
- evas_gl_common_shader_program_shutdown(&(gc->shared->shader[i]));
+ evas_gl_common_shader_program_shutdown(gc->shared);
while (gc->shared->images)
{
eina_hash_free(gc->shared->native_wl_hash);
eina_hash_free(gc->shared->native_tbm_hash);
eina_hash_free(gc->shared->native_evasgl_hash);
+ eina_stringshare_del(gc->shared->shaders_checksum);
free(gc->shared);
shared = NULL;
}
// fprintf(stderr, "------------------------\n");
gc->flushnum = 0;
- gc->state.current.id = SHADER_LAST;
- gc->state.current.cur_prog = 0;
+ gc->state.current.prog = NULL;
gc->state.current.cur_tex = 0;
gc->state.current.cur_texu = 0;
gc->state.current.cur_texv = 0;
gc->pipe[i].clip.w = 0;
gc->pipe[i].clip.h = 0;
gc->pipe[i].shader.surface = NULL;
- gc->pipe[i].shader.id = SHADER_LAST;
- gc->pipe[i].shader.cur_prog = 0;
+ gc->pipe[i].shader.prog = NULL;
gc->pipe[i].shader.cur_tex = 0;
gc->pipe[i].shader.cur_texu = 0;
gc->pipe[i].shader.cur_texv = 0;
glEnableVertexAttribArray(SHAD_VERTEX);
glEnableVertexAttribArray(SHAD_COLOR);
- if (gc->state.current.cur_prog == PRG_INVALID)
- glUseProgram(gc->shared->shader[0].prog);
- else glUseProgram(gc->state.current.cur_prog);
+ if (gc->state.current.prog != PRG_INVALID)
+ glUseProgram(gc->state.current.prog->prog);
glActiveTexture(GL_TEXTURE0);
glBindTexture(gc->pipe[0].shader.tex_target, gc->pipe[0].shader.cur_tex);
evas_gl_common_context_flush(gc);
evas_gl_common_context_done(gc);
- gc->state.current.id = SHADER_LAST;
- gc->state.current.cur_prog = PRG_INVALID;
+ gc->state.current.prog = NULL;
gc->state.current.cur_tex = 0;
gc->state.current.cur_texu = 0;
gc->state.current.cur_texv = 0;
*/
}
-static Evas_GL_Shader
-evas_gl_common_shader_select(Evas_Engine_GL_Context *gc,
- Shader_Type type,
- RGBA_Map_Point *p, int npoints,
- int r, int g, int b, int a,
- int sw, int sh, int w, int h, Eina_Bool smooth,
- Evas_GL_Texture *tex, Eina_Bool tex_only,
- Evas_GL_Texture *mtex, Eina_Bool mask_smooth,
- int mw, int mh,
- Shader_Sampling *psam, int *pnomul, Shader_Sampling *pmasksam)
-{
- const Eina_Bool gc_bgra = gc->shared->info.bgra;
- int nomul = 1, bgra = 0;
- int mask = (mtex != NULL), afill = 0;
- Shader_Sampling sam = SHD_SAM11, masksam = SHD_SAM11;
- Evas_GL_Shader shader = SHADER_RECT;
- int k = 0;
-
- if ((type <= SHD_UNKNOWN) || (type >= SHD_TYPE_LAST))
- {
- CRI("Unknown shader type requested!");
- goto end;
- }
-
- // image downscale sampling
- if (smooth && ((type == SHD_IMAGE) || (type == SHD_IMAGENATIVE)))
- {
- if ((sw >= (w * 2)) && (sh >= (h * 2)))
- sam = SHD_SAM22;
- else if (sw >= (w * 2))
- sam = SHD_SAM21;
- else if (sh >= (h * 2))
- sam = SHD_SAM12;
- }
-
- // mask downscale sampling
- if (mtex && mask_smooth)
- {
- if ((mtex->w >= (mw * 2)) && (mtex->h >= (mh * 2)))
- masksam = SHD_SAM22;
- else if (mtex->w >= (mw * 2))
- masksam = SHD_SAM21;
- else if (mtex->h >= (mh * 2))
- masksam = SHD_SAM12;
- }
-
- // rect, line, polygon
- if ((type == SHD_RECT) || (type == SHD_LINE))
- {
- static const Evas_GL_Shader rect_shaders[] = {
- SHADER_RECT_MASK, SHADER_RECT_MASK12, SHADER_RECT_MASK21, SHADER_RECT_MASK22
- };
- if (!mtex) shader = SHADER_RECT;
- else shader = rect_shaders[masksam];
- goto end;
- }
-
- // text
- if (type == SHD_FONT)
- {
- static const Evas_GL_Shader font_shaders[] = {
- SHADER_FONT_MASK, SHADER_FONT_MASK12, SHADER_FONT_MASK21, SHADER_FONT_MASK22
- };
- if (!mtex) shader = SHADER_FONT;
- else shader = font_shaders[masksam];
- goto end;
- }
-
- // color mul
- if ((a == 255) && (r == 255) && (g == 255) && (b == 255))
- {
- if (p)
- {
- for (k = 0; k < npoints; k++)
- if (p[k].col != 0xffffffff)
- {
- nomul = 0;
- break;
- }
- }
- }
- else
- nomul = 0;
-
- // bgra
- if (tex_only)
- {
- if (tex->pt->dyn.img)
- {
- afill = !tex->alpha;
- bgra = 1;
- }
- else if (tex->im && tex->im->native.target == GL_TEXTURE_EXTERNAL_OES)
- {
- type = SHD_TEX_EXTERNAL;
- afill = !tex->alpha;
- }
- else
- bgra = 1;
- }
- else
- bgra = gc_bgra;
-
- if ((type == SHD_IMAGE) || (type == SHD_IMAGENATIVE) || (type == SHD_MAP))
- shader = evas_gl_common_img_shader_select(type, sam, nomul, afill, bgra, mask, masksam);
- else
- {
-#define SHADERS(name, ...) \
- SHADER_##name##_NOMUL##__VA_ARGS__, SHADER_##name##__VA_ARGS__, \
- SHADER_##name##_MASK_NOMUL, SHADER_##name##_MASK
- static const Evas_GL_Shader yuv_shaders[] = {
- SHADERS(YUV),
- SHADERS(YUY2),
- SHADERS(NV12),
- SHADERS(YUV_709),
- SHADERS(YUY2_709),
- SHADERS(NV12_709),
- SHADERS(RGB_A_PAIR),
- SHADERS(TEX_EXTERNAL),
- SHADERS(TEX_EXTERNAL, _AFILL), /* note: afill + mask does not exist */
- };
-#undef SHADERS
-
- switch (type)
- {
- case SHD_YUV: k = 0; break;
- case SHD_YUY2: k = 4; break;
- case SHD_NV12: k = 8; break;
- case SHD_YUV_709: k = 12; break;
- case SHD_YUY2_709: k = 16; break;
- case SHD_NV12_709: k = 20; break;
- case SHD_RGB_A_PAIR: k = 24; break;
- case SHD_TEX_EXTERNAL: k = 28; break;
- default:
- CRI("Unknown shader type requested!");
- goto end;
- }
-
- shader = yuv_shaders[k + (afill * 4) + (mask * 2) + (!nomul)];
- }
-
- /*
- DBG("sam %d, nomul %d, afill %d, bgra %d, mask %d --> [%02d] %s",
- (int) sam, nomul, afill, bgra, mask, shader,
- evas_gl_common_shader_name_get(shader));
- */
-end:
- if (psam) *psam = sam;
- if (pnomul) *pnomul = nomul;
- if (pmasksam) *pmasksam = masksam;
- return shader;
-}
static int
_evas_gl_common_context_push(Shader_Type rtype,
Evas_Engine_GL_Context *gc,
Evas_GL_Texture *tex,
Evas_GL_Texture *texm,
- GLuint prog,
+ Evas_GL_Program *prog,
int x, int y, int w, int h,
Eina_Bool blend,
Eina_Bool smooth,
&& (!tex || gc->pipe[i].shader.cur_tex == current_tex)
&& (!texm || ((gc->pipe[i].shader.cur_texm == texm->pt->texture)
&& (gc->pipe[i].shader.mask_smooth == mask_smooth)))
- && (gc->pipe[i].shader.cur_prog == prog)
+ && (gc->pipe[i].shader.prog == prog)
&& (gc->pipe[i].shader.smooth == smooth)
&& (gc->pipe[i].shader.blend == blend)
&& (gc->pipe[i].shader.render_op == gc->dc->render_op)
/* && (!texa || gc->pipe[pn].shader.cur_texa == current_texa) */
&& (!texm || ((gc->pipe[i].shader.cur_texm == texm->pt->texture)
&& (gc->pipe[i].shader.mask_smooth == mask_smooth)))
- && (gc->pipe[pn].shader.cur_prog == prog)
+ && (gc->pipe[pn].shader.prog == prog)
&& (gc->pipe[pn].shader.smooth == smooth)
&& (gc->pipe[pn].shader.blend == blend)
&& (gc->pipe[pn].shader.render_op == gc->dc->render_op)
int r, int g, int b, int a)
{
Eina_Bool blend = EINA_FALSE;
- Evas_GL_Shader shader;
+ Evas_GL_Program *prog;
int pn = 0, i;
- GLuint prog, mtexid = mtex ? mtex->pt->texture : 0;
+ GLuint mtexid = mtex ? mtex->pt->texture : 0;
Shader_Sampling masksam = SHD_SAM11;
if (!(gc->dc->render_op == EVAS_RENDER_COPY) && ((a < 255) || (mtex)))
blend = EINA_TRUE;
- shader = evas_gl_common_shader_select(gc, SHD_LINE, NULL, 0, r, g, b, a,
+ prog = evas_gl_common_shader_program_get(gc, SHD_LINE, NULL, 0, r, g, b, a,
0, 0, 0, 0, EINA_FALSE, NULL, EINA_FALSE,
mtex, mask_smooth, mw, mh, NULL, NULL, &masksam);
- prog = gc->shared->shader[shader].prog;
shader_array_flush(gc);
vertex_array_size_check(gc, gc->state.top_pipe, 2);
pn = gc->state.top_pipe;
gc->pipe[pn].region.type = SHD_LINE;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = 0;
gc->pipe[pn].shader.cur_texm = mtexid;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.blend = blend;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
gc->pipe[pn].shader.clip = clip;
{
Eina_Bool blend = EINA_FALSE;
Shader_Sampling masksam = SHD_SAM11;
- Evas_GL_Shader shader;
- GLuint prog;
+ Evas_GL_Program *prog;
GLuint mtexid = mtex ? mtex->pt->texture : 0;
int pn = 0;
if (!(gc->dc->render_op == EVAS_RENDER_COPY) && ((a < 255) || mtex))
blend = EINA_TRUE;
- shader = evas_gl_common_shader_select(gc, SHD_RECT, NULL, 0, r, g, b, a,
- 0, 0, 0, 0, EINA_FALSE, NULL, EINA_FALSE,
- mtex, mask_smooth, mw, mh, NULL, NULL, &masksam);
- prog = gc->shared->shader[shader].prog;
+ prog = evas_gl_common_shader_program_get(gc, SHD_RECT, NULL, 0, r, g, b, a,
+ 0, 0, 0, 0, EINA_FALSE, NULL, EINA_FALSE,
+ mtex, mask_smooth, mw, mh, NULL, NULL, &masksam);
again:
vertex_array_size_check(gc, gc->state.top_pipe, 6);
if ((pn == 0) && (gc->pipe[pn].array.num == 0))
{
gc->pipe[pn].region.type = SHD_RECT;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = 0;
gc->pipe[pn].shader.cur_texm = mtexid;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.blend = blend;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
gc->pipe[pn].shader.mask_smooth = mask_smooth;
if ((gc->pipe[i].region.type == SHD_RECT)
&& (gc->pipe[i].shader.cur_tex == 0)
&& (gc->pipe[i].shader.cur_texm == mtexid)
- && (gc->pipe[i].shader.cur_prog == prog)
+ && (gc->pipe[i].shader.prog == prog)
&& (gc->pipe[i].shader.blend == blend)
&& (gc->pipe[i].shader.render_op == gc->dc->render_op)
&& (gc->pipe[i].shader.clip == 0)
}
gc->state.top_pipe = pn;
gc->pipe[pn].region.type = SHD_RECT;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = 0;
gc->pipe[pn].shader.cur_texm = mtexid;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.blend = blend;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
gc->pipe[pn].shader.mask_smooth = mask_smooth;
#else
if ((gc->pipe[pn].shader.cur_tex != 0)
|| (gc->pipe[pn].shader.cur_texm != mtexid)
- || (gc->pipe[pn].shader.cur_prog != prog)
+ || (gc->pipe[pn].shader.prog != prog)
|| (gc->pipe[pn].shader.blend != blend)
|| (gc->pipe[pn].shader.render_op != gc->dc->render_op)
|| (gc->pipe[pn].shader.clip != 0)
{
shader_array_flush(gc);
pn = gc->state.top_pipe;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = 0;
gc->pipe[pn].shader.cur_texm = mtexid;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.blend = blend;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
gc->pipe[pn].shader.mask_smooth = mask_smooth;
GLfloat offsetx, offsety;
double pw, ph;
Eina_Bool blend = EINA_FALSE;
- Evas_GL_Shader shader = SHADER_IMG;
- GLuint prog = gc->shared->shader[shader].prog;
+ Evas_GL_Program *prog;
int pn = 0, render_op = gc->dc->render_op, nomul = 0;
Shader_Sampling sam = 0, masksam = 0;
int yinvert = 0;
else if (!(render_op == EVAS_RENDER_COPY) && ((a < 255) || (tex->alpha)))
blend = EINA_TRUE;
- shader = evas_gl_common_shader_select(gc, shd_in, NULL, 0, r, g, b, a,
+ prog = evas_gl_common_shader_program_get(gc, shd_in, NULL, 0, r, g, b, a,
sw, sh, w, h, smooth, tex, tex_only,
mtex, mask_smooth, mw, mh,
&sam, &nomul, &masksam);
- prog = gc->shared->shader[shader].prog;
if (tex->ptt)
{
mask_smooth);
gc->pipe[pn].region.type = SHD_IMAGE;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = pt->texture;
gc->pipe[pn].shader.cur_texm = mtex ? mtex->pt->texture : 0;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.tex_target = tex_target;
gc->pipe[pn].shader.smooth = smooth;
gc->pipe[pn].shader.mask_smooth = mask_smooth;
{
GLfloat tx1, tx2, ty1, ty2;
Shader_Sampling masksam = SHD_SAM11;
- Evas_GL_Shader shader;
- GLuint prog;
+ Evas_GL_Program *prog;
int pn = 0;
- shader = evas_gl_common_shader_select(gc, SHD_FONT, NULL, 0, r, g, b, a,
+ prog = evas_gl_common_shader_program_get(gc, SHD_FONT, NULL, 0, r, g, b, a,
sw, sh, w, h, EINA_FALSE, tex, EINA_FALSE,
mtex, mask_smooth, mw, mh,
NULL, NULL, &masksam);
- prog = gc->shared->shader[shader].prog;
pn = _evas_gl_common_context_push(SHD_FONT,
gc, tex, mtex,
mask_smooth);
gc->pipe[pn].region.type = SHD_FONT;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = tex->pt->texture;
gc->pipe[pn].shader.cur_texm = mtex ? mtex->pt->texture : 0;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.smooth = 0;
gc->pipe[pn].shader.blend = 1;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
GLfloat tx1, tx2, ty1, ty2, t2x1, t2x2, t2y1, t2y2;
Shader_Sampling masksam = SHD_SAM11;
Eina_Bool blend = 0;
- Evas_GL_Shader shader;
- GLuint prog;
+ Evas_GL_Program *prog;
int pn = 0, nomul = 0;
if ((a < 255) || (!!mtex))
blend = 1;
- shader = evas_gl_common_shader_select(gc, SHD_YUV, NULL, 0, r, g, b, a,
+ prog = evas_gl_common_shader_program_get(gc, SHD_YUV, NULL, 0, r, g, b, a,
w, h, w, h, smooth, tex, 0,
mtex, mask_smooth, mw, mh,
NULL, &nomul, &masksam);
- prog = gc->shared->shader[shader].prog;
pn = _evas_gl_common_context_push(SHD_YUV,
gc, tex, mtex,
mask_smooth);
gc->pipe[pn].region.type = SHD_YUV;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = tex->pt->texture;
gc->pipe[pn].shader.cur_texu = tex->ptu->texture;
gc->pipe[pn].shader.cur_texv = tex->ptv->texture;
gc->pipe[pn].shader.cur_texm = mtex ? mtex->pt->texture : 0;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.smooth = smooth;
gc->pipe[pn].shader.blend = blend;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
GLfloat tx1, tx2, ty1, ty2, t2x1, t2x2, t2y1, t2y2;
Shader_Sampling masksam = SHD_SAM11;
Eina_Bool blend = 0;
- Evas_GL_Shader shader;
- GLuint prog;
+ Evas_GL_Program *prog;
int pn = 0, nomul = 0;
if ((a < 255) || (!!mtex))
blend = 1;
- shader = evas_gl_common_shader_select(gc, SHD_YUV_709, NULL, 0, r, g, b, a,
+ prog = evas_gl_common_shader_program_get(gc, SHD_YUV_709, NULL, 0, r, g, b, a,
w, h, w, h, smooth, tex, 0,
mtex, mask_smooth, mw, mh,
NULL, &nomul, &masksam);
- prog = gc->shared->shader[shader].prog;
pn = _evas_gl_common_context_push(SHD_YUV_709,
gc, tex, mtex,
mask_smooth);
gc->pipe[pn].region.type = SHD_YUV_709;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = tex->pt->texture;
gc->pipe[pn].shader.cur_texu = tex->ptu->texture;
gc->pipe[pn].shader.cur_texv = tex->ptv->texture;
gc->pipe[pn].shader.cur_texm = mtex ? mtex->pt->texture : 0;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.smooth = smooth;
gc->pipe[pn].shader.blend = blend;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
GLfloat tx1, tx2, ty1, ty2, t2x1, t2x2, t2y1, t2y2;
Shader_Sampling masksam = SHD_SAM11;
Eina_Bool blend = 0;
- Evas_GL_Shader shader;
- GLuint prog;
+ Evas_GL_Program *prog;
int pn = 0, nomul = 0;
if ((a < 255) || (!!mtex))
blend = 1;
- shader = evas_gl_common_shader_select(gc, SHD_YUY2, NULL, 0, r, g, b, a,
+ prog = evas_gl_common_shader_program_get(gc, SHD_YUY2, NULL, 0, r, g, b, a,
sw, sh, w, h, smooth, tex, 0,
mtex, mask_smooth, mw, mh,
NULL, &nomul, &masksam);
- prog = gc->shared->shader[shader].prog;
pn = _evas_gl_common_context_push(SHD_YUY2,
gc, tex, mtex,
mask_smooth);
gc->pipe[pn].region.type = SHD_YUY2;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = tex->pt->texture;
gc->pipe[pn].shader.cur_texu = tex->ptuv->texture;
gc->pipe[pn].shader.cur_texm = mtex ? mtex->pt->texture : 0;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.smooth = smooth;
gc->pipe[pn].shader.blend = blend;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
GLfloat tx1, tx2, ty1, ty2, t2x1, t2x2, t2y1, t2y2;
Shader_Sampling masksam = SHD_SAM11;
Eina_Bool blend = 0;
- Evas_GL_Shader shader;
- GLuint prog;
+ Evas_GL_Program *prog;
int pn = 0, nomul = 0;
if ((a < 255) || (!!mtex))
blend = 1;
- shader = evas_gl_common_shader_select(gc, SHD_NV12, NULL, 0, r, g, b, a,
+ prog = evas_gl_common_shader_program_get(gc, SHD_NV12, NULL, 0, r, g, b, a,
sw, sh, w, h, smooth, tex, 0,
mtex, mask_smooth, mw, mh,
NULL, &nomul, &masksam);
- prog = gc->shared->shader[shader].prog;
- prog = gc->shared->shader[shader].prog;
pn = _evas_gl_common_context_push(SHD_NV12,
gc, tex, mtex,
mask_smooth);
gc->pipe[pn].region.type = SHD_NV12;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = tex->pt->texture;
gc->pipe[pn].shader.cur_tex_dyn = tex->pt->dyn.img;
gc->pipe[pn].shader.cur_texu = tex->ptuv->texture;
gc->pipe[pn].shader.cur_texu_dyn = tex->ptuv->dyn.img;
gc->pipe[pn].shader.cur_texm = mtex ? mtex->pt->texture : 0;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.smooth = smooth;
gc->pipe[pn].shader.blend = blend;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
GLfloat tx1, tx2, ty1, ty2, t2x1, t2x2, t2y1, t2y2;
Shader_Sampling masksam = SHD_SAM11;
- Evas_GL_Shader shader;
- GLuint prog;
+ Evas_GL_Program *prog;
int pn, nomul = 0;
- shader = evas_gl_common_shader_select(gc, SHD_RGB_A_PAIR, NULL, 0, r, g, b, a,
+ prog = evas_gl_common_shader_program_get(gc, SHD_RGB_A_PAIR, NULL, 0, r, g, b, a,
sw, sh, w, h, smooth, tex, 0,
mtex, mask_smooth, mw, mh,
NULL, &nomul, &masksam);
- prog = gc->shared->shader[shader].prog;
pn = _evas_gl_common_context_push(SHD_RGB_A_PAIR,
gc, tex, mtex,
mask_smooth);
gc->pipe[pn].region.type = SHD_RGB_A_PAIR;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = tex->pt->texture;
gc->pipe[pn].shader.cur_texa = tex->pta->texture;
gc->pipe[pn].shader.cur_texm = mtex ? mtex->pt->texture : 0;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.smooth = smooth;
gc->pipe[pn].shader.blend = EINA_TRUE;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
Eina_Bool blend = EINA_FALSE;
DATA32 cmul;
Shader_Sampling masksam = SHD_SAM11;
- Evas_GL_Shader shader = SHADER_IMG;
+ Evas_GL_Program *prog;
Eina_Bool utexture = EINA_FALSE;
Eina_Bool uvtexture = EINA_FALSE;
Eina_Bool use_texa = EINA_FALSE;
Shader_Type type;
int pn = 0, i;
int flat = 0, nomul = 0, yinvert = 0;
- GLuint prog;
if (!(gc->dc->render_op == EVAS_RENDER_COPY) &&
((a < 255) || (tex->alpha) || (!!mtex))) blend = EINA_TRUE;
type = SHD_MAP;
break;
}
- shader = evas_gl_common_shader_select(gc, type, p, npoints, r, g, b, a,
+ prog = evas_gl_common_shader_program_get(gc, type, p, npoints, r, g, b, a,
w, h, w, h, smooth, tex, tex_only,
mtex, mask_smooth, mw, mh,
NULL, &nomul, &masksam);
- prog = gc->shared->shader[shader].prog;
x = w = (p[0].x >> FP);
y = h = (p[0].y >> FP);
clip, cx, cy, cw, ch,
mask_smooth);
gc->pipe[pn].region.type = SHD_MAP;
- gc->pipe[pn].shader.id = shader;
+ gc->pipe[pn].shader.prog = prog;
gc->pipe[pn].shader.cur_tex = tex->pt->texture;
if (utexture)
{
gc->pipe[pn].shader.cur_texu_dyn = tex->ptuv->dyn.img;
}
gc->pipe[pn].shader.cur_texm = mtex ? mtex->pt->texture : 0;
- gc->pipe[pn].shader.cur_prog = prog;
gc->pipe[pn].shader.smooth = smooth;
gc->pipe[pn].shader.blend = blend;
gc->pipe[pn].shader.render_op = gc->dc->render_op;
}
for (i = 0; i < gc->shared->info.tune.pipes.max; i++)
{
+ Evas_GL_Program *prog;
if (gc->pipe[i].array.num <= 0) break;
+ prog = gc->pipe[i].shader.prog;
setclip = EINA_FALSE;
pipe_done++;
gc->flushnum++;
GLERRV("<flush err>");
- if (gc->pipe[i].shader.cur_prog != gc->state.current.cur_prog)
+ if (prog && (prog != gc->state.current.prog))
{
- glUseProgram(gc->pipe[i].shader.cur_prog);
- if (gc->shared->shader[gc->pipe[i].shader.id].reset)
+ glUseProgram(prog->prog);
+ if (prog->reset)
{
- glUniformMatrix4fv(glGetUniformLocation(gc->pipe[i].shader.cur_prog, "mvp"), 1, GL_FALSE, gc->shared->proj);
- gc->shared->shader[gc->pipe[i].shader.id].reset = EINA_FALSE;
+ glUniformMatrix4fv(glGetUniformLocation(prog->prog, "mvp"), 1, GL_FALSE, gc->shared->proj);
+ prog->reset = EINA_FALSE;
}
}
gc->pipe[i].array.im = NULL;
}
- gc->state.current.id = gc->pipe[i].shader.id;
- gc->state.current.cur_prog = gc->pipe[i].shader.cur_prog;
+ gc->state.current.prog = gc->pipe[i].shader.prog;
gc->state.current.cur_tex = gc->pipe[i].shader.cur_tex;
gc->state.current.cur_texm = gc->pipe[i].shader.cur_texm;
gc->state.current.cur_texa = gc->pipe[i].shader.cur_texa;
{
/* check eet */
Eet_File *et = NULL; //check eet file
- int tmpfd;
- int res = 0;
- char cap_dir_path[PATH_MAX] = {0,};
- char cap_file_path[PATH_MAX]= {0,};
- char tmp_file[PATH_MAX] = {0,};
+ int tmpfd = -1;
+ char cap_dir_path[PATH_MAX];
+ char cap_file_path[PATH_MAX];
+ char tmp_file_name[PATH_MAX];
+ Eina_Tmpstr *tmp_file_path = NULL;
+
+ /* use eet */
+ if (!eet_init()) return 0;
if (!evas_gl_common_file_cache_dir_check(cap_dir_path, sizeof(cap_dir_path)))
{
- if (cap_dir_path[0] != '\0')
- res = evas_gl_common_file_cache_mkpath(cap_dir_path);
-
- if (!res) return 0; /* we can't make directory */
+ if (!evas_gl_common_file_cache_mkpath(cap_dir_path))
+ return 0; /* we can't make directory */
}
evas_gl_common_file_cache_file_check(cap_dir_path, "surface_cap", cap_file_path,
sizeof(cap_dir_path));
/* use mkstemp for writing */
- snprintf(tmp_file, sizeof(tmp_file), "%s.XXXXXX", cap_file_path);
-
-#ifndef _WIN32
- mode_t old_umask = umask(S_IRWXG|S_IRWXO);
-#endif
- tmpfd = mkstemp(tmp_file);
-#ifndef _WIN32
- umask(old_umask);
-#endif
-
+ snprintf(tmp_file_name, sizeof(tmp_file_name), "%s.XXXXXX.cache", cap_file_path);
+ tmpfd = eina_file_mkstemp(tmp_file_name, &tmp_file_path);
if (tmpfd < 0) goto error;
- close(tmpfd);
- /* use eet */
- if (!eet_init()) goto error;
-
- et = eet_open(tmp_file, EET_FILE_MODE_WRITE);
+ et = eet_open(tmp_file_path, EET_FILE_MODE_WRITE);
if (!et) goto error;
if (!_surface_cap_save(et)) goto error;
- if (eet_close(et) != EET_ERROR_NONE) goto error;
- if (rename(tmp_file,cap_file_path) < 0) goto error;
+ if (eet_close(et) != EET_ERROR_NONE) goto destroyed;
+ if (rename(tmp_file_path, cap_file_path) < 0) goto destroyed;
+ eina_tmpstr_del(tmp_file_path);
+ close(tmpfd);
eet_shutdown();
+
return 1;
+destroyed:
+ et = NULL;
+
error:
+ if (tmpfd >= 0) close(tmpfd);
if (et) eet_close(et);
- if (evas_gl_common_file_cache_file_exists(tmp_file)) unlink(tmp_file);
+ if (evas_gl_common_file_cache_file_exists(tmp_file_path))
+ unlink(tmp_file_path);
+ eina_tmpstr_del(tmp_file_path);
eet_shutdown();
return 0;
}
}
}
-void
-evas_gl_context_restore_set(Eina_Bool enable)
+EAPI void
+evas_gl_common_context_restore_set(Eina_Bool enable)
{
_need_context_restore = enable;
}
EAPI void *evgl_native_surface_buffer_get(EVGL_Surface *sfc, Eina_Bool *is_egl_image);
EAPI int evgl_native_surface_yinvert_get(EVGL_Surface *sfc);
EAPI void *evgl_current_native_context_get(EVGL_Context *ctx);
+EAPI void evas_gl_common_context_restore_set(Eina_Bool);
typedef void (*EVGL_Engine_Call)(void *eng_data);
typedef void *(*EVGL_Native_Surface_Call)(void *sfc, Eina_Bool *is_egl_image);
#include "config.h"
+#include "shader/evas_gl_shaders.x"
+#include "evas_gl_common.h"
+
+#define SHADER_FLAG_SAM_BITSHIFT 3
+#define SHADER_FLAG_MASKSAM_BITSHIFT 6
+#define SHADER_PROG_NAME_FMT "/shader/%08x"
+#define SHADER_BINARY_EET_COMPRESS 1
+#define SHADER_EET_CHECKSUM "/shader/checksum"
+#define SHADER_EET_CACHENAME "binary_shader"
+
+#define P(i) ((void*)(intptr_t)i)
+#define I(p) ((int)(intptr_t)p)
+
#ifdef WORDS_BIGENDIAN
-# include "shader/evas_gl_shaders_bigendian.x"
+# define BASEFLAG SHADER_FLAG_BIGENDIAN
#else
-# include "shader/evas_gl_shaders.x"
+# define BASEFLAG 0
#endif
-/////////////////////////////////////////////
+typedef enum {
+ SHADER_FLAG_TEX = (1 << 0),
+ SHADER_FLAG_BGRA = (1 << 1),
+ SHADER_FLAG_MASK = (1 << 2),
+ SHADER_FLAG_SAM12 = (1 << (SHADER_FLAG_SAM_BITSHIFT + 0)),
+ SHADER_FLAG_SAM21 = (1 << (SHADER_FLAG_SAM_BITSHIFT + 1)),
+ SHADER_FLAG_SAM22 = (1 << (SHADER_FLAG_SAM_BITSHIFT + 2)),
+ SHADER_FLAG_MASKSAM12 = (1 << (SHADER_FLAG_MASKSAM_BITSHIFT + 0)),
+ SHADER_FLAG_MASKSAM21 = (1 << (SHADER_FLAG_MASKSAM_BITSHIFT + 1)),
+ SHADER_FLAG_MASKSAM22 = (1 << (SHADER_FLAG_MASKSAM_BITSHIFT + 2)),
+ SHADER_FLAG_IMG = (1 << 9),
+ SHADER_FLAG_BIGENDIAN = (1 << 10),
+ SHADER_FLAG_YUV = (1 << 11),
+ SHADER_FLAG_YUY2 = (1 << 12),
+ SHADER_FLAG_NV12 = (1 << 13),
+ SHADER_FLAG_YUV_709 = (1 << 14),
+ SHADER_FLAG_EXTERNAL = (1 << 15),
+ SHADER_FLAG_AFILL = (1 << 16),
+ SHADER_FLAG_NOMUL = (1 << 17),
+ SHADER_FLAG_ALPHA = (1 << 18),
+ SHADER_FLAG_RGB_A_PAIR = (1 << 19),
+} Shader_Flag;
+#define SHADER_FLAG_COUNT 20
+
+static const char *_shader_flags[SHADER_FLAG_COUNT] = {
+ "TEX",
+ "BGRA",
+ "MASK",
+ "SAM12",
+ "SAM21",
+ "SAM22",
+ "MASKSAM12",
+ "MASKSAM21",
+ "MASKSAM22",
+ "IMG",
+ "BIGENDIAN",
+ "YUV",
+ "YUY2",
+ "NV12",
+ "YUV_709",
+ "EXTERNAL",
+ "AFILL",
+ "NOMUL",
+ "ALPHA",
+ "RGB_A_PAIR"
+};
+
+static Eina_Bool compiler_released = EINA_FALSE;
+
static void
-gl_compile_link_error(GLuint target, const char *action)
+gl_compile_link_error(GLuint target, const char *action, Eina_Bool is_shader)
{
int loglen = 0, chars = 0;
char *logtxt;
- /* Shader info log */
- glGetShaderiv(target, GL_INFO_LOG_LENGTH, &loglen);
- if (loglen > 0)
- {
- logtxt = calloc(loglen, sizeof(char));
- if (logtxt)
- {
- glGetShaderInfoLog(target, loglen, &chars, logtxt);
- ERR("Failed to %s: %s", action, logtxt);
- free(logtxt);
- }
- }
+ if (is_shader)
+ /* Shader info log */
+ glGetShaderiv(target, GL_INFO_LOG_LENGTH, &loglen);
+ else
+ /* Program info log */
+ glGetProgramiv(target, GL_INFO_LOG_LENGTH, &loglen);
- /* Program info log */
- glGetProgramiv(target, GL_INFO_LOG_LENGTH, &loglen);
if (loglen > 0)
{
logtxt = calloc(loglen, sizeof(char));
if (logtxt)
{
- glGetProgramInfoLog(target, loglen, &chars, logtxt);
+ if (is_shader) glGetShaderInfoLog(target, loglen, &chars, logtxt);
+ else glGetProgramInfoLog(target, loglen, &chars, logtxt);
ERR("Failed to %s: %s", action, logtxt);
free(logtxt);
}
}
}
-static int
-_evas_gl_common_shader_program_binary_init(Evas_GL_Program *p,
- const char *pname,
- Eet_File *ef)
+static Evas_GL_Program *
+_evas_gl_common_shader_program_binary_load(Eet_File *ef, unsigned int flags)
{
- int res = 0, num = 0, length = 0;
+ int num = 0, length = 0;
int *formats = NULL;
void *data = NULL;
- GLint ok = 0;
+ char pname[32];
+ GLint ok = 0, prg, vtx = GL_NONE, frg = GL_NONE;
+ Evas_GL_Program *p = NULL;
+ Eina_Bool direct = 1;
- if (!ef) return res;
+ if (!ef || !glsym_glProgramBinary) return NULL;
- data = eet_read(ef, pname, &length);
+ sprintf(pname, SHADER_PROG_NAME_FMT, flags);
+ data = (void *) eet_read_direct(ef, pname, &length);
+ if (!data)
+ {
+ data = eet_read(ef, pname, &length);
+ direct = 0;
+ }
if ((!data) || (length <= 0)) goto finish;
glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &num);
glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, formats);
if (!formats[0]) goto finish;
- p->prog = glCreateProgram();
-
+ prg = glCreateProgram();
#if 1
// TODO: invalid rendering error occurs when attempting to use a
// glProgramBinary. in order to render correctly we should create a dummy
// vertex shader.
- p->vert = glCreateShader(GL_VERTEX_SHADER);
- glAttachShader(p->prog, p->vert);
- p->frag = glCreateShader(GL_FRAGMENT_SHADER);
- glAttachShader(p->prog, p->frag);
+ vtx = glCreateShader(GL_VERTEX_SHADER);
+ glAttachShader(prg, vtx);
+ frg = glCreateShader(GL_FRAGMENT_SHADER);
+ glAttachShader(prg, frg);
#endif
- glsym_glProgramBinary(p->prog, formats[0], data, length);
-
- glBindAttribLocation(p->prog, SHAD_VERTEX, "vertex");
- glBindAttribLocation(p->prog, SHAD_COLOR, "color");
- glBindAttribLocation(p->prog, SHAD_TEXUV, "tex_coord");
- glBindAttribLocation(p->prog, SHAD_TEXUV2, "tex_coord2");
- glBindAttribLocation(p->prog, SHAD_TEXUV3, "tex_coord3");
- glBindAttribLocation(p->prog, SHAD_TEXA, "tex_coorda");
- glBindAttribLocation(p->prog, SHAD_TEXSAM, "tex_sample");
- glBindAttribLocation(p->prog, SHAD_MASK, "mask_coord");
- glBindAttribLocation(p->prog, SHAD_MASKSAM, "tex_masksample");
-
- glGetProgramiv(p->prog, GL_LINK_STATUS, &ok);
+ glsym_glProgramBinary(prg, formats[0], data, length);
+
+ glBindAttribLocation(prg, SHAD_VERTEX, "vertex");
+ glBindAttribLocation(prg, SHAD_COLOR, "color");
+ glBindAttribLocation(prg, SHAD_TEXUV, "tex_coord");
+ glBindAttribLocation(prg, SHAD_TEXUV2, "tex_coord2");
+ glBindAttribLocation(prg, SHAD_TEXUV3, "tex_coord3");
+ glBindAttribLocation(prg, SHAD_TEXA, "tex_coorda");
+ glBindAttribLocation(prg, SHAD_TEXSAM, "tex_sample");
+ glBindAttribLocation(prg, SHAD_MASK, "mask_coord");
+ glBindAttribLocation(prg, SHAD_MASKSAM, "tex_masksample");
+
+ glGetProgramiv(prg, GL_LINK_STATUS, &ok);
if (!ok)
{
- gl_compile_link_error(p->prog, "load a program object");
+ gl_compile_link_error(prg, "load a program object", EINA_FALSE);
ERR("Abort load of program (%s)", pname);
+ glDeleteProgram(prg);
goto finish;
}
- res = 1;
+ p = calloc(1, sizeof(*p));
+ p->flags = flags;
+ p->prog = prg;
+ p->reset = EINA_TRUE;
+ p->bin_saved = EINA_TRUE;
+ evas_gl_common_shader_textures_bind(p);
finish:
- if (formats) free(formats);
- if (data) free(data);
- if ((!res) && (p->prog))
- {
- glDeleteProgram(p->prog);
- p->prog = 0;
- }
- return res;
+ if (vtx) glDeleteShader(vtx);
+ if (frg) glDeleteShader(frg);
+ free(formats);
+ if (!direct) free(data);
+ return p;
}
static int
-_evas_gl_common_shader_program_binary_save(Evas_GL_Program *p,
- const char *pname,
- Eet_File *ef)
+_evas_gl_common_shader_program_binary_save(Evas_GL_Program *p, Eet_File *ef)
{
void* data = NULL;
GLenum format;
int length = 0, size = 0;
+ char pname[32];
if (!glsym_glGetProgramBinary) return 0;
return 0;
}
- if (eet_write(ef, pname, data, length, 1) < 0)
+ sprintf(pname, SHADER_PROG_NAME_FMT, p->flags);
+ if (eet_write(ef, pname, data, length, SHADER_BINARY_EET_COMPRESS) < 0)
{
- if (data) free(data);
+ free(data);
return 0;
}
- if (data) free(data);
+
+ free(data);
+ p->bin_saved = 1;
return 1;
}
-static int
-_evas_gl_common_shader_program_source_init(Evas_GL_Program *p,
- const char *vert,
- const char *frag,
- const char *name)
+static void
+_evas_gl_common_shader_binary_hash(Evas_GL_Shared *shared)
{
- GLint ok;
-
- p->vert = glCreateShader(GL_VERTEX_SHADER);
- p->frag = glCreateShader(GL_FRAGMENT_SHADER);
-
- glShaderSource(p->vert, 1, &vert, NULL);
- glCompileShader(p->vert);
- ok = 0;
- glGetShaderiv(p->vert, GL_COMPILE_STATUS, &ok);
- if (!ok)
- {
- gl_compile_link_error(p->vert, "compile vertex shader");
- ERR("Abort compile of shader vert (%s): %s", name, vert);
- return 0;
- }
- glShaderSource(p->frag, 1, &frag, NULL);
- glCompileShader(p->frag);
- ok = 0;
- glGetShaderiv(p->frag, GL_COMPILE_STATUS, &ok);
- if (!ok)
- {
- gl_compile_link_error(p->frag, "compile fragment shader");
- ERR("Abort compile of shader frag (%s): %s", name, frag);
- return 0;
- }
-
- p->prog = glCreateProgram();
-#ifdef GL_GLES
-#else
- if ((glsym_glGetProgramBinary) && (glsym_glProgramParameteri))
- {
- glsym_glProgramParameteri(p->prog, GL_PROGRAM_BINARY_RETRIEVABLE_HINT,
- GL_TRUE);
- }
-#endif
- glAttachShader(p->prog, p->vert);
- glAttachShader(p->prog, p->frag);
-
- glBindAttribLocation(p->prog, SHAD_VERTEX, "vertex");
- glBindAttribLocation(p->prog, SHAD_COLOR, "color");
- glBindAttribLocation(p->prog, SHAD_TEXUV, "tex_coord");
- glBindAttribLocation(p->prog, SHAD_TEXUV2, "tex_coord2");
- glBindAttribLocation(p->prog, SHAD_TEXUV3, "tex_coord3");
- glBindAttribLocation(p->prog, SHAD_TEXA, "tex_coorda");
- glBindAttribLocation(p->prog, SHAD_TEXSAM, "tex_sample");
- glBindAttribLocation(p->prog, SHAD_MASK, "mask_coord");
- glBindAttribLocation(p->prog, SHAD_MASKSAM, "tex_masksample");
-
- glLinkProgram(p->prog);
- ok = 0;
- glGetProgramiv(p->prog, GL_LINK_STATUS, &ok);
- if (!ok)
- {
- gl_compile_link_error(p->prog, "link fragment and vertex shaders");
- ERR("Abort compile of shader frag (%s): %s", name, frag);
- ERR("Abort compile of shader vert (%s): %s", name, vert);
- return 0;
- }
+ if (shared->shaders_checksum)
+ return;
+
+ /* This hash makes it sure that if the shaders code changes, then we
+ * will not reuse the old binaries. */
+ shared->shaders_checksum = eina_stringshare_printf
+ ("%#x:%#x",
+ eina_hash_superfast(fragment_glsl, strlen(fragment_glsl)),
+ eina_hash_superfast(vertex_glsl, strlen(vertex_glsl)));
+}
- return 1;
+static Eina_Bool
+_evas_gl_common_shader_binary_checksum_check(Evas_GL_Shared *shared, Eet_File *ef)
+{
+ Eina_Bool ret = EINA_FALSE;
+ const char *old_hash;
+ int len = 0;
+
+ if (!ef) return EINA_FALSE;
+ _evas_gl_common_shader_binary_hash(shared);
+ old_hash = eet_read_direct(ef, SHADER_EET_CHECKSUM, &len);
+ if (old_hash &&
+ (len == (eina_stringshare_strlen(shared->shaders_checksum) + 1)) &&
+ (!strcmp(shared->shaders_checksum, old_hash)))
+ ret = EINA_TRUE;
+
+ return ret;
}
-static int
-_evas_gl_common_shader_source_init(Evas_GL_Shared *shared)
+static Eina_Bool
+_evas_gl_common_shader_binary_checksum_write(Evas_GL_Shared *shared, Eet_File *ef)
{
- unsigned int i;
+ int ret, len;
- for (i = 0; i < sizeof (_shaders_source) / sizeof (_shaders_source[0]); i++)
- {
- if (!_evas_gl_common_shader_program_source_init
- (&(shared->shader[_shaders_source[i].id]),
- _shaders_source[i].vert,
- _shaders_source[i].frag,
- _shaders_source[i].name))
- return 0;
- }
- return 1;
+ if (!ef) return EINA_FALSE;
+ _evas_gl_common_shader_binary_hash(shared);
+ len = eina_stringshare_strlen(shared->shaders_checksum) + 1;
+ ret = eet_write(ef, SHADER_EET_CHECKSUM, shared->shaders_checksum, len, 0);
+
+ return (ret == len);
}
static int
_evas_gl_common_shader_binary_init(Evas_GL_Shared *shared)
{
- /* check eet */
- Eet_File *et = NULL;
+ Eet_File *ef = NULL;
char bin_dir_path[PATH_MAX];
char bin_file_path[PATH_MAX];
- unsigned int i;
+
+ if (!shared || !shared->info.bin_program)
+ return 1;
+
+ if (shared->shaders_cache)
+ return 1;
if (!evas_gl_common_file_cache_dir_check(bin_dir_path, sizeof(bin_dir_path)))
- return 0;
+ return 0;
- if (!evas_gl_common_file_cache_file_check(bin_dir_path, "binary_shader", bin_file_path,
- sizeof(bin_dir_path)))
- return 0;
+ if (!evas_gl_common_file_cache_file_check(bin_dir_path, SHADER_EET_CACHENAME,
+ bin_file_path, sizeof(bin_dir_path)))
+ return 0;
- /* use eet */
if (!eet_init()) return 0;
- et = eet_open(bin_file_path, EET_FILE_MODE_READ);
- if (!et) goto error;
-
- for (i = 0; i < sizeof (_shaders_source) / sizeof (_shaders_source[0]); ++i)
- if (!_evas_gl_common_shader_program_binary_init(&(shared->shader[_shaders_source[i].id]),
- _shaders_source[i].name,
- et))
- goto error;
+ ef = eet_open(bin_file_path, EET_FILE_MODE_READ);
+ if (!_evas_gl_common_shader_binary_checksum_check(shared, ef))
+ goto error;
- if (et) eet_close(et);
- eet_shutdown();
+ shared->shaders_cache = ef;
return 1;
error:
- if (et) eet_close(et);
+ if (ef) eet_close(ef);
eet_shutdown();
return 0;
}
static int
_evas_gl_common_shader_binary_save(Evas_GL_Shared *shared)
{
- /* check eet */
- Eet_File *et = NULL; //check eet file
- int tmpfd;
- int res = 0;
- char bin_dir_path[PATH_MAX] = {0,};
- char bin_file_path[PATH_MAX] = {0,};
- char tmp_file[PATH_MAX] = {0,};
- unsigned int i;
+ char bin_dir_path[PATH_MAX];
+ char bin_file_path[PATH_MAX];
+ char tmp_file_name[PATH_MAX];
+ int tmpfd = -1, copy;
+ Eina_Tmpstr *tmp_file_path = NULL;
+ Eet_File *ef = NULL;
+ Evas_GL_Program *p;
+ Eina_Iterator *it;
+ char pname[32];
+
+ /* use eet */
+ if (!eet_init()) return 0;
if (!evas_gl_common_file_cache_dir_check(bin_dir_path, sizeof(bin_dir_path)))
{
- if (bin_dir_path[0] != '\0')
- res = evas_gl_common_file_cache_mkpath(bin_dir_path);
-
- if (!res) return 0; /* we can't make directory */
+ if (!evas_gl_common_file_cache_mkpath(bin_dir_path))
+ return 0; /* we can't make directory */
}
- evas_gl_common_file_cache_file_check(bin_dir_path, "binary_shader", bin_file_path,
- sizeof(bin_dir_path));
+ copy = evas_gl_common_file_cache_file_check(bin_dir_path, SHADER_EET_CACHENAME,
+ bin_file_path, sizeof(bin_dir_path));
/* use mkstemp for writing */
- snprintf(tmp_file, sizeof(tmp_file), "%s.XXXXXX", bin_file_path);
+ snprintf(tmp_file_name, sizeof(tmp_file_name), "%s.XXXXXX.cache", bin_file_path);
+ tmpfd = eina_file_mkstemp(tmp_file_name, &tmp_file_path);
+ if (tmpfd < 0) goto error;
-#ifndef _WIN32
- mode_t old_umask = umask(S_IRWXG|S_IRWXO);
-#endif
- tmpfd = mkstemp(tmp_file);
-#ifndef _WIN32
- umask(old_umask);
-#endif
+ /* copy old file */
+ if (copy)
+ {
+ ef = eet_open(tmp_file_path, EET_FILE_MODE_READ);
+ if (!ef) goto save;
+ if (!_evas_gl_common_shader_binary_checksum_check(shared, ef))
+ copy = EINA_FALSE;
+ eet_close(ef);
+ if (copy)
+ eina_file_copy(bin_file_path, tmp_file_path, EINA_FILE_COPY_DATA, NULL, NULL);
+ }
- if (tmpfd < 0) goto error;
- close(tmpfd);
+save:
+ ef = eet_open(tmp_file_path, copy ? EET_FILE_MODE_READ_WRITE : EET_FILE_MODE_WRITE);
+ if (!ef) goto error;
- /* use eet */
- if (!eet_init()) goto error;
+ if (!_evas_gl_common_shader_binary_checksum_write(shared, ef))
+ goto error;
- et = eet_open(tmp_file, EET_FILE_MODE_WRITE);
- if (!et) goto error;
+ it = eina_hash_iterator_data_new(shared->shaders_hash);
+ EINA_ITERATOR_FOREACH(it, p)
+ {
+ if (!p->bin_saved)
+ {
+ int len = 0;
+ sprintf(pname, SHADER_PROG_NAME_FMT, p->flags);
+ eet_read_direct(ef, pname, &len);
+ if (len > 0)
+ p->bin_saved = 1; // assume bin data is correct
+ else
+ _evas_gl_common_shader_program_binary_save(p, ef);
+ }
+ }
+ eina_iterator_free(it);
- for (i = 0; i < sizeof (_shaders_source) / sizeof (_shaders_source[0]); ++i)
- if (!_evas_gl_common_shader_program_binary_save(&(shared->shader[_shaders_source[i].id]),
- _shaders_source[i].name,
- et))
- goto error;
+ if (shared->shaders_cache)
+ {
+ eet_close(shared->shaders_cache);
+ shared->shaders_cache = NULL;
+ eet_shutdown();
+ }
- if (eet_close(et) != EET_ERROR_NONE) goto error;
- if (rename(tmp_file,bin_file_path) < 0) goto error;
+ if (eet_close(ef) != EET_ERROR_NONE) goto destroyed;
+ if (rename(tmp_file_path, bin_file_path) < 0) goto destroyed;
+ eina_tmpstr_del(tmp_file_path);
+ close(tmpfd);
eet_shutdown();
+
+ shared->needs_shaders_flush = 0;
return 1;
-error:
- if (et) eet_close(et);
- if (evas_gl_common_file_cache_file_exists(tmp_file)) unlink(tmp_file);
+ destroyed:
+ ef = NULL;
+
+ error:
+ if (tmpfd >= 0) close(tmpfd);
+ if (ef) eet_close(ef);
+ if (evas_gl_common_file_cache_file_exists(tmp_file_path))
+ unlink(tmp_file_path);
+ eina_tmpstr_del(tmp_file_path);
eet_shutdown();
return 0;
}
+static inline void
+_program_del(Evas_GL_Program *p)
+{
+ if (p->prog) glDeleteProgram(p->prog);
+ free(p);
+}
+
+static void
+_shaders_hash_free_cb(void *data)
+{
+ _program_del(data);
+}
+
+static char *
+evas_gl_common_shader_glsl_get(unsigned int flags, const char *base)
+{
+ Eina_Strbuf *s = eina_strbuf_new();
+ unsigned int k;
+ char *str;
+
+ for (k = 0; k < SHADER_FLAG_COUNT; k++)
+ {
+ if (flags & (1 << k))
+ eina_strbuf_append_printf(s, "#define SHD_%s\n", _shader_flags[k]);
+ }
+
+ eina_strbuf_append(s, base);
+ str = eina_strbuf_string_steal(s);
+ eina_strbuf_free(s);
+ return str;
+}
+
+static Evas_GL_Program *
+evas_gl_common_shader_compile(unsigned int flags, const char *vertex,
+ const char *fragment)
+{
+ Evas_GL_Program *p;
+ GLuint vtx, frg, prg;
+ GLint ok = 0;
+
+ compiler_released = EINA_FALSE;
+ vtx = glCreateShader(GL_VERTEX_SHADER);
+ frg = glCreateShader(GL_FRAGMENT_SHADER);
+
+ glShaderSource(vtx, 1, &vertex, NULL);
+ glCompileShader(vtx);
+ glGetShaderiv(vtx, GL_COMPILE_STATUS, &ok);
+ if (!ok)
+ {
+ gl_compile_link_error(vtx, "compile vertex shader", EINA_TRUE);
+ ERR("Abort compile of vertex shader:\n%s", vertex);
+ glDeleteShader(vtx);
+ return NULL;
+ }
+ ok = 0;
+
+ glShaderSource(frg, 1, &fragment, NULL);
+ glCompileShader(frg);
+ glGetShaderiv(frg, GL_COMPILE_STATUS, &ok);
+ if (!ok)
+ {
+ gl_compile_link_error(frg, "compile fragment shader", EINA_TRUE);
+ ERR("Abort compile of fragment shader:\n%s", fragment);
+ glDeleteShader(vtx);
+ glDeleteShader(frg);
+ return NULL;
+ }
+ ok = 0;
+
+ prg = glCreateProgram();
+#ifndef GL_GLES
+ if ((glsym_glGetProgramBinary) && (glsym_glProgramParameteri))
+ glsym_glProgramParameteri(prg, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
+#endif
+ glAttachShader(prg, vtx);
+ glAttachShader(prg, frg);
+
+ glBindAttribLocation(prg, SHAD_VERTEX, "vertex");
+ glBindAttribLocation(prg, SHAD_COLOR, "color");
+ glBindAttribLocation(prg, SHAD_TEXUV, "tex_coord");
+ glBindAttribLocation(prg, SHAD_TEXUV2, "tex_coord2");
+ glBindAttribLocation(prg, SHAD_TEXUV3, "tex_coord3");
+ glBindAttribLocation(prg, SHAD_TEXA, "tex_coorda");
+ glBindAttribLocation(prg, SHAD_TEXSAM, "tex_sample");
+ glBindAttribLocation(prg, SHAD_MASK, "mask_coord");
+ glBindAttribLocation(prg, SHAD_MASKSAM, "tex_masksample");
+
+ glLinkProgram(prg);
+ glGetProgramiv(prg, GL_LINK_STATUS, &ok);
+ if (!ok)
+ {
+ gl_compile_link_error(prg, "link fragment and vertex shaders", EINA_FALSE);
+ ERR("Abort compile of shader (flags: %08x)", flags);
+ glDeleteShader(vtx);
+ glDeleteShader(frg);
+ glDeleteProgram(prg);
+ return 0;
+ }
+
+ p = calloc(1, sizeof(*p));
+ p->flags = flags;
+ p->prog = prg;
+ p->reset = EINA_TRUE;
+
+ glDeleteShader(vtx);
+ glDeleteShader(frg);
+
+ return p;
+}
+
+static Eina_List *
+evas_gl_common_shader_precompile_list(Evas_GL_Shared *shared)
+{
+ int bgra, mask, sam, masksam, img, nomul, afill, yuv;
+ Eina_List *li = NULL;
+
+ if (!shared) return NULL;
+
+ // rect
+ li = eina_list_append(li, P(BASEFLAG));
+
+ // text
+ for (mask = 0; mask <= 1; mask++)
+ for (masksam = SHD_SAM11; masksam < (mask ? SHD_SAM_LAST : 1); masksam++)
+ {
+ int flags = BASEFLAG | SHADER_FLAG_TEX | SHADER_FLAG_ALPHA;
+ if (mask) flags |= SHADER_FLAG_MASK;
+ if (masksam) flags |= (1 << (SHADER_FLAG_MASKSAM_BITSHIFT + masksam - 1));
+ li = eina_list_append(li, P(flags));
+ }
+
+ // images
+ for (mask = 0; mask <= 1; mask++)
+ for (masksam = SHD_SAM11; masksam < (mask ? SHD_SAM_LAST : 1); masksam++)
+ for (sam = SHD_SAM11; sam < SHD_SAM_LAST; sam++)
+ for (bgra = 0; bgra <= shared->info.bgra; bgra++)
+ for (img = 0; img <= 1; img++)
+ for (nomul = 0; nomul <= 1; nomul++)
+ for (afill = 0; afill <= (mask ? 0 : 1); afill++)
+ {
+ int flags = BASEFLAG | SHADER_FLAG_TEX;
+ if (mask) flags |= SHADER_FLAG_MASK;
+ if (masksam) flags |= (1 << (SHADER_FLAG_MASKSAM_BITSHIFT + masksam - 1));
+ if (sam) flags |= (1 << (SHADER_FLAG_SAM_BITSHIFT + sam - 1));
+ if (bgra) flags |= SHADER_FLAG_BGRA;
+ if (img) flags |= SHADER_FLAG_IMG;
+ if (nomul) flags |= SHADER_FLAG_NOMUL;
+ if (afill) flags |= SHADER_FLAG_AFILL;
+ li = eina_list_append(li, P(flags));
+ }
+
+ // yuv
+ for (yuv = SHADER_FLAG_YUV; yuv <= SHADER_FLAG_YUV_709; yuv *= 2)
+ for (mask = 0; mask <= 1; mask++)
+ for (masksam = SHD_SAM11; masksam < (mask ? SHD_SAM_LAST : 1); masksam++)
+ for (nomul = 0; nomul <= 1; nomul++)
+ {
+ int flags = BASEFLAG | SHADER_FLAG_TEX | yuv;
+ if (mask) flags |= SHADER_FLAG_MASK;
+ if (masksam) flags |= (1 << (SHADER_FLAG_MASKSAM_BITSHIFT + masksam - 1));
+ if (yuv == SHADER_FLAG_YUV_709) flags |= SHADER_FLAG_YUV;
+ if (nomul) flags |= SHADER_FLAG_NOMUL;
+ li = eina_list_append(li, P(flags));
+ }
+
+ // rgb+a pair, external, and others will not be precompiled.
+
+ DBG("Built list of %d shaders to precompile", eina_list_count(li));
+ return li;
+}
+
+static Evas_GL_Program *
+evas_gl_common_shader_generate_and_compile(Evas_GL_Shared *shared, unsigned int flags)
+{
+ char *vertex, *fragment;
+ Evas_GL_Program *p;
+
+ if (eina_hash_find(shared->shaders_hash, &flags))
+ return NULL;
+
+ vertex = evas_gl_common_shader_glsl_get(flags, vertex_glsl);
+ fragment = evas_gl_common_shader_glsl_get(flags, fragment_glsl);
+
+ p = evas_gl_common_shader_compile(flags, vertex, fragment);
+ if (p)
+ {
+ shared->needs_shaders_flush = 1;
+ evas_gl_common_shader_textures_bind(p);
+ eina_hash_add(shared->shaders_hash, &flags, p);
+ }
+ else WRN("Failed to compile a shader (flags: %08x)", flags);
+
+ free(vertex);
+ free(fragment);
+
+ return p;
+}
+
+static int
+evas_gl_common_shader_precompile_all(Evas_GL_Shared *shared)
+{
+ Eina_List *li = evas_gl_common_shader_precompile_list(shared);
+ Evas_GL_Program *p;
+ int total, cnt = 0;
+ void *data;
+
+ total = eina_list_count(li);
+ EINA_LIST_FREE(li, data)
+ {
+ p = evas_gl_common_shader_generate_and_compile(shared, I(data));
+ if (p)
+ {
+ p->delete_me = 1;
+ cnt++;
+ }
+ }
+
+ DBG("Precompiled %d/%d shaders!", cnt, total);
+ return cnt;
+}
+
int
evas_gl_common_shader_program_init(Evas_GL_Shared *shared)
{
- // gl support binary shader and get env of binary shader path
- if (shared->info.bin_program &&
- _evas_gl_common_shader_binary_init(shared)) return 1;
- /* compile all shader.*/
- if (!_evas_gl_common_shader_source_init(shared)) return 0;
- /* success compile all shader. if gl support binary shader, we need to save */
- if (shared->info.bin_program) _evas_gl_common_shader_binary_save(shared);
+ /* most popular shaders */
+ const int BGRA = (shared->info.bgra ? SHADER_FLAG_BGRA : 0);
+ const int autoload[] = {
+ /* rect */ BASEFLAG,
+ /* text */ BASEFLAG | SHADER_FLAG_TEX | SHADER_FLAG_ALPHA,
+ /* img1 */ BASEFLAG | SHADER_FLAG_TEX | SHADER_FLAG_IMG | BGRA,
+ /* img2 */ BASEFLAG | SHADER_FLAG_TEX | SHADER_FLAG_IMG | SHADER_FLAG_NOMUL | BGRA,
+ };
+ Evas_GL_Program *p;
+ unsigned i;
+
+ shared->shaders_hash = eina_hash_int32_new(_shaders_hash_free_cb);
+ if (_evas_gl_common_shader_binary_init(shared))
+ {
+ for (i = 0; i < (sizeof(autoload) / sizeof(autoload[0])); i++)
+ {
+ p = _evas_gl_common_shader_program_binary_load(shared->shaders_cache, autoload[i]);
+ if (p)
+ {
+ evas_gl_common_shader_textures_bind(p);
+ eina_hash_add(shared->shaders_hash, &autoload[i], p);
+ }
+ }
+ }
+ else
+ {
+ evas_gl_common_shader_precompile_all(shared);
+ for (i = 0; i < (sizeof(autoload) / sizeof(autoload[0])); i++)
+ {
+ p = eina_hash_find(shared->shaders_hash, &autoload[i]);
+ if (p) p->delete_me = 0;
+ }
+ evas_gl_common_shaders_flush(shared);
+ }
+
return 1;
}
-void
-evas_gl_common_shader_program_init_done(void)
+EAPI void
+evas_gl_common_shaders_flush(Evas_GL_Shared *shared)
{
+
+ if (!shared) return;
+ if (!compiler_released)
+ {
+ compiler_released = EINA_TRUE;
#ifdef GL_GLES
- glReleaseShaderCompiler();
+ glReleaseShaderCompiler();
#else
- if (glsym_glReleaseShaderCompiler)
- glsym_glReleaseShaderCompiler();
+ if (glsym_glReleaseShaderCompiler)
+ glsym_glReleaseShaderCompiler();
#endif
+ }
+ if (shared->needs_shaders_flush)
+ {
+ Eina_List *to_delete = NULL;
+ Eina_Iterator *it;
+ Evas_GL_Program *p;
+
+ _evas_gl_common_shader_binary_save(shared);
+
+ it = eina_hash_iterator_data_new(shared->shaders_hash);
+ EINA_ITERATOR_FOREACH(it, p)
+ {
+ if (p->delete_me)
+ to_delete = eina_list_append(to_delete, p);
+ }
+
+ EINA_LIST_FREE(to_delete, p)
+ eina_hash_del(shared->shaders_hash, &p->flags, p);
+ }
}
void
-evas_gl_common_shader_program_shutdown(Evas_GL_Program *p)
+evas_gl_common_shader_program_shutdown(Evas_GL_Shared *shared)
{
- if (p->vert) glDeleteShader(p->vert);
- if (p->frag) glDeleteShader(p->frag);
- if (p->prog) glDeleteProgram(p->prog);
+ if (!shared) return;
+
+ if (shared->needs_shaders_flush)
+ evas_gl_common_shaders_flush(shared);
+
+ if (shared->shaders_cache)
+ {
+ eet_close(shared->shaders_cache);
+ shared->shaders_cache = NULL;
+ eet_shutdown();
+ }
+
+ eina_hash_free(shared->shaders_hash);
+ shared->shaders_hash = NULL;
}
-Evas_GL_Shader
-evas_gl_common_img_shader_select(Shader_Type type, Shader_Sampling sam, int nomul, int afill, int bgra, int mask, int masksam)
+static inline unsigned int
+evas_gl_common_shader_flags_get(Evas_GL_Shared *shared, Shader_Type type,
+ RGBA_Map_Point *map_points, int npoints,
+ int r, int g, int b, int a,
+ int sw, int sh, int w, int h, Eina_Bool smooth,
+ Evas_GL_Texture *tex, Eina_Bool tex_only,
+ Evas_GL_Texture *mtex, Eina_Bool mask_smooth,
+ int mw, int mh,
+ Shader_Sampling *psam, int *pnomul, Shader_Sampling *pmasksam)
{
- // 256 combinaisons including many impossible
- static Evas_GL_Shader _shaders[4 * 2 * 2 * 2 * 2 * 4 * 2];
- static Eina_Bool init = EINA_FALSE;
- int idx;
+ Shader_Sampling sam = SHD_SAM11, masksam = SHD_SAM11;
+ int nomul = 1, bgra = 0, k;
+ unsigned int flags = BASEFLAG;
+
+ // image downscale sampling
+ if (smooth && ((type == SHD_IMAGE) || (type == SHD_IMAGENATIVE)))
+ {
+ if ((sw >= (w * 2)) && (sh >= (h * 2)))
+ sam = SHD_SAM22;
+ else if (sw >= (w * 2))
+ sam = SHD_SAM21;
+ else if (sh >= (h * 2))
+ sam = SHD_SAM12;
+ if (sam)
+ flags |= (1 << (SHADER_FLAG_SAM_BITSHIFT + sam - 1));
+ }
+
+ // mask downscale sampling
+ if (mtex && mask_smooth)
+ {
+ if ((mtex->w >= (mw * 2)) && (mtex->h >= (mh * 2)))
+ masksam = SHD_SAM22;
+ else if (mtex->w >= (mw * 2))
+ masksam = SHD_SAM21;
+ else if (mtex->h >= (mh * 2))
+ masksam = SHD_SAM12;
+ if (masksam)
+ flags |= (1 << (SHADER_FLAG_MASKSAM_BITSHIFT + masksam - 1));
+ }
- if (EINA_UNLIKELY(!init))
+ switch (type)
{
- unsigned int k;
+ case SHD_RECT:
+ case SHD_LINE:
+ goto end;
+ case SHD_FONT:
+ flags |= (SHADER_FLAG_ALPHA | SHADER_FLAG_TEX);
+ goto end;
+ case SHD_IMAGE:
+ flags |= SHADER_FLAG_IMG;
+ break;
+ case SHD_IMAGENATIVE:
+ break;
+ case SHD_YUV:
+ flags |= SHADER_FLAG_YUV;
+ break;
+ case SHD_YUY2:
+ flags |= SHADER_FLAG_YUY2;
+ break;
+ case SHD_NV12:
+ flags |= SHADER_FLAG_NV12;
+ break;
+ case SHD_YUV_709:
+ flags |= (SHADER_FLAG_YUV_709 | SHADER_FLAG_YUV);
+ break;
+ case SHD_RGB_A_PAIR:
+ case SHD_MAP:
+ break;
+ default:
+ CRI("Impossible shader type.");
+ return 0;
+ }
+
+ // color mul
+ if ((a == 255) && (r == 255) && (g == 255) && (b == 255))
+ {
+ if (map_points)
+ {
+ for (k = 0; k < npoints; k++)
+ if (map_points[k].col != 0xffffffff)
+ {
+ nomul = 0;
+ break;
+ }
+ }
+ }
+ else
+ nomul = 0;
- init = EINA_TRUE;
- for (k = 0; k < (sizeof(_shaders) / sizeof(_shaders[0])); k++)
- _shaders[k] = SHADER_IMG;
+ if (nomul)
+ flags |= SHADER_FLAG_NOMUL;
- for (k = 0; k < (sizeof(_shaders_source) / sizeof(_shaders_source[0])); k++)
+ // bgra
+ if (tex_only)
+ {
+ if (tex->im && tex->im->native.target == GL_TEXTURE_EXTERNAL_OES)
+ flags |= SHADER_FLAG_EXTERNAL;
+ else
+ bgra = 1;
+ }
+ else
+ bgra = shared->info.bgra;
+
+// This is only bug and fixed by upstream. AFILL flag is SET only for external images with No alpha
+ if (tex)
+ {
+ flags |= SHADER_FLAG_TEX;
+ if (!tex->alpha && tex_only)
{
- if (_shaders_source[k].type == SHD_IMAGE)
- {
- idx = _shaders_source[k].sam << 6; // 2 bits
- idx |= _shaders_source[k].masksam << 4; // 2 bits
- idx |= _shaders_source[k].bgra << 3; // bool
- idx |= _shaders_source[k].mask << 2; // bool
- idx |= _shaders_source[k].nomul << 1; // bool
- idx |= _shaders_source[k].afill; // bool
- _shaders[idx] = _shaders_source[k].id;
- }
- else if (_shaders_source[k].type == SHD_IMAGENATIVE)
+ if ((flags & SHADER_FLAG_EXTERNAL) || tex->pt->dyn.img)
+ flags |= SHADER_FLAG_AFILL;
+ }
+ }
+//
+
+ if (mtex)
+ flags |= SHADER_FLAG_MASK;
+
+ if (bgra)
+ flags |= SHADER_FLAG_BGRA;
+
+end:
+ if (psam) *psam = sam;
+ if (pnomul) *pnomul = nomul;
+ if (pmasksam) *pmasksam = masksam;
+ return flags;
+}
+
+void
+evas_gl_common_shader_textures_bind(Evas_GL_Program *p)
+{
+ struct {
+ const char *name;
+ int enabled;
+ } textures[] = {
+ { "tex", 0 },
+ { "texm", 0 },
+ { "texa", 0 },
+ { "texu", 0 },
+ { "texv", 0 },
+ { "texuv", 0 },
+ { NULL, 0 }
+ };
+ Eina_Bool hastex = 0;
+ GLint loc;
+ int i;
+
+ if (!p || (p->tex_count > 0)) return;
+
+ if ((p->flags & SHADER_FLAG_TEX) != 0)
+ {
+ textures[0].enabled = 1;
+ hastex = 1;
+ }
+ if ((p->flags & SHADER_FLAG_MASK) != 0)
+ {
+ textures[1].enabled = 1;
+ hastex = 1;
+ }
+ if ((p->flags & SHADER_FLAG_RGB_A_PAIR) != 0)
+ {
+ textures[2].enabled = 1;
+ hastex = 1;
+ }
+ if (p->flags & SHADER_FLAG_YUV)
+ {
+ textures[3].enabled = 1;
+ textures[4].enabled = 1;
+ hastex = 1;
+ }
+ else if ((p->flags & SHADER_FLAG_NV12) || (p->flags & SHADER_FLAG_YUY2))
+ {
+ textures[5].enabled = 1;
+ hastex = 1;
+ }
+
+ if (hastex)
+ {
+ glUseProgram(p->prog); // is this necessary??
+ for (i = 0; textures[i].name; i++)
+ {
+ if (!textures[i].enabled) continue;
+ loc = glGetUniformLocation(p->prog, textures[i].name);
+ if (loc < 0)
{
- idx = _shaders_source[k].sam << 6; // 2 bits
- idx |= _shaders_source[k].masksam << 4; // 2 bits
- idx |= _shaders_source[k].bgra << 3; // bool
- idx |= _shaders_source[k].mask << 2; // bool
- idx |= _shaders_source[k].nomul << 1; // bool
- idx |= _shaders_source[k].afill; // bool
- idx += (4 * 2 * 2 * 2 * 2 * 4);
- _shaders[idx] = _shaders_source[k].id;
+ ERR("Couldn't find uniform '%s' (shader: %08x)",
+ textures[i].name, p->flags);
}
+ glUniform1i(loc, p->tex_count++);
}
}
-
- idx = sam << 6;
- idx |= masksam << 4;
- idx |= bgra << 3;
- idx |= mask << 2;
- idx |= nomul << 1;
- idx |= afill;
- if (type == SHD_IMAGENATIVE) idx += (4 * 2 * 2 * 2 * 2 * 4);
- return _shaders[idx];
}
-const char *
-evas_gl_common_shader_name_get(Evas_GL_Shader shd)
+Evas_GL_Program *
+evas_gl_common_shader_program_get(Evas_Engine_GL_Context *gc,
+ Shader_Type type,
+ RGBA_Map_Point *map_points, int npoints,
+ int r, int g, int b, int a,
+ int sw, int sh, int w, int h, Eina_Bool smooth,
+ Evas_GL_Texture *tex, Eina_Bool tex_only,
+ Evas_GL_Texture *mtex, Eina_Bool mask_smooth,
+ int mw, int mh,
+ Shader_Sampling *psam, int *pnomul,
+ Shader_Sampling *pmasksam)
{
- if (shd < (sizeof(_shaders_source) / sizeof(_shaders_source[0])))
- return _shaders_source[shd].name;
- return "UNKNOWN";
+ unsigned int flags;
+ Evas_GL_Program *p;
+
+ flags = evas_gl_common_shader_flags_get(gc->shared, type, map_points, npoints, r, g, b, a,
+ sw, sh, w, h, smooth, tex, tex_only,
+ mtex, mask_smooth, mw, mh,
+ psam, pnomul, pmasksam);
+ p = eina_hash_find(gc->shared->shaders_hash, &flags);
+ if (!p)
+ {
+ _evas_gl_common_shader_binary_init(gc->shared);
+ if (gc->shared->shaders_cache)
+ {
+ char pname[32];
+ sprintf(pname, SHADER_PROG_NAME_FMT, flags);
+ p = _evas_gl_common_shader_program_binary_load(gc->shared->shaders_cache, flags);
+ if (p)
+ {
+ evas_gl_common_shader_textures_bind(p);
+ eina_hash_add(gc->shared->shaders_hash, &flags, p);
+ goto end;
+ }
+ }
+ p = evas_gl_common_shader_generate_and_compile(gc->shared, flags);
+ if (!p) return NULL;
+ }
+end:
+ if (p->hitcount < PROGRAM_HITCOUNT_MAX)
+ p->hitcount++;
+ return p;
}
+++ /dev/null
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-/* IF IT IS CHANGED PLEASE COMMIT THE CHANGES */
-
-typedef enum {
- SHADER_RECT,
- SHADER_RECT_MASK,
- SHADER_RECT_MASK12,
- SHADER_RECT_MASK21,
- SHADER_RECT_MASK22,
- SHADER_FONT,
- SHADER_FONT_MASK,
- SHADER_FONT_MASK12,
- SHADER_FONT_MASK21,
- SHADER_FONT_MASK22,
- SHADER_IMG,
- SHADER_IMG_BGRA,
- SHADER_IMG_12,
- SHADER_IMG_21,
- SHADER_IMG_22,
- SHADER_IMG_12_BGRA,
- SHADER_IMG_21_BGRA,
- SHADER_IMG_22_BGRA,
- SHADER_IMG_MASK,
- SHADER_IMG_BGRA_MASK,
- SHADER_IMG_12_MASK,
- SHADER_IMG_21_MASK,
- SHADER_IMG_22_MASK,
- SHADER_IMG_12_BGRA_MASK,
- SHADER_IMG_21_BGRA_MASK,
- SHADER_IMG_22_BGRA_MASK,
- SHADER_IMG_NOMUL,
- SHADER_IMG_BGRA_NOMUL,
- SHADER_IMG_12_NOMUL,
- SHADER_IMG_21_NOMUL,
- SHADER_IMG_22_NOMUL,
- SHADER_IMG_12_BGRA_NOMUL,
- SHADER_IMG_21_BGRA_NOMUL,
- SHADER_IMG_22_BGRA_NOMUL,
- SHADER_IMG_MASK_NOMUL,
- SHADER_IMG_BGRA_MASK_NOMUL,
- SHADER_IMG_12_MASK_NOMUL,
- SHADER_IMG_21_MASK_NOMUL,
- SHADER_IMG_22_MASK_NOMUL,
- SHADER_IMG_12_BGRA_MASK_NOMUL,
- SHADER_IMG_21_BGRA_MASK_NOMUL,
- SHADER_IMG_22_BGRA_MASK_NOMUL,
- SHADER_IMG_MASK12,
- SHADER_IMG_BGRA_MASK12,
- SHADER_IMG_12_MASK12,
- SHADER_IMG_21_MASK12,
- SHADER_IMG_22_MASK12,
- SHADER_IMG_12_BGRA_MASK12,
- SHADER_IMG_21_BGRA_MASK12,
- SHADER_IMG_22_BGRA_MASK12,
- SHADER_IMG_MASK12_NOMUL,
- SHADER_IMG_BGRA_MASK12_NOMUL,
- SHADER_IMG_12_MASK12_NOMUL,
- SHADER_IMG_21_MASK12_NOMUL,
- SHADER_IMG_22_MASK12_NOMUL,
- SHADER_IMG_12_BGRA_MASK12_NOMUL,
- SHADER_IMG_21_BGRA_MASK12_NOMUL,
- SHADER_IMG_22_BGRA_MASK12_NOMUL,
- SHADER_IMG_MASK21,
- SHADER_IMG_BGRA_MASK21,
- SHADER_IMG_12_MASK21,
- SHADER_IMG_21_MASK21,
- SHADER_IMG_22_MASK21,
- SHADER_IMG_12_BGRA_MASK21,
- SHADER_IMG_21_BGRA_MASK21,
- SHADER_IMG_22_BGRA_MASK21,
- SHADER_IMG_MASK21_NOMUL,
- SHADER_IMG_BGRA_MASK21_NOMUL,
- SHADER_IMG_12_MASK21_NOMUL,
- SHADER_IMG_21_MASK21_NOMUL,
- SHADER_IMG_22_MASK21_NOMUL,
- SHADER_IMG_12_BGRA_MASK21_NOMUL,
- SHADER_IMG_21_BGRA_MASK21_NOMUL,
- SHADER_IMG_22_BGRA_MASK21_NOMUL,
- SHADER_IMG_MASK22,
- SHADER_IMG_BGRA_MASK22,
- SHADER_IMG_12_MASK22,
- SHADER_IMG_21_MASK22,
- SHADER_IMG_22_MASK22,
- SHADER_IMG_12_BGRA_MASK22,
- SHADER_IMG_21_BGRA_MASK22,
- SHADER_IMG_22_BGRA_MASK22,
- SHADER_IMG_MASK22_NOMUL,
- SHADER_IMG_BGRA_MASK22_NOMUL,
- SHADER_IMG_12_MASK22_NOMUL,
- SHADER_IMG_21_MASK22_NOMUL,
- SHADER_IMG_22_MASK22_NOMUL,
- SHADER_IMG_12_BGRA_MASK22_NOMUL,
- SHADER_IMG_21_BGRA_MASK22_NOMUL,
- SHADER_IMG_22_BGRA_MASK22_NOMUL,
- SHADER_IMG_AFILL,
- SHADER_IMG_BGRA_AFILL,
- SHADER_IMG_NOMUL_AFILL,
- SHADER_IMG_BGRA_NOMUL_AFILL,
- SHADER_IMG_12_AFILL,
- SHADER_IMG_21_AFILL,
- SHADER_IMG_22_AFILL,
- SHADER_IMG_12_BGRA_AFILL,
- SHADER_IMG_21_BGRA_AFILL,
- SHADER_IMG_22_BGRA_AFILL,
- SHADER_IMG_12_NOMUL_AFILL,
- SHADER_IMG_21_NOMUL_AFILL,
- SHADER_IMG_22_NOMUL_AFILL,
- SHADER_IMG_12_BGRA_NOMUL_AFILL,
- SHADER_IMG_21_BGRA_NOMUL_AFILL,
- SHADER_IMG_22_BGRA_NOMUL_AFILL,
- SHADER_IMGNAT,
- SHADER_IMGNAT_BGRA,
- SHADER_IMGNAT_12,
- SHADER_IMGNAT_21,
- SHADER_IMGNAT_22,
- SHADER_IMGNAT_12_BGRA,
- SHADER_IMGNAT_21_BGRA,
- SHADER_IMGNAT_22_BGRA,
- SHADER_IMGNAT_MASK,
- SHADER_IMGNAT_BGRA_MASK,
- SHADER_IMGNAT_12_MASK,
- SHADER_IMGNAT_21_MASK,
- SHADER_IMGNAT_22_MASK,
- SHADER_IMGNAT_12_BGRA_MASK,
- SHADER_IMGNAT_21_BGRA_MASK,
- SHADER_IMGNAT_22_BGRA_MASK,
- SHADER_IMGNAT_NOMUL,
- SHADER_IMGNAT_BGRA_NOMUL,
- SHADER_IMGNAT_12_NOMUL,
- SHADER_IMGNAT_21_NOMUL,
- SHADER_IMGNAT_22_NOMUL,
- SHADER_IMGNAT_12_BGRA_NOMUL,
- SHADER_IMGNAT_21_BGRA_NOMUL,
- SHADER_IMGNAT_22_BGRA_NOMUL,
- SHADER_IMGNAT_MASK_NOMUL,
- SHADER_IMGNAT_BGRA_MASK_NOMUL,
- SHADER_IMGNAT_12_MASK_NOMUL,
- SHADER_IMGNAT_21_MASK_NOMUL,
- SHADER_IMGNAT_22_MASK_NOMUL,
- SHADER_IMGNAT_12_BGRA_MASK_NOMUL,
- SHADER_IMGNAT_21_BGRA_MASK_NOMUL,
- SHADER_IMGNAT_22_BGRA_MASK_NOMUL,
- SHADER_IMGNAT_MASK12,
- SHADER_IMGNAT_BGRA_MASK12,
- SHADER_IMGNAT_12_MASK12,
- SHADER_IMGNAT_21_MASK12,
- SHADER_IMGNAT_22_MASK12,
- SHADER_IMGNAT_12_BGRA_MASK12,
- SHADER_IMGNAT_21_BGRA_MASK12,
- SHADER_IMGNAT_22_BGRA_MASK12,
- SHADER_IMGNAT_MASK12_NOMUL,
- SHADER_IMGNAT_BGRA_MASK12_NOMUL,
- SHADER_IMGNAT_12_MASK12_NOMUL,
- SHADER_IMGNAT_21_MASK12_NOMUL,
- SHADER_IMGNAT_22_MASK12_NOMUL,
- SHADER_IMGNAT_12_BGRA_MASK12_NOMUL,
- SHADER_IMGNAT_21_BGRA_MASK12_NOMUL,
- SHADER_IMGNAT_22_BGRA_MASK12_NOMUL,
- SHADER_IMGNAT_MASK21,
- SHADER_IMGNAT_BGRA_MASK21,
- SHADER_IMGNAT_12_MASK21,
- SHADER_IMGNAT_21_MASK21,
- SHADER_IMGNAT_22_MASK21,
- SHADER_IMGNAT_12_BGRA_MASK21,
- SHADER_IMGNAT_21_BGRA_MASK21,
- SHADER_IMGNAT_22_BGRA_MASK21,
- SHADER_IMGNAT_MASK21_NOMUL,
- SHADER_IMGNAT_BGRA_MASK21_NOMUL,
- SHADER_IMGNAT_12_MASK21_NOMUL,
- SHADER_IMGNAT_21_MASK21_NOMUL,
- SHADER_IMGNAT_22_MASK21_NOMUL,
- SHADER_IMGNAT_12_BGRA_MASK21_NOMUL,
- SHADER_IMGNAT_21_BGRA_MASK21_NOMUL,
- SHADER_IMGNAT_22_BGRA_MASK21_NOMUL,
- SHADER_IMGNAT_MASK22,
- SHADER_IMGNAT_BGRA_MASK22,
- SHADER_IMGNAT_12_MASK22,
- SHADER_IMGNAT_21_MASK22,
- SHADER_IMGNAT_22_MASK22,
- SHADER_IMGNAT_12_BGRA_MASK22,
- SHADER_IMGNAT_21_BGRA_MASK22,
- SHADER_IMGNAT_22_BGRA_MASK22,
- SHADER_IMGNAT_MASK22_NOMUL,
- SHADER_IMGNAT_BGRA_MASK22_NOMUL,
- SHADER_IMGNAT_12_MASK22_NOMUL,
- SHADER_IMGNAT_21_MASK22_NOMUL,
- SHADER_IMGNAT_22_MASK22_NOMUL,
- SHADER_IMGNAT_12_BGRA_MASK22_NOMUL,
- SHADER_IMGNAT_21_BGRA_MASK22_NOMUL,
- SHADER_IMGNAT_22_BGRA_MASK22_NOMUL,
- SHADER_IMGNAT_AFILL,
- SHADER_IMGNAT_BGRA_AFILL,
- SHADER_IMGNAT_NOMUL_AFILL,
- SHADER_IMGNAT_BGRA_NOMUL_AFILL,
- SHADER_IMGNAT_12_AFILL,
- SHADER_IMGNAT_21_AFILL,
- SHADER_IMGNAT_22_AFILL,
- SHADER_IMGNAT_12_BGRA_AFILL,
- SHADER_IMGNAT_21_BGRA_AFILL,
- SHADER_IMGNAT_22_BGRA_AFILL,
- SHADER_IMGNAT_12_NOMUL_AFILL,
- SHADER_IMGNAT_21_NOMUL_AFILL,
- SHADER_IMGNAT_22_NOMUL_AFILL,
- SHADER_IMGNAT_12_BGRA_NOMUL_AFILL,
- SHADER_IMGNAT_21_BGRA_NOMUL_AFILL,
- SHADER_IMGNAT_22_BGRA_NOMUL_AFILL,
- SHADER_RGB_A_PAIR,
- SHADER_RGB_A_PAIR_MASK,
- SHADER_RGB_A_PAIR_NOMUL,
- SHADER_RGB_A_PAIR_MASK_NOMUL,
- SHADER_TEX_EXTERNAL,
- SHADER_TEX_EXTERNAL_AFILL,
- SHADER_TEX_EXTERNAL_NOMUL,
- SHADER_TEX_EXTERNAL_NOMUL_AFILL,
- SHADER_TEX_EXTERNAL_MASK,
- SHADER_TEX_EXTERNAL_MASK_NOMUL,
- SHADER_YUV,
- SHADER_YUV_NOMUL,
- SHADER_YUV_MASK,
- SHADER_YUV_MASK_NOMUL,
- SHADER_YUY2,
- SHADER_YUY2_NOMUL,
- SHADER_YUY2_MASK,
- SHADER_YUY2_MASK_NOMUL,
- SHADER_NV12,
- SHADER_NV12_NOMUL,
- SHADER_NV12_MASK,
- SHADER_NV12_MASK_NOMUL,
- SHADER_YUV_709,
- SHADER_YUV_709_NOMUL,
- SHADER_YUV_709_MASK,
- SHADER_YUV_709_MASK_NOMUL,
- SHADER_YUY2_709,
- SHADER_YUY2_709_NOMUL,
- SHADER_YUY2_709_MASK,
- SHADER_YUY2_709_MASK_NOMUL,
- SHADER_NV12_709,
- SHADER_NV12_709_NOMUL,
- SHADER_NV12_709_MASK,
- SHADER_NV12_709_MASK_NOMUL,
- SHADER_LAST
-} Evas_GL_Shader;
-
-#ifdef _EVAS_GL_CONTEXT_C
-
-static struct {
- Evas_GL_Shader id;
- const char *tname;
-} _shaders_textures[] = {
- { SHADER_FONT_MASK, "tex" },
- { SHADER_FONT_MASK, "texm" },
- { SHADER_FONT_MASK12, "tex" },
- { SHADER_FONT_MASK12, "texm" },
- { SHADER_FONT_MASK21, "tex" },
- { SHADER_FONT_MASK21, "texm" },
- { SHADER_FONT_MASK22, "tex" },
- { SHADER_FONT_MASK22, "texm" },
- { SHADER_IMG_MASK, "tex" },
- { SHADER_IMG_MASK, "texm" },
- { SHADER_IMG_BGRA_MASK, "tex" },
- { SHADER_IMG_BGRA_MASK, "texm" },
- { SHADER_IMG_12_MASK, "tex" },
- { SHADER_IMG_12_MASK, "texm" },
- { SHADER_IMG_21_MASK, "tex" },
- { SHADER_IMG_21_MASK, "texm" },
- { SHADER_IMG_22_MASK, "tex" },
- { SHADER_IMG_22_MASK, "texm" },
- { SHADER_IMG_12_BGRA_MASK, "tex" },
- { SHADER_IMG_12_BGRA_MASK, "texm" },
- { SHADER_IMG_21_BGRA_MASK, "tex" },
- { SHADER_IMG_21_BGRA_MASK, "texm" },
- { SHADER_IMG_22_BGRA_MASK, "tex" },
- { SHADER_IMG_22_BGRA_MASK, "texm" },
- { SHADER_IMG_MASK_NOMUL, "tex" },
- { SHADER_IMG_MASK_NOMUL, "texm" },
- { SHADER_IMG_BGRA_MASK_NOMUL, "tex" },
- { SHADER_IMG_BGRA_MASK_NOMUL, "texm" },
- { SHADER_IMG_12_MASK_NOMUL, "tex" },
- { SHADER_IMG_12_MASK_NOMUL, "texm" },
- { SHADER_IMG_21_MASK_NOMUL, "tex" },
- { SHADER_IMG_21_MASK_NOMUL, "texm" },
- { SHADER_IMG_22_MASK_NOMUL, "tex" },
- { SHADER_IMG_22_MASK_NOMUL, "texm" },
- { SHADER_IMG_12_BGRA_MASK_NOMUL, "tex" },
- { SHADER_IMG_12_BGRA_MASK_NOMUL, "texm" },
- { SHADER_IMG_21_BGRA_MASK_NOMUL, "tex" },
- { SHADER_IMG_21_BGRA_MASK_NOMUL, "texm" },
- { SHADER_IMG_22_BGRA_MASK_NOMUL, "tex" },
- { SHADER_IMG_22_BGRA_MASK_NOMUL, "texm" },
- { SHADER_IMG_MASK12, "tex" },
- { SHADER_IMG_MASK12, "texm" },
- { SHADER_IMG_BGRA_MASK12, "tex" },
- { SHADER_IMG_BGRA_MASK12, "texm" },
- { SHADER_IMG_12_MASK12, "tex" },
- { SHADER_IMG_12_MASK12, "texm" },
- { SHADER_IMG_21_MASK12, "tex" },
- { SHADER_IMG_21_MASK12, "texm" },
- { SHADER_IMG_22_MASK12, "tex" },
- { SHADER_IMG_22_MASK12, "texm" },
- { SHADER_IMG_12_BGRA_MASK12, "tex" },
- { SHADER_IMG_12_BGRA_MASK12, "texm" },
- { SHADER_IMG_21_BGRA_MASK12, "tex" },
- { SHADER_IMG_21_BGRA_MASK12, "texm" },
- { SHADER_IMG_22_BGRA_MASK12, "tex" },
- { SHADER_IMG_22_BGRA_MASK12, "texm" },
- { SHADER_IMG_MASK12_NOMUL, "tex" },
- { SHADER_IMG_MASK12_NOMUL, "texm" },
- { SHADER_IMG_BGRA_MASK12_NOMUL, "tex" },
- { SHADER_IMG_BGRA_MASK12_NOMUL, "texm" },
- { SHADER_IMG_12_MASK12_NOMUL, "tex" },
- { SHADER_IMG_12_MASK12_NOMUL, "texm" },
- { SHADER_IMG_21_MASK12_NOMUL, "tex" },
- { SHADER_IMG_21_MASK12_NOMUL, "texm" },
- { SHADER_IMG_22_MASK12_NOMUL, "tex" },
- { SHADER_IMG_22_MASK12_NOMUL, "texm" },
- { SHADER_IMG_12_BGRA_MASK12_NOMUL, "tex" },
- { SHADER_IMG_12_BGRA_MASK12_NOMUL, "texm" },
- { SHADER_IMG_21_BGRA_MASK12_NOMUL, "tex" },
- { SHADER_IMG_21_BGRA_MASK12_NOMUL, "texm" },
- { SHADER_IMG_22_BGRA_MASK12_NOMUL, "tex" },
- { SHADER_IMG_22_BGRA_MASK12_NOMUL, "texm" },
- { SHADER_IMG_MASK21, "tex" },
- { SHADER_IMG_MASK21, "texm" },
- { SHADER_IMG_BGRA_MASK21, "tex" },
- { SHADER_IMG_BGRA_MASK21, "texm" },
- { SHADER_IMG_12_MASK21, "tex" },
- { SHADER_IMG_12_MASK21, "texm" },
- { SHADER_IMG_21_MASK21, "tex" },
- { SHADER_IMG_21_MASK21, "texm" },
- { SHADER_IMG_22_MASK21, "tex" },
- { SHADER_IMG_22_MASK21, "texm" },
- { SHADER_IMG_12_BGRA_MASK21, "tex" },
- { SHADER_IMG_12_BGRA_MASK21, "texm" },
- { SHADER_IMG_21_BGRA_MASK21, "tex" },
- { SHADER_IMG_21_BGRA_MASK21, "texm" },
- { SHADER_IMG_22_BGRA_MASK21, "tex" },
- { SHADER_IMG_22_BGRA_MASK21, "texm" },
- { SHADER_IMG_MASK21_NOMUL, "tex" },
- { SHADER_IMG_MASK21_NOMUL, "texm" },
- { SHADER_IMG_BGRA_MASK21_NOMUL, "tex" },
- { SHADER_IMG_BGRA_MASK21_NOMUL, "texm" },
- { SHADER_IMG_12_MASK21_NOMUL, "tex" },
- { SHADER_IMG_12_MASK21_NOMUL, "texm" },
- { SHADER_IMG_21_MASK21_NOMUL, "tex" },
- { SHADER_IMG_21_MASK21_NOMUL, "texm" },
- { SHADER_IMG_22_MASK21_NOMUL, "tex" },
- { SHADER_IMG_22_MASK21_NOMUL, "texm" },
- { SHADER_IMG_12_BGRA_MASK21_NOMUL, "tex" },
- { SHADER_IMG_12_BGRA_MASK21_NOMUL, "texm" },
- { SHADER_IMG_21_BGRA_MASK21_NOMUL, "tex" },
- { SHADER_IMG_21_BGRA_MASK21_NOMUL, "texm" },
- { SHADER_IMG_22_BGRA_MASK21_NOMUL, "tex" },
- { SHADER_IMG_22_BGRA_MASK21_NOMUL, "texm" },
- { SHADER_IMG_MASK22, "tex" },
- { SHADER_IMG_MASK22, "texm" },
- { SHADER_IMG_BGRA_MASK22, "tex" },
- { SHADER_IMG_BGRA_MASK22, "texm" },
- { SHADER_IMG_12_MASK22, "tex" },
- { SHADER_IMG_12_MASK22, "texm" },
- { SHADER_IMG_21_MASK22, "tex" },
- { SHADER_IMG_21_MASK22, "texm" },
- { SHADER_IMG_22_MASK22, "tex" },
- { SHADER_IMG_22_MASK22, "texm" },
- { SHADER_IMG_12_BGRA_MASK22, "tex" },
- { SHADER_IMG_12_BGRA_MASK22, "texm" },
- { SHADER_IMG_21_BGRA_MASK22, "tex" },
- { SHADER_IMG_21_BGRA_MASK22, "texm" },
- { SHADER_IMG_22_BGRA_MASK22, "tex" },
- { SHADER_IMG_22_BGRA_MASK22, "texm" },
- { SHADER_IMG_MASK22_NOMUL, "tex" },
- { SHADER_IMG_MASK22_NOMUL, "texm" },
- { SHADER_IMG_BGRA_MASK22_NOMUL, "tex" },
- { SHADER_IMG_BGRA_MASK22_NOMUL, "texm" },
- { SHADER_IMG_12_MASK22_NOMUL, "tex" },
- { SHADER_IMG_12_MASK22_NOMUL, "texm" },
- { SHADER_IMG_21_MASK22_NOMUL, "tex" },
- { SHADER_IMG_21_MASK22_NOMUL, "texm" },
- { SHADER_IMG_22_MASK22_NOMUL, "tex" },
- { SHADER_IMG_22_MASK22_NOMUL, "texm" },
- { SHADER_IMG_12_BGRA_MASK22_NOMUL, "tex" },
- { SHADER_IMG_12_BGRA_MASK22_NOMUL, "texm" },
- { SHADER_IMG_21_BGRA_MASK22_NOMUL, "tex" },
- { SHADER_IMG_21_BGRA_MASK22_NOMUL, "texm" },
- { SHADER_IMG_22_BGRA_MASK22_NOMUL, "tex" },
- { SHADER_IMG_22_BGRA_MASK22_NOMUL, "texm" },
- { SHADER_IMGNAT_MASK, "tex" },
- { SHADER_IMGNAT_MASK, "texm" },
- { SHADER_IMGNAT_BGRA_MASK, "tex" },
- { SHADER_IMGNAT_BGRA_MASK, "texm" },
- { SHADER_IMGNAT_12_MASK, "tex" },
- { SHADER_IMGNAT_12_MASK, "texm" },
- { SHADER_IMGNAT_21_MASK, "tex" },
- { SHADER_IMGNAT_21_MASK, "texm" },
- { SHADER_IMGNAT_22_MASK, "tex" },
- { SHADER_IMGNAT_22_MASK, "texm" },
- { SHADER_IMGNAT_12_BGRA_MASK, "tex" },
- { SHADER_IMGNAT_12_BGRA_MASK, "texm" },
- { SHADER_IMGNAT_21_BGRA_MASK, "tex" },
- { SHADER_IMGNAT_21_BGRA_MASK, "texm" },
- { SHADER_IMGNAT_22_BGRA_MASK, "tex" },
- { SHADER_IMGNAT_22_BGRA_MASK, "texm" },
- { SHADER_IMGNAT_MASK_NOMUL, "tex" },
- { SHADER_IMGNAT_MASK_NOMUL, "texm" },
- { SHADER_IMGNAT_BGRA_MASK_NOMUL, "tex" },
- { SHADER_IMGNAT_BGRA_MASK_NOMUL, "texm" },
- { SHADER_IMGNAT_12_MASK_NOMUL, "tex" },
- { SHADER_IMGNAT_12_MASK_NOMUL, "texm" },
- { SHADER_IMGNAT_21_MASK_NOMUL, "tex" },
- { SHADER_IMGNAT_21_MASK_NOMUL, "texm" },
- { SHADER_IMGNAT_22_MASK_NOMUL, "tex" },
- { SHADER_IMGNAT_22_MASK_NOMUL, "texm" },
- { SHADER_IMGNAT_12_BGRA_MASK_NOMUL, "tex" },
- { SHADER_IMGNAT_12_BGRA_MASK_NOMUL, "texm" },
- { SHADER_IMGNAT_21_BGRA_MASK_NOMUL, "tex" },
- { SHADER_IMGNAT_21_BGRA_MASK_NOMUL, "texm" },
- { SHADER_IMGNAT_22_BGRA_MASK_NOMUL, "tex" },
- { SHADER_IMGNAT_22_BGRA_MASK_NOMUL, "texm" },
- { SHADER_IMGNAT_MASK12, "tex" },
- { SHADER_IMGNAT_MASK12, "texm" },
- { SHADER_IMGNAT_BGRA_MASK12, "tex" },
- { SHADER_IMGNAT_BGRA_MASK12, "texm" },
- { SHADER_IMGNAT_12_MASK12, "tex" },
- { SHADER_IMGNAT_12_MASK12, "texm" },
- { SHADER_IMGNAT_21_MASK12, "tex" },
- { SHADER_IMGNAT_21_MASK12, "texm" },
- { SHADER_IMGNAT_22_MASK12, "tex" },
- { SHADER_IMGNAT_22_MASK12, "texm" },
- { SHADER_IMGNAT_12_BGRA_MASK12, "tex" },
- { SHADER_IMGNAT_12_BGRA_MASK12, "texm" },
- { SHADER_IMGNAT_21_BGRA_MASK12, "tex" },
- { SHADER_IMGNAT_21_BGRA_MASK12, "texm" },
- { SHADER_IMGNAT_22_BGRA_MASK12, "tex" },
- { SHADER_IMGNAT_22_BGRA_MASK12, "texm" },
- { SHADER_IMGNAT_MASK12_NOMUL, "tex" },
- { SHADER_IMGNAT_MASK12_NOMUL, "texm" },
- { SHADER_IMGNAT_BGRA_MASK12_NOMUL, "tex" },
- { SHADER_IMGNAT_BGRA_MASK12_NOMUL, "texm" },
- { SHADER_IMGNAT_12_MASK12_NOMUL, "tex" },
- { SHADER_IMGNAT_12_MASK12_NOMUL, "texm" },
- { SHADER_IMGNAT_21_MASK12_NOMUL, "tex" },
- { SHADER_IMGNAT_21_MASK12_NOMUL, "texm" },
- { SHADER_IMGNAT_22_MASK12_NOMUL, "tex" },
- { SHADER_IMGNAT_22_MASK12_NOMUL, "texm" },
- { SHADER_IMGNAT_12_BGRA_MASK12_NOMUL, "tex" },
- { SHADER_IMGNAT_12_BGRA_MASK12_NOMUL, "texm" },
- { SHADER_IMGNAT_21_BGRA_MASK12_NOMUL, "tex" },
- { SHADER_IMGNAT_21_BGRA_MASK12_NOMUL, "texm" },
- { SHADER_IMGNAT_22_BGRA_MASK12_NOMUL, "tex" },
- { SHADER_IMGNAT_22_BGRA_MASK12_NOMUL, "texm" },
- { SHADER_IMGNAT_MASK21, "tex" },
- { SHADER_IMGNAT_MASK21, "texm" },
- { SHADER_IMGNAT_BGRA_MASK21, "tex" },
- { SHADER_IMGNAT_BGRA_MASK21, "texm" },
- { SHADER_IMGNAT_12_MASK21, "tex" },
- { SHADER_IMGNAT_12_MASK21, "texm" },
- { SHADER_IMGNAT_21_MASK21, "tex" },
- { SHADER_IMGNAT_21_MASK21, "texm" },
- { SHADER_IMGNAT_22_MASK21, "tex" },
- { SHADER_IMGNAT_22_MASK21, "texm" },
- { SHADER_IMGNAT_12_BGRA_MASK21, "tex" },
- { SHADER_IMGNAT_12_BGRA_MASK21, "texm" },
- { SHADER_IMGNAT_21_BGRA_MASK21, "tex" },
- { SHADER_IMGNAT_21_BGRA_MASK21, "texm" },
- { SHADER_IMGNAT_22_BGRA_MASK21, "tex" },
- { SHADER_IMGNAT_22_BGRA_MASK21, "texm" },
- { SHADER_IMGNAT_MASK21_NOMUL, "tex" },
- { SHADER_IMGNAT_MASK21_NOMUL, "texm" },
- { SHADER_IMGNAT_BGRA_MASK21_NOMUL, "tex" },
- { SHADER_IMGNAT_BGRA_MASK21_NOMUL, "texm" },
- { SHADER_IMGNAT_12_MASK21_NOMUL, "tex" },
- { SHADER_IMGNAT_12_MASK21_NOMUL, "texm" },
- { SHADER_IMGNAT_21_MASK21_NOMUL, "tex" },
- { SHADER_IMGNAT_21_MASK21_NOMUL, "texm" },
- { SHADER_IMGNAT_22_MASK21_NOMUL, "tex" },
- { SHADER_IMGNAT_22_MASK21_NOMUL, "texm" },
- { SHADER_IMGNAT_12_BGRA_MASK21_NOMUL, "tex" },
- { SHADER_IMGNAT_12_BGRA_MASK21_NOMUL, "texm" },
- { SHADER_IMGNAT_21_BGRA_MASK21_NOMUL, "tex" },
- { SHADER_IMGNAT_21_BGRA_MASK21_NOMUL, "texm" },
- { SHADER_IMGNAT_22_BGRA_MASK21_NOMUL, "tex" },
- { SHADER_IMGNAT_22_BGRA_MASK21_NOMUL, "texm" },
- { SHADER_IMGNAT_MASK22, "tex" },
- { SHADER_IMGNAT_MASK22, "texm" },
- { SHADER_IMGNAT_BGRA_MASK22, "tex" },
- { SHADER_IMGNAT_BGRA_MASK22, "texm" },
- { SHADER_IMGNAT_12_MASK22, "tex" },
- { SHADER_IMGNAT_12_MASK22, "texm" },
- { SHADER_IMGNAT_21_MASK22, "tex" },
- { SHADER_IMGNAT_21_MASK22, "texm" },
- { SHADER_IMGNAT_22_MASK22, "tex" },
- { SHADER_IMGNAT_22_MASK22, "texm" },
- { SHADER_IMGNAT_12_BGRA_MASK22, "tex" },
- { SHADER_IMGNAT_12_BGRA_MASK22, "texm" },
- { SHADER_IMGNAT_21_BGRA_MASK22, "tex" },
- { SHADER_IMGNAT_21_BGRA_MASK22, "texm" },
- { SHADER_IMGNAT_22_BGRA_MASK22, "tex" },
- { SHADER_IMGNAT_22_BGRA_MASK22, "texm" },
- { SHADER_IMGNAT_MASK22_NOMUL, "tex" },
- { SHADER_IMGNAT_MASK22_NOMUL, "texm" },
- { SHADER_IMGNAT_BGRA_MASK22_NOMUL, "tex" },
- { SHADER_IMGNAT_BGRA_MASK22_NOMUL, "texm" },
- { SHADER_IMGNAT_12_MASK22_NOMUL, "tex" },
- { SHADER_IMGNAT_12_MASK22_NOMUL, "texm" },
- { SHADER_IMGNAT_21_MASK22_NOMUL, "tex" },
- { SHADER_IMGNAT_21_MASK22_NOMUL, "texm" },
- { SHADER_IMGNAT_22_MASK22_NOMUL, "tex" },
- { SHADER_IMGNAT_22_MASK22_NOMUL, "texm" },
- { SHADER_IMGNAT_12_BGRA_MASK22_NOMUL, "tex" },
- { SHADER_IMGNAT_12_BGRA_MASK22_NOMUL, "texm" },
- { SHADER_IMGNAT_21_BGRA_MASK22_NOMUL, "tex" },
- { SHADER_IMGNAT_21_BGRA_MASK22_NOMUL, "texm" },
- { SHADER_IMGNAT_22_BGRA_MASK22_NOMUL, "tex" },
- { SHADER_IMGNAT_22_BGRA_MASK22_NOMUL, "texm" },
- { SHADER_RGB_A_PAIR, "tex" },
- { SHADER_RGB_A_PAIR, "texa" },
- { SHADER_RGB_A_PAIR_MASK, "tex" },
- { SHADER_RGB_A_PAIR_MASK, "texa" },
- { SHADER_RGB_A_PAIR_MASK, "texm" },
- { SHADER_RGB_A_PAIR_NOMUL, "tex" },
- { SHADER_RGB_A_PAIR_NOMUL, "texa" },
- { SHADER_RGB_A_PAIR_MASK_NOMUL, "tex" },
- { SHADER_RGB_A_PAIR_MASK_NOMUL, "texa" },
- { SHADER_RGB_A_PAIR_MASK_NOMUL, "texm" },
- { SHADER_YUV, "tex" },
- { SHADER_YUV, "texu" },
- { SHADER_YUV, "texv" },
- { SHADER_YUV_NOMUL, "tex" },
- { SHADER_YUV_NOMUL, "texu" },
- { SHADER_YUV_NOMUL, "texv" },
- { SHADER_YUV_MASK, "tex" },
- { SHADER_YUV_MASK, "texu" },
- { SHADER_YUV_MASK, "texv" },
- { SHADER_YUV_MASK, "texm" },
- { SHADER_YUV_MASK_NOMUL, "tex" },
- { SHADER_YUV_MASK_NOMUL, "texu" },
- { SHADER_YUV_MASK_NOMUL, "texv" },
- { SHADER_YUV_MASK_NOMUL, "texm" },
- { SHADER_YUY2, "tex" },
- { SHADER_YUY2, "texuv" },
- { SHADER_YUY2_NOMUL, "tex" },
- { SHADER_YUY2_NOMUL, "texuv" },
- { SHADER_YUY2_MASK, "tex" },
- { SHADER_YUY2_MASK, "texuv" },
- { SHADER_YUY2_MASK, "texm" },
- { SHADER_YUY2_MASK_NOMUL, "tex" },
- { SHADER_YUY2_MASK_NOMUL, "texuv" },
- { SHADER_YUY2_MASK_NOMUL, "texm" },
- { SHADER_NV12, "tex" },
- { SHADER_NV12, "texuv" },
- { SHADER_NV12_NOMUL, "tex" },
- { SHADER_NV12_NOMUL, "texuv" },
- { SHADER_NV12_MASK, "tex" },
- { SHADER_NV12_MASK, "texuv" },
- { SHADER_NV12_MASK, "texm" },
- { SHADER_NV12_MASK_NOMUL, "tex" },
- { SHADER_NV12_MASK_NOMUL, "texuv" },
- { SHADER_NV12_MASK_NOMUL, "texm" },
- { SHADER_YUV_709, "tex" },
- { SHADER_YUV_709, "texu" },
- { SHADER_YUV_709, "texv" },
- { SHADER_YUV_709_NOMUL, "tex" },
- { SHADER_YUV_709_NOMUL, "texu" },
- { SHADER_YUV_709_NOMUL, "texv" },
- { SHADER_YUV_709_MASK, "tex" },
- { SHADER_YUV_709_MASK, "texu" },
- { SHADER_YUV_709_MASK, "texv" },
- { SHADER_YUV_709_MASK, "texm" },
- { SHADER_YUV_709_MASK_NOMUL, "tex" },
- { SHADER_YUV_709_MASK_NOMUL, "texu" },
- { SHADER_YUV_709_MASK_NOMUL, "texv" },
- { SHADER_YUV_709_MASK_NOMUL, "texm" },
- { SHADER_YUY2_709, "tex" },
- { SHADER_YUY2_709, "texuv" },
- { SHADER_YUY2_709_NOMUL, "tex" },
- { SHADER_YUY2_709_NOMUL, "texuv" },
- { SHADER_YUY2_709_MASK, "tex" },
- { SHADER_YUY2_709_MASK, "texuv" },
- { SHADER_YUY2_709_MASK, "texm" },
- { SHADER_YUY2_709_MASK_NOMUL, "tex" },
- { SHADER_YUY2_709_MASK_NOMUL, "texuv" },
- { SHADER_YUY2_709_MASK_NOMUL, "texm" },
- { SHADER_NV12_709, "tex" },
- { SHADER_NV12_709, "texuv" },
- { SHADER_NV12_709_NOMUL, "tex" },
- { SHADER_NV12_709_NOMUL, "texuv" },
- { SHADER_NV12_709_MASK, "tex" },
- { SHADER_NV12_709_MASK, "texuv" },
- { SHADER_NV12_709_MASK, "texm" },
- { SHADER_NV12_709_MASK_NOMUL, "tex" },
- { SHADER_NV12_709_MASK_NOMUL, "texuv" },
- { SHADER_NV12_709_MASK_NOMUL, "texm" },
- { SHADER_LAST, NULL }
-};
-
-#endif // _EVAS_GL_CONTEXT_C
/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
/* IF IT IS CHANGED PLEASE COMMIT THE CHANGES */
-#include "../evas_gl_private.h"
-
-static const char rect_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char rect_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- "}\n";
-
-static const char rect_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char rect_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char rect_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char rect_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char rect_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char rect_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char rect_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char rect_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char font_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char font_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char font_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char font_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char font_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char font_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char font_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char font_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char font_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char font_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_12_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_12_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_21_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_22_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_12_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_21_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_22_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_12_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_21_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_22_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_12_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_21_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_22_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_12_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_12_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_21_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_22_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_12_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_21_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_22_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_12_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_21_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_22_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_12_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_21_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_22_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char rgb_a_pair_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texa;\n"
- "varying vec2 tex_a;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * texture2D(texa, tex_a).r\n"
- " ;\n"
- "}\n";
-
-static const char rgb_a_pair_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coorda;\n"
- "varying vec2 tex_a;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_a = tex_coorda;\n"
- "}\n";
-
-static const char rgb_a_pair_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texa;\n"
- "varying vec2 tex_a;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " * texture2D(texa, tex_a).r\n"
- " ;\n"
- "}\n";
-
-static const char rgb_a_pair_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coorda;\n"
- "varying vec2 tex_a;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_a = tex_coorda;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char rgb_a_pair_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texa;\n"
- "varying vec2 tex_a;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * texture2D(texa, tex_a).r\n"
- " ;\n"
- "}\n";
-
-static const char rgb_a_pair_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coorda;\n"
- "varying vec2 tex_a;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_a = tex_coorda;\n"
- "}\n";
-
-static const char rgb_a_pair_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texa;\n"
- "varying vec2 tex_a;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " * texture2D(texa, tex_a).r\n"
- " ;\n"
- "}\n";
-
-static const char rgb_a_pair_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coorda;\n"
- "varying vec2 tex_a;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_a = tex_coorda;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char tex_external_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char tex_external_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char tex_external_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char tex_external_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char tex_external_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char tex_external_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char tex_external_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char tex_external_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char tex_external_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char tex_external_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char tex_external_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char tex_external_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuv_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char yuv_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- "}\n";
-
-static const char yuv_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char yuv_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- "}\n";
-
-static const char yuv_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuv_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuv_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuv_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuy2_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- "}\n";
-
-static const char yuy2_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- "}\n";
-
-static const char yuy2_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuy2_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char nv12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char nv12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- "}\n";
-
-static const char nv12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char nv12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- "}\n";
-
-static const char nv12_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char nv12_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char nv12_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char nv12_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuv_709_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char yuv_709_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- "}\n";
-
-static const char yuv_709_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char yuv_709_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- "}\n";
-
-static const char yuv_709_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuv_709_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuv_709_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuv_709_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuy2_709_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_709_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- "}\n";
-
-static const char yuy2_709_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_709_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- "}\n";
-
-static const char yuy2_709_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_709_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuy2_709_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_709_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char nv12_709_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char nv12_709_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- "}\n";
-
-static const char nv12_709_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
+static const char fragment_glsl[] =
+ "/* General-purpose fragment shader for all operations in Evas.\n"
+ " * This file can either be used directly by evas at runtime to\n"
+ " * generate its shaders with the appropriate #defines, or passed\n"
+ " * through cpp first (in which case the precision must be manually added).\n"
+ " */\n"
+ "#ifdef GL_ES\n"
+ "# ifdef SHD_EXTERNAL\n"
+ "# extension GL_OES_EGL_image_external : require\n"
+ "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
+ "# endif\n"
+ "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
"precision highp float;\n"
- "#else\n"
+ "# else\n"
"precision mediump float;\n"
+ "# endif\n"
+ "#else\n"
+ "# define SAMPLER_EXTERNAL_OES sampler2D\n"
"#endif\n"
+ "#ifndef SHD_NOMUL\n"
+ "varying vec4 col;\n"
"#endif\n"
+ "#ifdef SHD_EXTERNAL\n"
+ "uniform SAMPLER_EXTERNAL_OES tex;\n"
+ "varying vec2 tex_c;\n"
+ "#elif defined(SHD_TEX)\n"
"uniform sampler2D tex;\n"
"varying vec2 tex_c;\n"
+ "#endif\n"
+ "#if defined(SHD_NV12) || defined(SHD_YUY2)\n"
"uniform sampler2D texuv;\n"
"varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char nv12_709_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
"#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
+ "#if defined(SHD_YUV)\n"
+ "uniform sampler2D texu;\n"
+ "uniform sampler2D texv;\n"
"varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- "}\n";
-
-static const char nv12_709_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
+ "varying vec2 tex_c3;\n"
"#endif\n"
+ "#ifdef SHD_TEXA\n"
+ "uniform sampler2D texa;\n"
+ "varying vec2 tex_a;\n"
"#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
+ "#if defined(SHD_SAM12) || defined(SHD_SAM21) || defined(SHD_SAM22)\n"
+ "varying vec4 div_s;\n"
+ "# if defined(SHD_SAM12) || defined(SHD_SAM21)\n"
+ "varying vec2 tex_s[2];\n"
+ "# else\n"
+ "varying vec2 tex_s[4];\n"
+ "# endif\n"
+ "#endif\n"
+ "#ifdef SHD_MASK\n"
"uniform sampler2D texm;\n"
"varying vec2 tex_m;\n"
+ "# if defined(SHD_MASKSAM12) || defined(SHD_MASKSAM21)\n"
+ "varying float maskdiv_s;\n"
+ "varying vec2 masktex_s[2];\n"
+ "# elif defined(SHD_MASKSAM22)\n"
+ "varying float maskdiv_s;\n"
+ "varying vec2 masktex_s[4];\n"
+ "# endif\n"
+ "#endif\n"
+ "#ifdef SHD_ALPHA\n"
+ "# define SWZ aaaa\n"
+ "#else\n"
+ "# ifndef SHD_BGRA\n"
+ "# if defined(SHD_IMG) && defined(SHD_BIGENDIAN)\n"
+ "# define SWZ gbar\n"
+ "# else\n"
+ "# define SWZ bgra\n"
+ "#endif\n"
+ "# else\n"
+ "# if defined(SHD_IMG) && defined(SHD_BIGENDIAN)\n"
+ "# define SWZ grab\n"
+ "# else\n"
+ "# define SWZ rgba\n"
+ "# endif\n"
+ "# endif\n"
+ "#endif\n"
"void main()\n"
"{\n"
" vec4 c;\n"
+ "#if defined(SHD_YUV) || defined(SHD_NV12) || defined(SHD_YUY2)\n"
" float r, g, b, y, u, v, vmu;\n"
+ "# if defined(SHD_YUV)\n"
+ " y = texture2D(tex, tex_c).r;\n"
+ " u = texture2D(texu, tex_c2).r;\n"
+ " v = texture2D(texv, tex_c3).r;\n"
+ "# elif defined(SHD_NV12) || defined(SHD_YUY2)\n"
" y = texture2D(tex, tex_c).g;\n"
" u = texture2D(texuv, tex_c2).g;\n"
" v = texture2D(texuv, tex_c2).a;\n"
+ "# endif\n"
+ "// center u and v around 0 for uv and y (with 128/255 for u + v, 16/255 for y)\n"
" u = u - 0.5;\n"
" v = v - 0.5;\n"
+ "# if defined (SHD_YUV_709)\n"
+ "// 709 yuv colorspace for hd content\n"
" y = (y - 0.062) * 1.164;\n"
" vmu = (v * 0.534) + (u * 0.213);\n"
" v = v * 1.793;\n"
" u = u * 2.115;\n"
+ "# else\n"
+ "// 601 colorspace constants (older yuv content)\n"
+ " y = (y - 0.062) * 1.164;\n"
+ " vmu = (v * 0.813) + (u * 0.391);\n"
+ " v = v * 1.596;\n"
+ " u = u * 2.018;\n"
+ "# endif\n"
+ "// common yuv\n"
" r = y + v;\n"
" g = y - vmu;\n"
" b = y + u;\n"
" c = vec4(r, g, b, 1.0);\n"
+ "#elif defined(SHD_SAM12) || defined(SHD_SAM21)\n"
+ " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).SWZ;\n"
+ " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).SWZ;\n"
+ " c = (col00 + col01) / div_s;\n"
+ "#elif defined(SHD_SAM22)\n"
+ " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).SWZ;\n"
+ " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).SWZ;\n"
+ " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).SWZ;\n"
+ " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).SWZ;\n"
+ " c = (col00 + col01 + col10 + col11) / div_s;\n"
+ "#elif defined(SHD_TEX) || defined(SHD_EXTERNAL)\n"
+ " c = texture2D(tex, tex_c).SWZ;\n"
+ "#else\n"
+ " c = vec4(1, 1, 1, 1);\n"
+ "#endif\n"
+ "#ifdef SHD_MASK\n"
" float ma;\n"
+ "# if defined(SHD_MASKSAM12) || defined(SHD_MASKSAM21)\n"
+ " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
+ " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
+ " ma = (ma00 + ma01) / maskdiv_s;\n"
+ "# elif defined(SHD_MASKSAM22)\n"
+ " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
+ " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
+ " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
+ " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
+ " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
+ "# else\n"
" ma = texture2D(texm, tex_m).a;\n"
+ "# endif\n"
+ "#endif\n"
+ "#ifdef SHD_AFILL\n"
+ " c.a = 1.0;\n"
+ "#endif\n"
" gl_FragColor =\n"
" c\n"
+ "#ifndef SHD_NOMUL\n"
" * col\n"
- " * ma\n"
+ "#endif\n"
+ "#ifdef SHD_MASK\n"
+ " * ma\n"
+ "#endif\n"
+ "#ifdef SHD_TEXA\n"
+ " * texture2D(texa, tex_a).r\n"
+ "#endif\n"
" ;\n"
"}\n";
-static const char nv12_709_mask_vert_src[] =
+static const char vertex_glsl[] =
+ "/* General-purpose vertex shader for all operations in Evas.\n"
+ " * This file can either be used directly by evas at runtime to\n"
+ " * generate its shaders with the appropriate #defines, or passed\n"
+ " * through cpp first (in which case the precision must be manually added).\n"
+ " */\n"
"#ifdef GL_ES\n"
"precision highp float;\n"
"#endif\n"
"attribute vec4 vertex;\n"
"uniform mat4 mvp;\n"
+ "/* All except nomul */\n"
+ "#ifndef SHD_NOMUL\n"
"attribute vec4 color;\n"
"varying vec4 col;\n"
+ "#endif\n"
+ "/* All images & fonts */\n"
+ "#if defined(SHD_TEX) || defined(SHD_EXTERNAL)\n"
"attribute vec2 tex_coord;\n"
"varying vec2 tex_c;\n"
+ "#endif\n"
+ "/* NV12, YUY2 */\n"
+ "#if defined(SHD_NV12) || defined(SHD_YUY2) || defined(SHD_YUV)\n"
"attribute vec2 tex_coord2;\n"
"varying vec2 tex_c2;\n"
+ "#endif\n"
+ "/* YUV */\n"
+ "#ifdef SHD_YUV\n"
+ "attribute vec2 tex_coord3;\n"
+ "varying vec2 tex_c3;\n"
+ "#endif\n"
+ "/* RGB+A */\n"
+ "#ifdef SHD_TEXA\n"
+ "attribute vec2 tex_coorda;\n"
+ "varying vec2 tex_a;\n"
+ "#endif\n"
+ "/* Sampling */\n"
+ "#if defined(SHD_SAM12) || defined(SHD_SAM21) || defined(SHD_SAM22)\n"
+ "attribute vec2 tex_sample;\n"
+ "varying vec4 div_s;\n"
+ "# if defined(SHD_SAM12) || defined(SHD_SAM21)\n"
+ "varying vec2 tex_s[2];\n"
+ "# else\n"
+ "varying vec2 tex_s[4];\n"
+ "# endif\n"
+ "#endif\n"
+ "/* Masking */\n"
+ "#ifdef SHD_MASK\n"
"attribute vec4 mask_coord;\n"
"varying vec2 tex_m;\n"
+ "# if defined(SHD_MASKSAM12) || defined(SHD_MASKSAM21)\n"
+ "attribute vec2 tex_masksample;\n"
+ "varying float maskdiv_s;\n"
+ "varying vec2 masktex_s[2];\n"
+ "# elif defined(SHD_MASKSAM22)\n"
+ "attribute vec2 tex_masksample;\n"
+ "varying float maskdiv_s;\n"
+ "varying vec2 masktex_s[4];\n"
+ "# endif\n"
+ "#endif\n"
"void main()\n"
"{\n"
" gl_Position = mvp * vertex;\n"
+ "#ifndef SHD_NOMUL\n"
" col = color;\n"
+ "#endif\n"
+ "#if defined(SHD_TEX) || defined(SHD_EXTERNAL)\n"
" tex_c = tex_coord;\n"
+ "#endif\n"
+ "#ifdef SHD_NV12\n"
" tex_c2 = tex_coord2 * 0.5;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char nv12_709_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
"#endif\n"
+ "#ifdef SHD_YUY2\n"
+ " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
"#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char nv12_709_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
+ "#ifdef SHD_YUV\n"
+ " tex_c2 = tex_coord2;\n"
+ " tex_c3 = tex_coord3;\n"
"#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
+ "#ifdef SHD_TEXA\n"
+ " tex_a = tex_coorda;\n"
+ "#endif\n"
+ "#if defined(SHD_SAM12)\n"
+ " tex_s[0] = vec2(0, -tex_sample.y);\n"
+ " tex_s[1] = vec2(0, tex_sample.y);\n"
+ " div_s = vec4(2, 2, 2, 2);\n"
+ "#elif defined(SHD_SAM21)\n"
+ " tex_s[0] = vec2(-tex_sample.x, 0);\n"
+ " tex_s[1] = vec2( tex_sample.x, 0);\n"
+ " div_s = vec4(2, 2, 2, 2);\n"
+ "#elif defined(SHD_SAM22)\n"
+ " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
+ " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
+ " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
+ " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
+ " div_s = vec4(4, 4, 4, 4);\n"
+ "#endif\n"
+ "#if defined(SHD_MASKSAM12)\n"
+ " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
+ " masktex_s[1] = vec2(0, tex_masksample.y);\n"
+ " maskdiv_s = 2.0;\n"
+ "#elif defined(SHD_MASKSAM21)\n"
+ " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
+ " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
+ " maskdiv_s = 2.0;\n"
+ "#elif defined(SHD_MASKSAM22)\n"
+ " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
+ " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
+ " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
+ " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
+ " maskdiv_s = 4.0;\n"
+ "#endif\n"
+ "#ifdef SHD_MASK\n"
+ " // mask_coord.w contains the Y-invert flag\n"
+ " // position on screen in [0..1] range of current pixel\n"
" vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
" tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
+ "#endif\n"
"}\n";
-
-static const struct {
- Evas_GL_Shader id;
- const char *vert;
- const char *frag;
- const char *name;
- Shader_Type type;
- Shader_Sampling sam;
- Shader_Sampling masksam;
- Eina_Bool bgra : 1;
- Eina_Bool mask : 1;
- Eina_Bool nomul : 1;
- Eina_Bool afill : 1;
-} _shaders_source[] = {
- { SHADER_RECT, rect_vert_src, rect_frag_src, "rect", SHD_RECT, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_RECT_MASK, rect_mask_vert_src, rect_mask_frag_src, "rect_mask", SHD_RECT, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_RECT_MASK12, rect_mask12_vert_src, rect_mask12_frag_src, "rect_mask12", SHD_RECT, SHD_SAM11, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_RECT_MASK21, rect_mask21_vert_src, rect_mask21_frag_src, "rect_mask21", SHD_RECT, SHD_SAM11, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_RECT_MASK22, rect_mask22_vert_src, rect_mask22_frag_src, "rect_mask22", SHD_RECT, SHD_SAM11, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_FONT, font_vert_src, font_frag_src, "font", SHD_FONT, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_FONT_MASK, font_mask_vert_src, font_mask_frag_src, "font_mask", SHD_FONT, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_FONT_MASK12, font_mask12_vert_src, font_mask12_frag_src, "font_mask12", SHD_FONT, SHD_SAM11, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_FONT_MASK21, font_mask21_vert_src, font_mask21_frag_src, "font_mask21", SHD_FONT, SHD_SAM11, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_FONT_MASK22, font_mask22_vert_src, font_mask22_frag_src, "font_mask22", SHD_FONT, SHD_SAM11, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG, img_vert_src, img_frag_src, "img", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMG_BGRA, img_bgra_vert_src, img_bgra_frag_src, "img_bgra", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMG_12, img_12_vert_src, img_12_frag_src, "img_12", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMG_21, img_21_vert_src, img_21_frag_src, "img_21", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMG_22, img_22_vert_src, img_22_frag_src, "img_22", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMG_12_BGRA, img_12_bgra_vert_src, img_12_bgra_frag_src, "img_12_bgra", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMG_21_BGRA, img_21_bgra_vert_src, img_21_bgra_frag_src, "img_21_bgra", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMG_22_BGRA, img_22_bgra_vert_src, img_22_bgra_frag_src, "img_22_bgra", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMG_MASK, img_mask_vert_src, img_mask_frag_src, "img_mask", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMG_BGRA_MASK, img_bgra_mask_vert_src, img_bgra_mask_frag_src, "img_bgra_mask", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMG_12_MASK, img_12_mask_vert_src, img_12_mask_frag_src, "img_12_mask", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMG_21_MASK, img_21_mask_vert_src, img_21_mask_frag_src, "img_21_mask", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMG_22_MASK, img_22_mask_vert_src, img_22_mask_frag_src, "img_22_mask", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMG_12_BGRA_MASK, img_12_bgra_mask_vert_src, img_12_bgra_mask_frag_src, "img_12_bgra_mask", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMG_21_BGRA_MASK, img_21_bgra_mask_vert_src, img_21_bgra_mask_frag_src, "img_21_bgra_mask", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMG_22_BGRA_MASK, img_22_bgra_mask_vert_src, img_22_bgra_mask_frag_src, "img_22_bgra_mask", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMG_NOMUL, img_nomul_vert_src, img_nomul_frag_src, "img_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMG_BGRA_NOMUL, img_bgra_nomul_vert_src, img_bgra_nomul_frag_src, "img_bgra_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMG_12_NOMUL, img_12_nomul_vert_src, img_12_nomul_frag_src, "img_12_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMG_21_NOMUL, img_21_nomul_vert_src, img_21_nomul_frag_src, "img_21_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMG_22_NOMUL, img_22_nomul_vert_src, img_22_nomul_frag_src, "img_22_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMG_12_BGRA_NOMUL, img_12_bgra_nomul_vert_src, img_12_bgra_nomul_frag_src, "img_12_bgra_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMG_21_BGRA_NOMUL, img_21_bgra_nomul_vert_src, img_21_bgra_nomul_frag_src, "img_21_bgra_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMG_22_BGRA_NOMUL, img_22_bgra_nomul_vert_src, img_22_bgra_nomul_frag_src, "img_22_bgra_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMG_MASK_NOMUL, img_mask_nomul_vert_src, img_mask_nomul_frag_src, "img_mask_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMG_BGRA_MASK_NOMUL, img_bgra_mask_nomul_vert_src, img_bgra_mask_nomul_frag_src, "img_bgra_mask_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMG_12_MASK_NOMUL, img_12_mask_nomul_vert_src, img_12_mask_nomul_frag_src, "img_12_mask_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMG_21_MASK_NOMUL, img_21_mask_nomul_vert_src, img_21_mask_nomul_frag_src, "img_21_mask_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMG_22_MASK_NOMUL, img_22_mask_nomul_vert_src, img_22_mask_nomul_frag_src, "img_22_mask_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMG_12_BGRA_MASK_NOMUL, img_12_bgra_mask_nomul_vert_src, img_12_bgra_mask_nomul_frag_src, "img_12_bgra_mask_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMG_21_BGRA_MASK_NOMUL, img_21_bgra_mask_nomul_vert_src, img_21_bgra_mask_nomul_frag_src, "img_21_bgra_mask_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMG_22_BGRA_MASK_NOMUL, img_22_bgra_mask_nomul_vert_src, img_22_bgra_mask_nomul_frag_src, "img_22_bgra_mask_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMG_MASK12, img_mask12_vert_src, img_mask12_frag_src, "img_mask12", SHD_IMAGE, SHD_SAM11, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMG_BGRA_MASK12, img_bgra_mask12_vert_src, img_bgra_mask12_frag_src, "img_bgra_mask12", SHD_IMAGE, SHD_SAM11, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMG_12_MASK12, img_12_mask12_vert_src, img_12_mask12_frag_src, "img_12_mask12", SHD_IMAGE, SHD_SAM12, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMG_21_MASK12, img_21_mask12_vert_src, img_21_mask12_frag_src, "img_21_mask12", SHD_IMAGE, SHD_SAM21, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMG_22_MASK12, img_22_mask12_vert_src, img_22_mask12_frag_src, "img_22_mask12", SHD_IMAGE, SHD_SAM22, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMG_12_BGRA_MASK12, img_12_bgra_mask12_vert_src, img_12_bgra_mask12_frag_src, "img_12_bgra_mask12", SHD_IMAGE, SHD_SAM12, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMG_21_BGRA_MASK12, img_21_bgra_mask12_vert_src, img_21_bgra_mask12_frag_src, "img_21_bgra_mask12", SHD_IMAGE, SHD_SAM21, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMG_22_BGRA_MASK12, img_22_bgra_mask12_vert_src, img_22_bgra_mask12_frag_src, "img_22_bgra_mask12", SHD_IMAGE, SHD_SAM22, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMG_MASK12_NOMUL, img_mask12_nomul_vert_src, img_mask12_nomul_frag_src, "img_mask12_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMG_BGRA_MASK12_NOMUL, img_bgra_mask12_nomul_vert_src, img_bgra_mask12_nomul_frag_src, "img_bgra_mask12_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMG_12_MASK12_NOMUL, img_12_mask12_nomul_vert_src, img_12_mask12_nomul_frag_src, "img_12_mask12_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMG_21_MASK12_NOMUL, img_21_mask12_nomul_vert_src, img_21_mask12_nomul_frag_src, "img_21_mask12_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMG_22_MASK12_NOMUL, img_22_mask12_nomul_vert_src, img_22_mask12_nomul_frag_src, "img_22_mask12_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMG_12_BGRA_MASK12_NOMUL, img_12_bgra_mask12_nomul_vert_src, img_12_bgra_mask12_nomul_frag_src, "img_12_bgra_mask12_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMG_21_BGRA_MASK12_NOMUL, img_21_bgra_mask12_nomul_vert_src, img_21_bgra_mask12_nomul_frag_src, "img_21_bgra_mask12_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMG_22_BGRA_MASK12_NOMUL, img_22_bgra_mask12_nomul_vert_src, img_22_bgra_mask12_nomul_frag_src, "img_22_bgra_mask12_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMG_MASK21, img_mask21_vert_src, img_mask21_frag_src, "img_mask21", SHD_IMAGE, SHD_SAM11, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMG_BGRA_MASK21, img_bgra_mask21_vert_src, img_bgra_mask21_frag_src, "img_bgra_mask21", SHD_IMAGE, SHD_SAM11, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMG_12_MASK21, img_12_mask21_vert_src, img_12_mask21_frag_src, "img_12_mask21", SHD_IMAGE, SHD_SAM12, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMG_21_MASK21, img_21_mask21_vert_src, img_21_mask21_frag_src, "img_21_mask21", SHD_IMAGE, SHD_SAM21, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMG_22_MASK21, img_22_mask21_vert_src, img_22_mask21_frag_src, "img_22_mask21", SHD_IMAGE, SHD_SAM22, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMG_12_BGRA_MASK21, img_12_bgra_mask21_vert_src, img_12_bgra_mask21_frag_src, "img_12_bgra_mask21", SHD_IMAGE, SHD_SAM12, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMG_21_BGRA_MASK21, img_21_bgra_mask21_vert_src, img_21_bgra_mask21_frag_src, "img_21_bgra_mask21", SHD_IMAGE, SHD_SAM21, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMG_22_BGRA_MASK21, img_22_bgra_mask21_vert_src, img_22_bgra_mask21_frag_src, "img_22_bgra_mask21", SHD_IMAGE, SHD_SAM22, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMG_MASK21_NOMUL, img_mask21_nomul_vert_src, img_mask21_nomul_frag_src, "img_mask21_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMG_BGRA_MASK21_NOMUL, img_bgra_mask21_nomul_vert_src, img_bgra_mask21_nomul_frag_src, "img_bgra_mask21_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMG_12_MASK21_NOMUL, img_12_mask21_nomul_vert_src, img_12_mask21_nomul_frag_src, "img_12_mask21_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMG_21_MASK21_NOMUL, img_21_mask21_nomul_vert_src, img_21_mask21_nomul_frag_src, "img_21_mask21_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMG_22_MASK21_NOMUL, img_22_mask21_nomul_vert_src, img_22_mask21_nomul_frag_src, "img_22_mask21_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMG_12_BGRA_MASK21_NOMUL, img_12_bgra_mask21_nomul_vert_src, img_12_bgra_mask21_nomul_frag_src, "img_12_bgra_mask21_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMG_21_BGRA_MASK21_NOMUL, img_21_bgra_mask21_nomul_vert_src, img_21_bgra_mask21_nomul_frag_src, "img_21_bgra_mask21_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMG_22_BGRA_MASK21_NOMUL, img_22_bgra_mask21_nomul_vert_src, img_22_bgra_mask21_nomul_frag_src, "img_22_bgra_mask21_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMG_MASK22, img_mask22_vert_src, img_mask22_frag_src, "img_mask22", SHD_IMAGE, SHD_SAM11, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG_BGRA_MASK22, img_bgra_mask22_vert_src, img_bgra_mask22_frag_src, "img_bgra_mask22", SHD_IMAGE, SHD_SAM11, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMG_12_MASK22, img_12_mask22_vert_src, img_12_mask22_frag_src, "img_12_mask22", SHD_IMAGE, SHD_SAM12, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG_21_MASK22, img_21_mask22_vert_src, img_21_mask22_frag_src, "img_21_mask22", SHD_IMAGE, SHD_SAM21, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG_22_MASK22, img_22_mask22_vert_src, img_22_mask22_frag_src, "img_22_mask22", SHD_IMAGE, SHD_SAM22, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG_12_BGRA_MASK22, img_12_bgra_mask22_vert_src, img_12_bgra_mask22_frag_src, "img_12_bgra_mask22", SHD_IMAGE, SHD_SAM12, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMG_21_BGRA_MASK22, img_21_bgra_mask22_vert_src, img_21_bgra_mask22_frag_src, "img_21_bgra_mask22", SHD_IMAGE, SHD_SAM21, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMG_22_BGRA_MASK22, img_22_bgra_mask22_vert_src, img_22_bgra_mask22_frag_src, "img_22_bgra_mask22", SHD_IMAGE, SHD_SAM22, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMG_MASK22_NOMUL, img_mask22_nomul_vert_src, img_mask22_nomul_frag_src, "img_mask22_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMG_BGRA_MASK22_NOMUL, img_bgra_mask22_nomul_vert_src, img_bgra_mask22_nomul_frag_src, "img_bgra_mask22_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMG_12_MASK22_NOMUL, img_12_mask22_nomul_vert_src, img_12_mask22_nomul_frag_src, "img_12_mask22_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMG_21_MASK22_NOMUL, img_21_mask22_nomul_vert_src, img_21_mask22_nomul_frag_src, "img_21_mask22_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMG_22_MASK22_NOMUL, img_22_mask22_nomul_vert_src, img_22_mask22_nomul_frag_src, "img_22_mask22_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMG_12_BGRA_MASK22_NOMUL, img_12_bgra_mask22_nomul_vert_src, img_12_bgra_mask22_nomul_frag_src, "img_12_bgra_mask22_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMG_21_BGRA_MASK22_NOMUL, img_21_bgra_mask22_nomul_vert_src, img_21_bgra_mask22_nomul_frag_src, "img_21_bgra_mask22_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMG_22_BGRA_MASK22_NOMUL, img_22_bgra_mask22_nomul_vert_src, img_22_bgra_mask22_nomul_frag_src, "img_22_bgra_mask22_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMG_AFILL, img_afill_vert_src, img_afill_frag_src, "img_afill", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMG_BGRA_AFILL, img_bgra_afill_vert_src, img_bgra_afill_frag_src, "img_bgra_afill", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMG_NOMUL_AFILL, img_nomul_afill_vert_src, img_nomul_afill_frag_src, "img_nomul_afill", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMG_BGRA_NOMUL_AFILL, img_bgra_nomul_afill_vert_src, img_bgra_nomul_afill_frag_src, "img_bgra_nomul_afill", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMG_12_AFILL, img_12_afill_vert_src, img_12_afill_frag_src, "img_12_afill", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMG_21_AFILL, img_21_afill_vert_src, img_21_afill_frag_src, "img_21_afill", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMG_22_AFILL, img_22_afill_vert_src, img_22_afill_frag_src, "img_22_afill", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMG_12_BGRA_AFILL, img_12_bgra_afill_vert_src, img_12_bgra_afill_frag_src, "img_12_bgra_afill", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMG_21_BGRA_AFILL, img_21_bgra_afill_vert_src, img_21_bgra_afill_frag_src, "img_21_bgra_afill", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMG_22_BGRA_AFILL, img_22_bgra_afill_vert_src, img_22_bgra_afill_frag_src, "img_22_bgra_afill", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMG_12_NOMUL_AFILL, img_12_nomul_afill_vert_src, img_12_nomul_afill_frag_src, "img_12_nomul_afill", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMG_21_NOMUL_AFILL, img_21_nomul_afill_vert_src, img_21_nomul_afill_frag_src, "img_21_nomul_afill", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMG_22_NOMUL_AFILL, img_22_nomul_afill_vert_src, img_22_nomul_afill_frag_src, "img_22_nomul_afill", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMG_12_BGRA_NOMUL_AFILL, img_12_bgra_nomul_afill_vert_src, img_12_bgra_nomul_afill_frag_src, "img_12_bgra_nomul_afill", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMG_21_BGRA_NOMUL_AFILL, img_21_bgra_nomul_afill_vert_src, img_21_bgra_nomul_afill_frag_src, "img_21_bgra_nomul_afill", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMG_22_BGRA_NOMUL_AFILL, img_22_bgra_nomul_afill_vert_src, img_22_bgra_nomul_afill_frag_src, "img_22_bgra_nomul_afill", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMGNAT, imgnat_vert_src, imgnat_frag_src, "imgnat", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMGNAT_BGRA, imgnat_bgra_vert_src, imgnat_bgra_frag_src, "imgnat_bgra", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMGNAT_12, imgnat_12_vert_src, imgnat_12_frag_src, "imgnat_12", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMGNAT_21, imgnat_21_vert_src, imgnat_21_frag_src, "imgnat_21", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMGNAT_22, imgnat_22_vert_src, imgnat_22_frag_src, "imgnat_22", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMGNAT_12_BGRA, imgnat_12_bgra_vert_src, imgnat_12_bgra_frag_src, "imgnat_12_bgra", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMGNAT_21_BGRA, imgnat_21_bgra_vert_src, imgnat_21_bgra_frag_src, "imgnat_21_bgra", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMGNAT_22_BGRA, imgnat_22_bgra_vert_src, imgnat_22_bgra_frag_src, "imgnat_22_bgra", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMGNAT_MASK, imgnat_mask_vert_src, imgnat_mask_frag_src, "imgnat_mask", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMGNAT_BGRA_MASK, imgnat_bgra_mask_vert_src, imgnat_bgra_mask_frag_src, "imgnat_bgra_mask", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMGNAT_12_MASK, imgnat_12_mask_vert_src, imgnat_12_mask_frag_src, "imgnat_12_mask", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMGNAT_21_MASK, imgnat_21_mask_vert_src, imgnat_21_mask_frag_src, "imgnat_21_mask", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMGNAT_22_MASK, imgnat_22_mask_vert_src, imgnat_22_mask_frag_src, "imgnat_22_mask", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK, imgnat_12_bgra_mask_vert_src, imgnat_12_bgra_mask_frag_src, "imgnat_12_bgra_mask", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK, imgnat_21_bgra_mask_vert_src, imgnat_21_bgra_mask_frag_src, "imgnat_21_bgra_mask", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK, imgnat_22_bgra_mask_vert_src, imgnat_22_bgra_mask_frag_src, "imgnat_22_bgra_mask", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMGNAT_NOMUL, imgnat_nomul_vert_src, imgnat_nomul_frag_src, "imgnat_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMGNAT_BGRA_NOMUL, imgnat_bgra_nomul_vert_src, imgnat_bgra_nomul_frag_src, "imgnat_bgra_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMGNAT_12_NOMUL, imgnat_12_nomul_vert_src, imgnat_12_nomul_frag_src, "imgnat_12_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMGNAT_21_NOMUL, imgnat_21_nomul_vert_src, imgnat_21_nomul_frag_src, "imgnat_21_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMGNAT_22_NOMUL, imgnat_22_nomul_vert_src, imgnat_22_nomul_frag_src, "imgnat_22_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_NOMUL, imgnat_12_bgra_nomul_vert_src, imgnat_12_bgra_nomul_frag_src, "imgnat_12_bgra_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_NOMUL, imgnat_21_bgra_nomul_vert_src, imgnat_21_bgra_nomul_frag_src, "imgnat_21_bgra_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_NOMUL, imgnat_22_bgra_nomul_vert_src, imgnat_22_bgra_nomul_frag_src, "imgnat_22_bgra_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMGNAT_MASK_NOMUL, imgnat_mask_nomul_vert_src, imgnat_mask_nomul_frag_src, "imgnat_mask_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMGNAT_BGRA_MASK_NOMUL, imgnat_bgra_mask_nomul_vert_src, imgnat_bgra_mask_nomul_frag_src, "imgnat_bgra_mask_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMGNAT_12_MASK_NOMUL, imgnat_12_mask_nomul_vert_src, imgnat_12_mask_nomul_frag_src, "imgnat_12_mask_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMGNAT_21_MASK_NOMUL, imgnat_21_mask_nomul_vert_src, imgnat_21_mask_nomul_frag_src, "imgnat_21_mask_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMGNAT_22_MASK_NOMUL, imgnat_22_mask_nomul_vert_src, imgnat_22_mask_nomul_frag_src, "imgnat_22_mask_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK_NOMUL, imgnat_12_bgra_mask_nomul_vert_src, imgnat_12_bgra_mask_nomul_frag_src, "imgnat_12_bgra_mask_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK_NOMUL, imgnat_21_bgra_mask_nomul_vert_src, imgnat_21_bgra_mask_nomul_frag_src, "imgnat_21_bgra_mask_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK_NOMUL, imgnat_22_bgra_mask_nomul_vert_src, imgnat_22_bgra_mask_nomul_frag_src, "imgnat_22_bgra_mask_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMGNAT_MASK12, imgnat_mask12_vert_src, imgnat_mask12_frag_src, "imgnat_mask12", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMGNAT_BGRA_MASK12, imgnat_bgra_mask12_vert_src, imgnat_bgra_mask12_frag_src, "imgnat_bgra_mask12", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMGNAT_12_MASK12, imgnat_12_mask12_vert_src, imgnat_12_mask12_frag_src, "imgnat_12_mask12", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMGNAT_21_MASK12, imgnat_21_mask12_vert_src, imgnat_21_mask12_frag_src, "imgnat_21_mask12", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMGNAT_22_MASK12, imgnat_22_mask12_vert_src, imgnat_22_mask12_frag_src, "imgnat_22_mask12", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK12, imgnat_12_bgra_mask12_vert_src, imgnat_12_bgra_mask12_frag_src, "imgnat_12_bgra_mask12", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK12, imgnat_21_bgra_mask12_vert_src, imgnat_21_bgra_mask12_frag_src, "imgnat_21_bgra_mask12", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK12, imgnat_22_bgra_mask12_vert_src, imgnat_22_bgra_mask12_frag_src, "imgnat_22_bgra_mask12", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMGNAT_MASK12_NOMUL, imgnat_mask12_nomul_vert_src, imgnat_mask12_nomul_frag_src, "imgnat_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMGNAT_BGRA_MASK12_NOMUL, imgnat_bgra_mask12_nomul_vert_src, imgnat_bgra_mask12_nomul_frag_src, "imgnat_bgra_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMGNAT_12_MASK12_NOMUL, imgnat_12_mask12_nomul_vert_src, imgnat_12_mask12_nomul_frag_src, "imgnat_12_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMGNAT_21_MASK12_NOMUL, imgnat_21_mask12_nomul_vert_src, imgnat_21_mask12_nomul_frag_src, "imgnat_21_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMGNAT_22_MASK12_NOMUL, imgnat_22_mask12_nomul_vert_src, imgnat_22_mask12_nomul_frag_src, "imgnat_22_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK12_NOMUL, imgnat_12_bgra_mask12_nomul_vert_src, imgnat_12_bgra_mask12_nomul_frag_src, "imgnat_12_bgra_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK12_NOMUL, imgnat_21_bgra_mask12_nomul_vert_src, imgnat_21_bgra_mask12_nomul_frag_src, "imgnat_21_bgra_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK12_NOMUL, imgnat_22_bgra_mask12_nomul_vert_src, imgnat_22_bgra_mask12_nomul_frag_src, "imgnat_22_bgra_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMGNAT_MASK21, imgnat_mask21_vert_src, imgnat_mask21_frag_src, "imgnat_mask21", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMGNAT_BGRA_MASK21, imgnat_bgra_mask21_vert_src, imgnat_bgra_mask21_frag_src, "imgnat_bgra_mask21", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMGNAT_12_MASK21, imgnat_12_mask21_vert_src, imgnat_12_mask21_frag_src, "imgnat_12_mask21", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMGNAT_21_MASK21, imgnat_21_mask21_vert_src, imgnat_21_mask21_frag_src, "imgnat_21_mask21", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMGNAT_22_MASK21, imgnat_22_mask21_vert_src, imgnat_22_mask21_frag_src, "imgnat_22_mask21", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK21, imgnat_12_bgra_mask21_vert_src, imgnat_12_bgra_mask21_frag_src, "imgnat_12_bgra_mask21", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK21, imgnat_21_bgra_mask21_vert_src, imgnat_21_bgra_mask21_frag_src, "imgnat_21_bgra_mask21", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK21, imgnat_22_bgra_mask21_vert_src, imgnat_22_bgra_mask21_frag_src, "imgnat_22_bgra_mask21", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMGNAT_MASK21_NOMUL, imgnat_mask21_nomul_vert_src, imgnat_mask21_nomul_frag_src, "imgnat_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMGNAT_BGRA_MASK21_NOMUL, imgnat_bgra_mask21_nomul_vert_src, imgnat_bgra_mask21_nomul_frag_src, "imgnat_bgra_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMGNAT_12_MASK21_NOMUL, imgnat_12_mask21_nomul_vert_src, imgnat_12_mask21_nomul_frag_src, "imgnat_12_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMGNAT_21_MASK21_NOMUL, imgnat_21_mask21_nomul_vert_src, imgnat_21_mask21_nomul_frag_src, "imgnat_21_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMGNAT_22_MASK21_NOMUL, imgnat_22_mask21_nomul_vert_src, imgnat_22_mask21_nomul_frag_src, "imgnat_22_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK21_NOMUL, imgnat_12_bgra_mask21_nomul_vert_src, imgnat_12_bgra_mask21_nomul_frag_src, "imgnat_12_bgra_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK21_NOMUL, imgnat_21_bgra_mask21_nomul_vert_src, imgnat_21_bgra_mask21_nomul_frag_src, "imgnat_21_bgra_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK21_NOMUL, imgnat_22_bgra_mask21_nomul_vert_src, imgnat_22_bgra_mask21_nomul_frag_src, "imgnat_22_bgra_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMGNAT_MASK22, imgnat_mask22_vert_src, imgnat_mask22_frag_src, "imgnat_mask22", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMGNAT_BGRA_MASK22, imgnat_bgra_mask22_vert_src, imgnat_bgra_mask22_frag_src, "imgnat_bgra_mask22", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMGNAT_12_MASK22, imgnat_12_mask22_vert_src, imgnat_12_mask22_frag_src, "imgnat_12_mask22", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMGNAT_21_MASK22, imgnat_21_mask22_vert_src, imgnat_21_mask22_frag_src, "imgnat_21_mask22", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMGNAT_22_MASK22, imgnat_22_mask22_vert_src, imgnat_22_mask22_frag_src, "imgnat_22_mask22", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK22, imgnat_12_bgra_mask22_vert_src, imgnat_12_bgra_mask22_frag_src, "imgnat_12_bgra_mask22", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK22, imgnat_21_bgra_mask22_vert_src, imgnat_21_bgra_mask22_frag_src, "imgnat_21_bgra_mask22", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK22, imgnat_22_bgra_mask22_vert_src, imgnat_22_bgra_mask22_frag_src, "imgnat_22_bgra_mask22", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMGNAT_MASK22_NOMUL, imgnat_mask22_nomul_vert_src, imgnat_mask22_nomul_frag_src, "imgnat_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMGNAT_BGRA_MASK22_NOMUL, imgnat_bgra_mask22_nomul_vert_src, imgnat_bgra_mask22_nomul_frag_src, "imgnat_bgra_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMGNAT_12_MASK22_NOMUL, imgnat_12_mask22_nomul_vert_src, imgnat_12_mask22_nomul_frag_src, "imgnat_12_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMGNAT_21_MASK22_NOMUL, imgnat_21_mask22_nomul_vert_src, imgnat_21_mask22_nomul_frag_src, "imgnat_21_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMGNAT_22_MASK22_NOMUL, imgnat_22_mask22_nomul_vert_src, imgnat_22_mask22_nomul_frag_src, "imgnat_22_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK22_NOMUL, imgnat_12_bgra_mask22_nomul_vert_src, imgnat_12_bgra_mask22_nomul_frag_src, "imgnat_12_bgra_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK22_NOMUL, imgnat_21_bgra_mask22_nomul_vert_src, imgnat_21_bgra_mask22_nomul_frag_src, "imgnat_21_bgra_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK22_NOMUL, imgnat_22_bgra_mask22_nomul_vert_src, imgnat_22_bgra_mask22_nomul_frag_src, "imgnat_22_bgra_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMGNAT_AFILL, imgnat_afill_vert_src, imgnat_afill_frag_src, "imgnat_afill", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMGNAT_BGRA_AFILL, imgnat_bgra_afill_vert_src, imgnat_bgra_afill_frag_src, "imgnat_bgra_afill", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMGNAT_NOMUL_AFILL, imgnat_nomul_afill_vert_src, imgnat_nomul_afill_frag_src, "imgnat_nomul_afill", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMGNAT_BGRA_NOMUL_AFILL, imgnat_bgra_nomul_afill_vert_src, imgnat_bgra_nomul_afill_frag_src, "imgnat_bgra_nomul_afill", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMGNAT_12_AFILL, imgnat_12_afill_vert_src, imgnat_12_afill_frag_src, "imgnat_12_afill", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMGNAT_21_AFILL, imgnat_21_afill_vert_src, imgnat_21_afill_frag_src, "imgnat_21_afill", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMGNAT_22_AFILL, imgnat_22_afill_vert_src, imgnat_22_afill_frag_src, "imgnat_22_afill", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMGNAT_12_BGRA_AFILL, imgnat_12_bgra_afill_vert_src, imgnat_12_bgra_afill_frag_src, "imgnat_12_bgra_afill", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMGNAT_21_BGRA_AFILL, imgnat_21_bgra_afill_vert_src, imgnat_21_bgra_afill_frag_src, "imgnat_21_bgra_afill", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMGNAT_22_BGRA_AFILL, imgnat_22_bgra_afill_vert_src, imgnat_22_bgra_afill_frag_src, "imgnat_22_bgra_afill", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMGNAT_12_NOMUL_AFILL, imgnat_12_nomul_afill_vert_src, imgnat_12_nomul_afill_frag_src, "imgnat_12_nomul_afill", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMGNAT_21_NOMUL_AFILL, imgnat_21_nomul_afill_vert_src, imgnat_21_nomul_afill_frag_src, "imgnat_21_nomul_afill", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMGNAT_22_NOMUL_AFILL, imgnat_22_nomul_afill_vert_src, imgnat_22_nomul_afill_frag_src, "imgnat_22_nomul_afill", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMGNAT_12_BGRA_NOMUL_AFILL, imgnat_12_bgra_nomul_afill_vert_src, imgnat_12_bgra_nomul_afill_frag_src, "imgnat_12_bgra_nomul_afill", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMGNAT_21_BGRA_NOMUL_AFILL, imgnat_21_bgra_nomul_afill_vert_src, imgnat_21_bgra_nomul_afill_frag_src, "imgnat_21_bgra_nomul_afill", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMGNAT_22_BGRA_NOMUL_AFILL, imgnat_22_bgra_nomul_afill_vert_src, imgnat_22_bgra_nomul_afill_frag_src, "imgnat_22_bgra_nomul_afill", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_RGB_A_PAIR, rgb_a_pair_vert_src, rgb_a_pair_frag_src, "rgb_a_pair", SHD_RGB_A_PAIR, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_RGB_A_PAIR_MASK, rgb_a_pair_mask_vert_src, rgb_a_pair_mask_frag_src, "rgb_a_pair_mask", SHD_RGB_A_PAIR, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_RGB_A_PAIR_NOMUL, rgb_a_pair_nomul_vert_src, rgb_a_pair_nomul_frag_src, "rgb_a_pair_nomul", SHD_RGB_A_PAIR, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_RGB_A_PAIR_MASK_NOMUL, rgb_a_pair_mask_nomul_vert_src, rgb_a_pair_mask_nomul_frag_src, "rgb_a_pair_mask_nomul", SHD_RGB_A_PAIR, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_TEX_EXTERNAL, tex_external_vert_src, tex_external_frag_src, "tex_external", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_TEX_EXTERNAL_AFILL, tex_external_afill_vert_src, tex_external_afill_frag_src, "tex_external_afill", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_TEX_EXTERNAL_NOMUL, tex_external_nomul_vert_src, tex_external_nomul_frag_src, "tex_external_nomul", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_TEX_EXTERNAL_NOMUL_AFILL, tex_external_nomul_afill_vert_src, tex_external_nomul_afill_frag_src, "tex_external_nomul_afill", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_TEX_EXTERNAL_MASK, tex_external_mask_vert_src, tex_external_mask_frag_src, "tex_external_mask", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_TEX_EXTERNAL_MASK_NOMUL, tex_external_mask_nomul_vert_src, tex_external_mask_nomul_frag_src, "tex_external_mask_nomul", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_YUV, yuv_vert_src, yuv_frag_src, "yuv", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_YUV_NOMUL, yuv_nomul_vert_src, yuv_nomul_frag_src, "yuv_nomul", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_YUV_MASK, yuv_mask_vert_src, yuv_mask_frag_src, "yuv_mask", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_YUV_MASK_NOMUL, yuv_mask_nomul_vert_src, yuv_mask_nomul_frag_src, "yuv_mask_nomul", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_YUY2, yuy2_vert_src, yuy2_frag_src, "yuy2", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_YUY2_NOMUL, yuy2_nomul_vert_src, yuy2_nomul_frag_src, "yuy2_nomul", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_YUY2_MASK, yuy2_mask_vert_src, yuy2_mask_frag_src, "yuy2_mask", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_YUY2_MASK_NOMUL, yuy2_mask_nomul_vert_src, yuy2_mask_nomul_frag_src, "yuy2_mask_nomul", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_NV12, nv12_vert_src, nv12_frag_src, "nv12", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_NV12_NOMUL, nv12_nomul_vert_src, nv12_nomul_frag_src, "nv12_nomul", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_NV12_MASK, nv12_mask_vert_src, nv12_mask_frag_src, "nv12_mask", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_NV12_MASK_NOMUL, nv12_mask_nomul_vert_src, nv12_mask_nomul_frag_src, "nv12_mask_nomul", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_YUV_709, yuv_709_vert_src, yuv_709_frag_src, "yuv_709", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_YUV_709_NOMUL, yuv_709_nomul_vert_src, yuv_709_nomul_frag_src, "yuv_709_nomul", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_YUV_709_MASK, yuv_709_mask_vert_src, yuv_709_mask_frag_src, "yuv_709_mask", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_YUV_709_MASK_NOMUL, yuv_709_mask_nomul_vert_src, yuv_709_mask_nomul_frag_src, "yuv_709_mask_nomul", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_YUY2_709, yuy2_709_vert_src, yuy2_709_frag_src, "yuy2_709", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_YUY2_709_NOMUL, yuy2_709_nomul_vert_src, yuy2_709_nomul_frag_src, "yuy2_709_nomul", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_YUY2_709_MASK, yuy2_709_mask_vert_src, yuy2_709_mask_frag_src, "yuy2_709_mask", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_YUY2_709_MASK_NOMUL, yuy2_709_mask_nomul_vert_src, yuy2_709_mask_nomul_frag_src, "yuy2_709_mask_nomul", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_NV12_709, nv12_709_vert_src, nv12_709_frag_src, "nv12_709", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_NV12_709_NOMUL, nv12_709_nomul_vert_src, nv12_709_nomul_frag_src, "nv12_709_nomul", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_NV12_709_MASK, nv12_709_mask_vert_src, nv12_709_mask_frag_src, "nv12_709_mask", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_NV12_709_MASK_NOMUL, nv12_709_mask_nomul_vert_src, nv12_709_mask_nomul_frag_src, "nv12_709_mask_nomul", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
-};
-
+++ /dev/null
-/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-/* IF IT IS CHANGED PLEASE COMMIT THE CHANGES */
-
-#include "../evas_gl_private.h"
-
-static const char rect_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char rect_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- "}\n";
-
-static const char rect_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char rect_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char rect_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char rect_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char rect_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char rect_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char rect_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = vec4(1, 1, 1, 1);\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char rect_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char font_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char font_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char font_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char font_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char font_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char font_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char font_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char font_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char font_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).aaaa;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char font_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_12_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_12_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_21_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_21_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_22_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char img_22_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char img_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).gbar;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).grab;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char img_12_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_12_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_21_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_22_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_12_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_21_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_22_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_12_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_21_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).gbar;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).gbar;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).gbar;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).gbar;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_22_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char img_12_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_12_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_21_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_21_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char img_22_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).grab;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).grab;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).grab;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).grab;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char img_22_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_bgra_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_bgra_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(0, -tex_masksample.y);\n"
- " masktex_s[1] = vec2(0, tex_masksample.y);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask21_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask21_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask21_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " ma = (ma00 + ma01) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask21_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, 0);\n"
- " masktex_s[1] = vec2( tex_masksample.x, 0);\n"
- " maskdiv_s = 2.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask22_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask22_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_12_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_21_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask22_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " float ma;\n"
- " float ma00 = texture2D(texm, tex_m + masktex_s[0]).a;\n"
- " float ma01 = texture2D(texm, tex_m + masktex_s[1]).a;\n"
- " float ma10 = texture2D(texm, tex_m + masktex_s[2]).a;\n"
- " float ma11 = texture2D(texm, tex_m + masktex_s[3]).a;\n"
- " ma = (ma00 + ma01 + ma10 + ma11) / maskdiv_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char imgnat_22_bgra_mask22_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "attribute vec2 tex_masksample;\n"
- "varying float maskdiv_s;\n"
- "varying vec2 masktex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- " masktex_s[0] = vec2(-tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[1] = vec2( tex_masksample.x, -tex_masksample.y);\n"
- " masktex_s[2] = vec2( tex_masksample.x, tex_masksample.y);\n"
- " masktex_s[3] = vec2(-tex_masksample.x, tex_masksample.y);\n"
- " maskdiv_s = 4.0;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char imgnat_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).rgba;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char imgnat_12_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_12_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_21_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_22_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_12_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_21_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_bgra_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_22_bgra_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_12_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_21_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).bgra;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).bgra;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).bgra;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).bgra;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_22_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char imgnat_12_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_12_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(0, -tex_sample.y);\n"
- " tex_s[1] = vec2(0, tex_sample.y);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_21_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " c = (col00 + col01) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_21_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[2];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, 0);\n"
- " tex_s[1] = vec2( tex_sample.x, 0);\n"
- " div_s = vec4(2, 2, 2, 2);\n"
- "}\n";
-
-static const char imgnat_22_bgra_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " vec4 col00 = texture2D(tex, tex_c + tex_s[0]).rgba;\n"
- " vec4 col01 = texture2D(tex, tex_c + tex_s[1]).rgba;\n"
- " vec4 col10 = texture2D(tex, tex_c + tex_s[2]).rgba;\n"
- " vec4 col11 = texture2D(tex, tex_c + tex_s[3]).rgba;\n"
- " c = (col00 + col01 + col10 + col11) / div_s;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char imgnat_22_bgra_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_sample;\n"
- "varying vec4 div_s;\n"
- "varying vec2 tex_s[4];\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_s[0] = vec2(-tex_sample.x, -tex_sample.y);\n"
- " tex_s[1] = vec2( tex_sample.x, -tex_sample.y);\n"
- " tex_s[2] = vec2( tex_sample.x, tex_sample.y);\n"
- " tex_s[3] = vec2(-tex_sample.x, tex_sample.y);\n"
- " div_s = vec4(4, 4, 4, 4);\n"
- "}\n";
-
-static const char rgb_a_pair_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texa;\n"
- "varying vec2 tex_a;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * texture2D(texa, tex_a).r\n"
- " ;\n"
- "}\n";
-
-static const char rgb_a_pair_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coorda;\n"
- "varying vec2 tex_a;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_a = tex_coorda;\n"
- "}\n";
-
-static const char rgb_a_pair_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texa;\n"
- "varying vec2 tex_a;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " * texture2D(texa, tex_a).r\n"
- " ;\n"
- "}\n";
-
-static const char rgb_a_pair_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coorda;\n"
- "varying vec2 tex_a;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_a = tex_coorda;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char rgb_a_pair_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texa;\n"
- "varying vec2 tex_a;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * texture2D(texa, tex_a).r\n"
- " ;\n"
- "}\n";
-
-static const char rgb_a_pair_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coorda;\n"
- "varying vec2 tex_a;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_a = tex_coorda;\n"
- "}\n";
-
-static const char rgb_a_pair_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texa;\n"
- "varying vec2 tex_a;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " * texture2D(texa, tex_a).r\n"
- " ;\n"
- "}\n";
-
-static const char rgb_a_pair_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coorda;\n"
- "varying vec2 tex_a;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_a = tex_coorda;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char tex_external_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char tex_external_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char tex_external_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char tex_external_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char tex_external_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char tex_external_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char tex_external_nomul_afill_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- " gl_FragColor.a = 1.0;\n"
- "}\n";
-
-static const char tex_external_nomul_afill_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- "}\n";
-
-static const char tex_external_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char tex_external_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char tex_external_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "# extension GL_OES_EGL_image_external : require\n"
- "# ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "# else\n"
- "precision mediump float;\n"
- "# endif\n"
- "# define SAMPLER_EXTERNAL_OES samplerExternalOES\n"
- "#else\n"
- "# define SAMPLER_EXTERNAL_OES sampler2D\n"
- "#endif\n"
- "uniform SAMPLER_EXTERNAL_OES tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " c = texture2D(tex, tex_c).bgra;\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char tex_external_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuv_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char yuv_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- "}\n";
-
-static const char yuv_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char yuv_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- "}\n";
-
-static const char yuv_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuv_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuv_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuv_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuy2_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- "}\n";
-
-static const char yuy2_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- "}\n";
-
-static const char yuy2_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuy2_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char nv12_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char nv12_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- "}\n";
-
-static const char nv12_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char nv12_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- "}\n";
-
-static const char nv12_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char nv12_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char nv12_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.813) + (u * 0.391);\n"
- " v = v * 1.596;\n"
- " u = u * 2.018;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char nv12_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuv_709_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char yuv_709_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- "}\n";
-
-static const char yuv_709_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char yuv_709_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- "}\n";
-
-static const char yuv_709_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuv_709_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuv_709_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texu;\n"
- "uniform sampler2D texv;\n"
- "varying vec2 tex_c2;\n"
- "varying vec2 tex_c3;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).r;\n"
- " u = texture2D(texu, tex_c2).r;\n"
- " v = texture2D(texv, tex_c3).r;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuv_709_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec2 tex_coord3;\n"
- "varying vec2 tex_c3;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2;\n"
- " tex_c3 = tex_coord3;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuy2_709_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_709_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- "}\n";
-
-static const char yuy2_709_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_709_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- "}\n";
-
-static const char yuy2_709_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_709_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char yuy2_709_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char yuy2_709_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = vec2(tex_coord2.x * 0.5, tex_coord2.y);\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char nv12_709_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " ;\n"
- "}\n";
-
-static const char nv12_709_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- "}\n";
-
-static const char nv12_709_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " gl_FragColor =\n"
- " c\n"
- " ;\n"
- "}\n";
-
-static const char nv12_709_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- "}\n";
-
-static const char nv12_709_mask_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "varying vec4 col;\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * col\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char nv12_709_mask_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec4 color;\n"
- "varying vec4 col;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " col = color;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-static const char nv12_709_mask_nomul_frag_src[] =
- "#ifdef GL_ES\n"
- "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
- "precision highp float;\n"
- "#else\n"
- "precision mediump float;\n"
- "#endif\n"
- "#endif\n"
- "uniform sampler2D tex;\n"
- "varying vec2 tex_c;\n"
- "uniform sampler2D texuv;\n"
- "varying vec2 tex_c2;\n"
- "uniform sampler2D texm;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " vec4 c;\n"
- " float r, g, b, y, u, v, vmu;\n"
- " y = texture2D(tex, tex_c).g;\n"
- " u = texture2D(texuv, tex_c2).g;\n"
- " v = texture2D(texuv, tex_c2).a;\n"
- " u = u - 0.5;\n"
- " v = v - 0.5;\n"
- " y = (y - 0.062) * 1.164;\n"
- " vmu = (v * 0.534) + (u * 0.213);\n"
- " v = v * 1.793;\n"
- " u = u * 2.115;\n"
- " r = y + v;\n"
- " g = y - vmu;\n"
- " b = y + u;\n"
- " c = vec4(r, g, b, 1.0);\n"
- " float ma;\n"
- " ma = texture2D(texm, tex_m).a;\n"
- " gl_FragColor =\n"
- " c\n"
- " * ma\n"
- " ;\n"
- "}\n";
-
-static const char nv12_709_mask_nomul_vert_src[] =
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "attribute vec4 vertex;\n"
- "uniform mat4 mvp;\n"
- "attribute vec2 tex_coord;\n"
- "varying vec2 tex_c;\n"
- "attribute vec2 tex_coord2;\n"
- "varying vec2 tex_c2;\n"
- "attribute vec4 mask_coord;\n"
- "varying vec2 tex_m;\n"
- "void main()\n"
- "{\n"
- " gl_Position = mvp * vertex;\n"
- " tex_c = tex_coord;\n"
- " tex_c2 = tex_coord2 * 0.5;\n"
- " vec4 mask_Position = mvp * vertex * vec4(0.5, sign(mask_coord.w) * 0.5, 0.5, 0.5) + vec4(0.5, 0.5, 0, 0);\n"
- " tex_m = mask_Position.xy * abs(mask_coord.zw) + mask_coord.xy;\n"
- "}\n";
-
-
-static const struct {
- Evas_GL_Shader id;
- const char *vert;
- const char *frag;
- const char *name;
- Shader_Type type;
- Shader_Sampling sam;
- Shader_Sampling masksam;
- Eina_Bool bgra : 1;
- Eina_Bool mask : 1;
- Eina_Bool nomul : 1;
- Eina_Bool afill : 1;
-} _shaders_source[] = {
- { SHADER_RECT, rect_vert_src, rect_frag_src, "rect", SHD_RECT, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_RECT_MASK, rect_mask_vert_src, rect_mask_frag_src, "rect_mask", SHD_RECT, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_RECT_MASK12, rect_mask12_vert_src, rect_mask12_frag_src, "rect_mask12", SHD_RECT, SHD_SAM11, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_RECT_MASK21, rect_mask21_vert_src, rect_mask21_frag_src, "rect_mask21", SHD_RECT, SHD_SAM11, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_RECT_MASK22, rect_mask22_vert_src, rect_mask22_frag_src, "rect_mask22", SHD_RECT, SHD_SAM11, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_FONT, font_vert_src, font_frag_src, "font", SHD_FONT, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_FONT_MASK, font_mask_vert_src, font_mask_frag_src, "font_mask", SHD_FONT, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_FONT_MASK12, font_mask12_vert_src, font_mask12_frag_src, "font_mask12", SHD_FONT, SHD_SAM11, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_FONT_MASK21, font_mask21_vert_src, font_mask21_frag_src, "font_mask21", SHD_FONT, SHD_SAM11, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_FONT_MASK22, font_mask22_vert_src, font_mask22_frag_src, "font_mask22", SHD_FONT, SHD_SAM11, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG, img_vert_src, img_frag_src, "img", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMG_BGRA, img_bgra_vert_src, img_bgra_frag_src, "img_bgra", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMG_12, img_12_vert_src, img_12_frag_src, "img_12", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMG_21, img_21_vert_src, img_21_frag_src, "img_21", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMG_22, img_22_vert_src, img_22_frag_src, "img_22", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMG_12_BGRA, img_12_bgra_vert_src, img_12_bgra_frag_src, "img_12_bgra", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMG_21_BGRA, img_21_bgra_vert_src, img_21_bgra_frag_src, "img_21_bgra", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMG_22_BGRA, img_22_bgra_vert_src, img_22_bgra_frag_src, "img_22_bgra", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMG_MASK, img_mask_vert_src, img_mask_frag_src, "img_mask", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMG_BGRA_MASK, img_bgra_mask_vert_src, img_bgra_mask_frag_src, "img_bgra_mask", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMG_12_MASK, img_12_mask_vert_src, img_12_mask_frag_src, "img_12_mask", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMG_21_MASK, img_21_mask_vert_src, img_21_mask_frag_src, "img_21_mask", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMG_22_MASK, img_22_mask_vert_src, img_22_mask_frag_src, "img_22_mask", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMG_12_BGRA_MASK, img_12_bgra_mask_vert_src, img_12_bgra_mask_frag_src, "img_12_bgra_mask", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMG_21_BGRA_MASK, img_21_bgra_mask_vert_src, img_21_bgra_mask_frag_src, "img_21_bgra_mask", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMG_22_BGRA_MASK, img_22_bgra_mask_vert_src, img_22_bgra_mask_frag_src, "img_22_bgra_mask", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMG_NOMUL, img_nomul_vert_src, img_nomul_frag_src, "img_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMG_BGRA_NOMUL, img_bgra_nomul_vert_src, img_bgra_nomul_frag_src, "img_bgra_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMG_12_NOMUL, img_12_nomul_vert_src, img_12_nomul_frag_src, "img_12_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMG_21_NOMUL, img_21_nomul_vert_src, img_21_nomul_frag_src, "img_21_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMG_22_NOMUL, img_22_nomul_vert_src, img_22_nomul_frag_src, "img_22_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMG_12_BGRA_NOMUL, img_12_bgra_nomul_vert_src, img_12_bgra_nomul_frag_src, "img_12_bgra_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMG_21_BGRA_NOMUL, img_21_bgra_nomul_vert_src, img_21_bgra_nomul_frag_src, "img_21_bgra_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMG_22_BGRA_NOMUL, img_22_bgra_nomul_vert_src, img_22_bgra_nomul_frag_src, "img_22_bgra_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMG_MASK_NOMUL, img_mask_nomul_vert_src, img_mask_nomul_frag_src, "img_mask_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMG_BGRA_MASK_NOMUL, img_bgra_mask_nomul_vert_src, img_bgra_mask_nomul_frag_src, "img_bgra_mask_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMG_12_MASK_NOMUL, img_12_mask_nomul_vert_src, img_12_mask_nomul_frag_src, "img_12_mask_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMG_21_MASK_NOMUL, img_21_mask_nomul_vert_src, img_21_mask_nomul_frag_src, "img_21_mask_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMG_22_MASK_NOMUL, img_22_mask_nomul_vert_src, img_22_mask_nomul_frag_src, "img_22_mask_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMG_12_BGRA_MASK_NOMUL, img_12_bgra_mask_nomul_vert_src, img_12_bgra_mask_nomul_frag_src, "img_12_bgra_mask_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMG_21_BGRA_MASK_NOMUL, img_21_bgra_mask_nomul_vert_src, img_21_bgra_mask_nomul_frag_src, "img_21_bgra_mask_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMG_22_BGRA_MASK_NOMUL, img_22_bgra_mask_nomul_vert_src, img_22_bgra_mask_nomul_frag_src, "img_22_bgra_mask_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMG_MASK12, img_mask12_vert_src, img_mask12_frag_src, "img_mask12", SHD_IMAGE, SHD_SAM11, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMG_BGRA_MASK12, img_bgra_mask12_vert_src, img_bgra_mask12_frag_src, "img_bgra_mask12", SHD_IMAGE, SHD_SAM11, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMG_12_MASK12, img_12_mask12_vert_src, img_12_mask12_frag_src, "img_12_mask12", SHD_IMAGE, SHD_SAM12, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMG_21_MASK12, img_21_mask12_vert_src, img_21_mask12_frag_src, "img_21_mask12", SHD_IMAGE, SHD_SAM21, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMG_22_MASK12, img_22_mask12_vert_src, img_22_mask12_frag_src, "img_22_mask12", SHD_IMAGE, SHD_SAM22, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMG_12_BGRA_MASK12, img_12_bgra_mask12_vert_src, img_12_bgra_mask12_frag_src, "img_12_bgra_mask12", SHD_IMAGE, SHD_SAM12, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMG_21_BGRA_MASK12, img_21_bgra_mask12_vert_src, img_21_bgra_mask12_frag_src, "img_21_bgra_mask12", SHD_IMAGE, SHD_SAM21, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMG_22_BGRA_MASK12, img_22_bgra_mask12_vert_src, img_22_bgra_mask12_frag_src, "img_22_bgra_mask12", SHD_IMAGE, SHD_SAM22, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMG_MASK12_NOMUL, img_mask12_nomul_vert_src, img_mask12_nomul_frag_src, "img_mask12_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMG_BGRA_MASK12_NOMUL, img_bgra_mask12_nomul_vert_src, img_bgra_mask12_nomul_frag_src, "img_bgra_mask12_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMG_12_MASK12_NOMUL, img_12_mask12_nomul_vert_src, img_12_mask12_nomul_frag_src, "img_12_mask12_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMG_21_MASK12_NOMUL, img_21_mask12_nomul_vert_src, img_21_mask12_nomul_frag_src, "img_21_mask12_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMG_22_MASK12_NOMUL, img_22_mask12_nomul_vert_src, img_22_mask12_nomul_frag_src, "img_22_mask12_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMG_12_BGRA_MASK12_NOMUL, img_12_bgra_mask12_nomul_vert_src, img_12_bgra_mask12_nomul_frag_src, "img_12_bgra_mask12_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMG_21_BGRA_MASK12_NOMUL, img_21_bgra_mask12_nomul_vert_src, img_21_bgra_mask12_nomul_frag_src, "img_21_bgra_mask12_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMG_22_BGRA_MASK12_NOMUL, img_22_bgra_mask12_nomul_vert_src, img_22_bgra_mask12_nomul_frag_src, "img_22_bgra_mask12_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMG_MASK21, img_mask21_vert_src, img_mask21_frag_src, "img_mask21", SHD_IMAGE, SHD_SAM11, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMG_BGRA_MASK21, img_bgra_mask21_vert_src, img_bgra_mask21_frag_src, "img_bgra_mask21", SHD_IMAGE, SHD_SAM11, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMG_12_MASK21, img_12_mask21_vert_src, img_12_mask21_frag_src, "img_12_mask21", SHD_IMAGE, SHD_SAM12, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMG_21_MASK21, img_21_mask21_vert_src, img_21_mask21_frag_src, "img_21_mask21", SHD_IMAGE, SHD_SAM21, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMG_22_MASK21, img_22_mask21_vert_src, img_22_mask21_frag_src, "img_22_mask21", SHD_IMAGE, SHD_SAM22, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMG_12_BGRA_MASK21, img_12_bgra_mask21_vert_src, img_12_bgra_mask21_frag_src, "img_12_bgra_mask21", SHD_IMAGE, SHD_SAM12, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMG_21_BGRA_MASK21, img_21_bgra_mask21_vert_src, img_21_bgra_mask21_frag_src, "img_21_bgra_mask21", SHD_IMAGE, SHD_SAM21, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMG_22_BGRA_MASK21, img_22_bgra_mask21_vert_src, img_22_bgra_mask21_frag_src, "img_22_bgra_mask21", SHD_IMAGE, SHD_SAM22, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMG_MASK21_NOMUL, img_mask21_nomul_vert_src, img_mask21_nomul_frag_src, "img_mask21_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMG_BGRA_MASK21_NOMUL, img_bgra_mask21_nomul_vert_src, img_bgra_mask21_nomul_frag_src, "img_bgra_mask21_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMG_12_MASK21_NOMUL, img_12_mask21_nomul_vert_src, img_12_mask21_nomul_frag_src, "img_12_mask21_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMG_21_MASK21_NOMUL, img_21_mask21_nomul_vert_src, img_21_mask21_nomul_frag_src, "img_21_mask21_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMG_22_MASK21_NOMUL, img_22_mask21_nomul_vert_src, img_22_mask21_nomul_frag_src, "img_22_mask21_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMG_12_BGRA_MASK21_NOMUL, img_12_bgra_mask21_nomul_vert_src, img_12_bgra_mask21_nomul_frag_src, "img_12_bgra_mask21_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMG_21_BGRA_MASK21_NOMUL, img_21_bgra_mask21_nomul_vert_src, img_21_bgra_mask21_nomul_frag_src, "img_21_bgra_mask21_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMG_22_BGRA_MASK21_NOMUL, img_22_bgra_mask21_nomul_vert_src, img_22_bgra_mask21_nomul_frag_src, "img_22_bgra_mask21_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMG_MASK22, img_mask22_vert_src, img_mask22_frag_src, "img_mask22", SHD_IMAGE, SHD_SAM11, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG_BGRA_MASK22, img_bgra_mask22_vert_src, img_bgra_mask22_frag_src, "img_bgra_mask22", SHD_IMAGE, SHD_SAM11, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMG_12_MASK22, img_12_mask22_vert_src, img_12_mask22_frag_src, "img_12_mask22", SHD_IMAGE, SHD_SAM12, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG_21_MASK22, img_21_mask22_vert_src, img_21_mask22_frag_src, "img_21_mask22", SHD_IMAGE, SHD_SAM21, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG_22_MASK22, img_22_mask22_vert_src, img_22_mask22_frag_src, "img_22_mask22", SHD_IMAGE, SHD_SAM22, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMG_12_BGRA_MASK22, img_12_bgra_mask22_vert_src, img_12_bgra_mask22_frag_src, "img_12_bgra_mask22", SHD_IMAGE, SHD_SAM12, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMG_21_BGRA_MASK22, img_21_bgra_mask22_vert_src, img_21_bgra_mask22_frag_src, "img_21_bgra_mask22", SHD_IMAGE, SHD_SAM21, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMG_22_BGRA_MASK22, img_22_bgra_mask22_vert_src, img_22_bgra_mask22_frag_src, "img_22_bgra_mask22", SHD_IMAGE, SHD_SAM22, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMG_MASK22_NOMUL, img_mask22_nomul_vert_src, img_mask22_nomul_frag_src, "img_mask22_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMG_BGRA_MASK22_NOMUL, img_bgra_mask22_nomul_vert_src, img_bgra_mask22_nomul_frag_src, "img_bgra_mask22_nomul", SHD_IMAGE, SHD_SAM11, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMG_12_MASK22_NOMUL, img_12_mask22_nomul_vert_src, img_12_mask22_nomul_frag_src, "img_12_mask22_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMG_21_MASK22_NOMUL, img_21_mask22_nomul_vert_src, img_21_mask22_nomul_frag_src, "img_21_mask22_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMG_22_MASK22_NOMUL, img_22_mask22_nomul_vert_src, img_22_mask22_nomul_frag_src, "img_22_mask22_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMG_12_BGRA_MASK22_NOMUL, img_12_bgra_mask22_nomul_vert_src, img_12_bgra_mask22_nomul_frag_src, "img_12_bgra_mask22_nomul", SHD_IMAGE, SHD_SAM12, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMG_21_BGRA_MASK22_NOMUL, img_21_bgra_mask22_nomul_vert_src, img_21_bgra_mask22_nomul_frag_src, "img_21_bgra_mask22_nomul", SHD_IMAGE, SHD_SAM21, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMG_22_BGRA_MASK22_NOMUL, img_22_bgra_mask22_nomul_vert_src, img_22_bgra_mask22_nomul_frag_src, "img_22_bgra_mask22_nomul", SHD_IMAGE, SHD_SAM22, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMG_AFILL, img_afill_vert_src, img_afill_frag_src, "img_afill", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMG_BGRA_AFILL, img_bgra_afill_vert_src, img_bgra_afill_frag_src, "img_bgra_afill", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMG_NOMUL_AFILL, img_nomul_afill_vert_src, img_nomul_afill_frag_src, "img_nomul_afill", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMG_BGRA_NOMUL_AFILL, img_bgra_nomul_afill_vert_src, img_bgra_nomul_afill_frag_src, "img_bgra_nomul_afill", SHD_IMAGE, SHD_SAM11, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMG_12_AFILL, img_12_afill_vert_src, img_12_afill_frag_src, "img_12_afill", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMG_21_AFILL, img_21_afill_vert_src, img_21_afill_frag_src, "img_21_afill", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMG_22_AFILL, img_22_afill_vert_src, img_22_afill_frag_src, "img_22_afill", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMG_12_BGRA_AFILL, img_12_bgra_afill_vert_src, img_12_bgra_afill_frag_src, "img_12_bgra_afill", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMG_21_BGRA_AFILL, img_21_bgra_afill_vert_src, img_21_bgra_afill_frag_src, "img_21_bgra_afill", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMG_22_BGRA_AFILL, img_22_bgra_afill_vert_src, img_22_bgra_afill_frag_src, "img_22_bgra_afill", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMG_12_NOMUL_AFILL, img_12_nomul_afill_vert_src, img_12_nomul_afill_frag_src, "img_12_nomul_afill", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMG_21_NOMUL_AFILL, img_21_nomul_afill_vert_src, img_21_nomul_afill_frag_src, "img_21_nomul_afill", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMG_22_NOMUL_AFILL, img_22_nomul_afill_vert_src, img_22_nomul_afill_frag_src, "img_22_nomul_afill", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMG_12_BGRA_NOMUL_AFILL, img_12_bgra_nomul_afill_vert_src, img_12_bgra_nomul_afill_frag_src, "img_12_bgra_nomul_afill", SHD_IMAGE, SHD_SAM12, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMG_21_BGRA_NOMUL_AFILL, img_21_bgra_nomul_afill_vert_src, img_21_bgra_nomul_afill_frag_src, "img_21_bgra_nomul_afill", SHD_IMAGE, SHD_SAM21, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMG_22_BGRA_NOMUL_AFILL, img_22_bgra_nomul_afill_vert_src, img_22_bgra_nomul_afill_frag_src, "img_22_bgra_nomul_afill", SHD_IMAGE, SHD_SAM22, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMGNAT, imgnat_vert_src, imgnat_frag_src, "imgnat", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMGNAT_BGRA, imgnat_bgra_vert_src, imgnat_bgra_frag_src, "imgnat_bgra", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMGNAT_12, imgnat_12_vert_src, imgnat_12_frag_src, "imgnat_12", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMGNAT_21, imgnat_21_vert_src, imgnat_21_frag_src, "imgnat_21", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMGNAT_22, imgnat_22_vert_src, imgnat_22_frag_src, "imgnat_22", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_IMGNAT_12_BGRA, imgnat_12_bgra_vert_src, imgnat_12_bgra_frag_src, "imgnat_12_bgra", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMGNAT_21_BGRA, imgnat_21_bgra_vert_src, imgnat_21_bgra_frag_src, "imgnat_21_bgra", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMGNAT_22_BGRA, imgnat_22_bgra_vert_src, imgnat_22_bgra_frag_src, "imgnat_22_bgra", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 0, 0, 0 },
- { SHADER_IMGNAT_MASK, imgnat_mask_vert_src, imgnat_mask_frag_src, "imgnat_mask", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMGNAT_BGRA_MASK, imgnat_bgra_mask_vert_src, imgnat_bgra_mask_frag_src, "imgnat_bgra_mask", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMGNAT_12_MASK, imgnat_12_mask_vert_src, imgnat_12_mask_frag_src, "imgnat_12_mask", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMGNAT_21_MASK, imgnat_21_mask_vert_src, imgnat_21_mask_frag_src, "imgnat_21_mask", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMGNAT_22_MASK, imgnat_22_mask_vert_src, imgnat_22_mask_frag_src, "imgnat_22_mask", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK, imgnat_12_bgra_mask_vert_src, imgnat_12_bgra_mask_frag_src, "imgnat_12_bgra_mask", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK, imgnat_21_bgra_mask_vert_src, imgnat_21_bgra_mask_frag_src, "imgnat_21_bgra_mask", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK, imgnat_22_bgra_mask_vert_src, imgnat_22_bgra_mask_frag_src, "imgnat_22_bgra_mask", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 1, 0, 0 },
- { SHADER_IMGNAT_NOMUL, imgnat_nomul_vert_src, imgnat_nomul_frag_src, "imgnat_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMGNAT_BGRA_NOMUL, imgnat_bgra_nomul_vert_src, imgnat_bgra_nomul_frag_src, "imgnat_bgra_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMGNAT_12_NOMUL, imgnat_12_nomul_vert_src, imgnat_12_nomul_frag_src, "imgnat_12_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMGNAT_21_NOMUL, imgnat_21_nomul_vert_src, imgnat_21_nomul_frag_src, "imgnat_21_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMGNAT_22_NOMUL, imgnat_22_nomul_vert_src, imgnat_22_nomul_frag_src, "imgnat_22_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_NOMUL, imgnat_12_bgra_nomul_vert_src, imgnat_12_bgra_nomul_frag_src, "imgnat_12_bgra_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_NOMUL, imgnat_21_bgra_nomul_vert_src, imgnat_21_bgra_nomul_frag_src, "imgnat_21_bgra_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_NOMUL, imgnat_22_bgra_nomul_vert_src, imgnat_22_bgra_nomul_frag_src, "imgnat_22_bgra_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 0, 1, 0 },
- { SHADER_IMGNAT_MASK_NOMUL, imgnat_mask_nomul_vert_src, imgnat_mask_nomul_frag_src, "imgnat_mask_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMGNAT_BGRA_MASK_NOMUL, imgnat_bgra_mask_nomul_vert_src, imgnat_bgra_mask_nomul_frag_src, "imgnat_bgra_mask_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMGNAT_12_MASK_NOMUL, imgnat_12_mask_nomul_vert_src, imgnat_12_mask_nomul_frag_src, "imgnat_12_mask_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMGNAT_21_MASK_NOMUL, imgnat_21_mask_nomul_vert_src, imgnat_21_mask_nomul_frag_src, "imgnat_21_mask_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMGNAT_22_MASK_NOMUL, imgnat_22_mask_nomul_vert_src, imgnat_22_mask_nomul_frag_src, "imgnat_22_mask_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK_NOMUL, imgnat_12_bgra_mask_nomul_vert_src, imgnat_12_bgra_mask_nomul_frag_src, "imgnat_12_bgra_mask_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK_NOMUL, imgnat_21_bgra_mask_nomul_vert_src, imgnat_21_bgra_mask_nomul_frag_src, "imgnat_21_bgra_mask_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK_NOMUL, imgnat_22_bgra_mask_nomul_vert_src, imgnat_22_bgra_mask_nomul_frag_src, "imgnat_22_bgra_mask_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 1, 1, 0 },
- { SHADER_IMGNAT_MASK12, imgnat_mask12_vert_src, imgnat_mask12_frag_src, "imgnat_mask12", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMGNAT_BGRA_MASK12, imgnat_bgra_mask12_vert_src, imgnat_bgra_mask12_frag_src, "imgnat_bgra_mask12", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMGNAT_12_MASK12, imgnat_12_mask12_vert_src, imgnat_12_mask12_frag_src, "imgnat_12_mask12", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMGNAT_21_MASK12, imgnat_21_mask12_vert_src, imgnat_21_mask12_frag_src, "imgnat_21_mask12", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMGNAT_22_MASK12, imgnat_22_mask12_vert_src, imgnat_22_mask12_frag_src, "imgnat_22_mask12", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM12, 0, 1, 0, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK12, imgnat_12_bgra_mask12_vert_src, imgnat_12_bgra_mask12_frag_src, "imgnat_12_bgra_mask12", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK12, imgnat_21_bgra_mask12_vert_src, imgnat_21_bgra_mask12_frag_src, "imgnat_21_bgra_mask12", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK12, imgnat_22_bgra_mask12_vert_src, imgnat_22_bgra_mask12_frag_src, "imgnat_22_bgra_mask12", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM12, 1, 1, 0, 0 },
- { SHADER_IMGNAT_MASK12_NOMUL, imgnat_mask12_nomul_vert_src, imgnat_mask12_nomul_frag_src, "imgnat_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMGNAT_BGRA_MASK12_NOMUL, imgnat_bgra_mask12_nomul_vert_src, imgnat_bgra_mask12_nomul_frag_src, "imgnat_bgra_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMGNAT_12_MASK12_NOMUL, imgnat_12_mask12_nomul_vert_src, imgnat_12_mask12_nomul_frag_src, "imgnat_12_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMGNAT_21_MASK12_NOMUL, imgnat_21_mask12_nomul_vert_src, imgnat_21_mask12_nomul_frag_src, "imgnat_21_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMGNAT_22_MASK12_NOMUL, imgnat_22_mask12_nomul_vert_src, imgnat_22_mask12_nomul_frag_src, "imgnat_22_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM12, 0, 1, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK12_NOMUL, imgnat_12_bgra_mask12_nomul_vert_src, imgnat_12_bgra_mask12_nomul_frag_src, "imgnat_12_bgra_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK12_NOMUL, imgnat_21_bgra_mask12_nomul_vert_src, imgnat_21_bgra_mask12_nomul_frag_src, "imgnat_21_bgra_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK12_NOMUL, imgnat_22_bgra_mask12_nomul_vert_src, imgnat_22_bgra_mask12_nomul_frag_src, "imgnat_22_bgra_mask12_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM12, 1, 1, 1, 0 },
- { SHADER_IMGNAT_MASK21, imgnat_mask21_vert_src, imgnat_mask21_frag_src, "imgnat_mask21", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMGNAT_BGRA_MASK21, imgnat_bgra_mask21_vert_src, imgnat_bgra_mask21_frag_src, "imgnat_bgra_mask21", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMGNAT_12_MASK21, imgnat_12_mask21_vert_src, imgnat_12_mask21_frag_src, "imgnat_12_mask21", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMGNAT_21_MASK21, imgnat_21_mask21_vert_src, imgnat_21_mask21_frag_src, "imgnat_21_mask21", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMGNAT_22_MASK21, imgnat_22_mask21_vert_src, imgnat_22_mask21_frag_src, "imgnat_22_mask21", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM21, 0, 1, 0, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK21, imgnat_12_bgra_mask21_vert_src, imgnat_12_bgra_mask21_frag_src, "imgnat_12_bgra_mask21", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK21, imgnat_21_bgra_mask21_vert_src, imgnat_21_bgra_mask21_frag_src, "imgnat_21_bgra_mask21", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK21, imgnat_22_bgra_mask21_vert_src, imgnat_22_bgra_mask21_frag_src, "imgnat_22_bgra_mask21", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM21, 1, 1, 0, 0 },
- { SHADER_IMGNAT_MASK21_NOMUL, imgnat_mask21_nomul_vert_src, imgnat_mask21_nomul_frag_src, "imgnat_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMGNAT_BGRA_MASK21_NOMUL, imgnat_bgra_mask21_nomul_vert_src, imgnat_bgra_mask21_nomul_frag_src, "imgnat_bgra_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMGNAT_12_MASK21_NOMUL, imgnat_12_mask21_nomul_vert_src, imgnat_12_mask21_nomul_frag_src, "imgnat_12_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMGNAT_21_MASK21_NOMUL, imgnat_21_mask21_nomul_vert_src, imgnat_21_mask21_nomul_frag_src, "imgnat_21_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMGNAT_22_MASK21_NOMUL, imgnat_22_mask21_nomul_vert_src, imgnat_22_mask21_nomul_frag_src, "imgnat_22_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM21, 0, 1, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK21_NOMUL, imgnat_12_bgra_mask21_nomul_vert_src, imgnat_12_bgra_mask21_nomul_frag_src, "imgnat_12_bgra_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK21_NOMUL, imgnat_21_bgra_mask21_nomul_vert_src, imgnat_21_bgra_mask21_nomul_frag_src, "imgnat_21_bgra_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK21_NOMUL, imgnat_22_bgra_mask21_nomul_vert_src, imgnat_22_bgra_mask21_nomul_frag_src, "imgnat_22_bgra_mask21_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM21, 1, 1, 1, 0 },
- { SHADER_IMGNAT_MASK22, imgnat_mask22_vert_src, imgnat_mask22_frag_src, "imgnat_mask22", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMGNAT_BGRA_MASK22, imgnat_bgra_mask22_vert_src, imgnat_bgra_mask22_frag_src, "imgnat_bgra_mask22", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMGNAT_12_MASK22, imgnat_12_mask22_vert_src, imgnat_12_mask22_frag_src, "imgnat_12_mask22", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMGNAT_21_MASK22, imgnat_21_mask22_vert_src, imgnat_21_mask22_frag_src, "imgnat_21_mask22", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMGNAT_22_MASK22, imgnat_22_mask22_vert_src, imgnat_22_mask22_frag_src, "imgnat_22_mask22", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM22, 0, 1, 0, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK22, imgnat_12_bgra_mask22_vert_src, imgnat_12_bgra_mask22_frag_src, "imgnat_12_bgra_mask22", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK22, imgnat_21_bgra_mask22_vert_src, imgnat_21_bgra_mask22_frag_src, "imgnat_21_bgra_mask22", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK22, imgnat_22_bgra_mask22_vert_src, imgnat_22_bgra_mask22_frag_src, "imgnat_22_bgra_mask22", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM22, 1, 1, 0, 0 },
- { SHADER_IMGNAT_MASK22_NOMUL, imgnat_mask22_nomul_vert_src, imgnat_mask22_nomul_frag_src, "imgnat_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMGNAT_BGRA_MASK22_NOMUL, imgnat_bgra_mask22_nomul_vert_src, imgnat_bgra_mask22_nomul_frag_src, "imgnat_bgra_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMGNAT_12_MASK22_NOMUL, imgnat_12_mask22_nomul_vert_src, imgnat_12_mask22_nomul_frag_src, "imgnat_12_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMGNAT_21_MASK22_NOMUL, imgnat_21_mask22_nomul_vert_src, imgnat_21_mask22_nomul_frag_src, "imgnat_21_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMGNAT_22_MASK22_NOMUL, imgnat_22_mask22_nomul_vert_src, imgnat_22_mask22_nomul_frag_src, "imgnat_22_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM22, 0, 1, 1, 0 },
- { SHADER_IMGNAT_12_BGRA_MASK22_NOMUL, imgnat_12_bgra_mask22_nomul_vert_src, imgnat_12_bgra_mask22_nomul_frag_src, "imgnat_12_bgra_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMGNAT_21_BGRA_MASK22_NOMUL, imgnat_21_bgra_mask22_nomul_vert_src, imgnat_21_bgra_mask22_nomul_frag_src, "imgnat_21_bgra_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMGNAT_22_BGRA_MASK22_NOMUL, imgnat_22_bgra_mask22_nomul_vert_src, imgnat_22_bgra_mask22_nomul_frag_src, "imgnat_22_bgra_mask22_nomul", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM22, 1, 1, 1, 0 },
- { SHADER_IMGNAT_AFILL, imgnat_afill_vert_src, imgnat_afill_frag_src, "imgnat_afill", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMGNAT_BGRA_AFILL, imgnat_bgra_afill_vert_src, imgnat_bgra_afill_frag_src, "imgnat_bgra_afill", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMGNAT_NOMUL_AFILL, imgnat_nomul_afill_vert_src, imgnat_nomul_afill_frag_src, "imgnat_nomul_afill", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMGNAT_BGRA_NOMUL_AFILL, imgnat_bgra_nomul_afill_vert_src, imgnat_bgra_nomul_afill_frag_src, "imgnat_bgra_nomul_afill", SHD_IMAGENATIVE, SHD_SAM11, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMGNAT_12_AFILL, imgnat_12_afill_vert_src, imgnat_12_afill_frag_src, "imgnat_12_afill", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMGNAT_21_AFILL, imgnat_21_afill_vert_src, imgnat_21_afill_frag_src, "imgnat_21_afill", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMGNAT_22_AFILL, imgnat_22_afill_vert_src, imgnat_22_afill_frag_src, "imgnat_22_afill", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_IMGNAT_12_BGRA_AFILL, imgnat_12_bgra_afill_vert_src, imgnat_12_bgra_afill_frag_src, "imgnat_12_bgra_afill", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMGNAT_21_BGRA_AFILL, imgnat_21_bgra_afill_vert_src, imgnat_21_bgra_afill_frag_src, "imgnat_21_bgra_afill", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMGNAT_22_BGRA_AFILL, imgnat_22_bgra_afill_vert_src, imgnat_22_bgra_afill_frag_src, "imgnat_22_bgra_afill", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 0, 0, 1 },
- { SHADER_IMGNAT_12_NOMUL_AFILL, imgnat_12_nomul_afill_vert_src, imgnat_12_nomul_afill_frag_src, "imgnat_12_nomul_afill", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMGNAT_21_NOMUL_AFILL, imgnat_21_nomul_afill_vert_src, imgnat_21_nomul_afill_frag_src, "imgnat_21_nomul_afill", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMGNAT_22_NOMUL_AFILL, imgnat_22_nomul_afill_vert_src, imgnat_22_nomul_afill_frag_src, "imgnat_22_nomul_afill", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_IMGNAT_12_BGRA_NOMUL_AFILL, imgnat_12_bgra_nomul_afill_vert_src, imgnat_12_bgra_nomul_afill_frag_src, "imgnat_12_bgra_nomul_afill", SHD_IMAGENATIVE, SHD_SAM12, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMGNAT_21_BGRA_NOMUL_AFILL, imgnat_21_bgra_nomul_afill_vert_src, imgnat_21_bgra_nomul_afill_frag_src, "imgnat_21_bgra_nomul_afill", SHD_IMAGENATIVE, SHD_SAM21, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_IMGNAT_22_BGRA_NOMUL_AFILL, imgnat_22_bgra_nomul_afill_vert_src, imgnat_22_bgra_nomul_afill_frag_src, "imgnat_22_bgra_nomul_afill", SHD_IMAGENATIVE, SHD_SAM22, SHD_SAM11, 1, 0, 1, 1 },
- { SHADER_RGB_A_PAIR, rgb_a_pair_vert_src, rgb_a_pair_frag_src, "rgb_a_pair", SHD_RGB_A_PAIR, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_RGB_A_PAIR_MASK, rgb_a_pair_mask_vert_src, rgb_a_pair_mask_frag_src, "rgb_a_pair_mask", SHD_RGB_A_PAIR, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_RGB_A_PAIR_NOMUL, rgb_a_pair_nomul_vert_src, rgb_a_pair_nomul_frag_src, "rgb_a_pair_nomul", SHD_RGB_A_PAIR, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_RGB_A_PAIR_MASK_NOMUL, rgb_a_pair_mask_nomul_vert_src, rgb_a_pair_mask_nomul_frag_src, "rgb_a_pair_mask_nomul", SHD_RGB_A_PAIR, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_TEX_EXTERNAL, tex_external_vert_src, tex_external_frag_src, "tex_external", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_TEX_EXTERNAL_AFILL, tex_external_afill_vert_src, tex_external_afill_frag_src, "tex_external_afill", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 0, 0, 1 },
- { SHADER_TEX_EXTERNAL_NOMUL, tex_external_nomul_vert_src, tex_external_nomul_frag_src, "tex_external_nomul", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_TEX_EXTERNAL_NOMUL_AFILL, tex_external_nomul_afill_vert_src, tex_external_nomul_afill_frag_src, "tex_external_nomul_afill", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 0, 1, 1 },
- { SHADER_TEX_EXTERNAL_MASK, tex_external_mask_vert_src, tex_external_mask_frag_src, "tex_external_mask", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_TEX_EXTERNAL_MASK_NOMUL, tex_external_mask_nomul_vert_src, tex_external_mask_nomul_frag_src, "tex_external_mask_nomul", SHD_TEX_EXTERNAL, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_YUV, yuv_vert_src, yuv_frag_src, "yuv", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_YUV_NOMUL, yuv_nomul_vert_src, yuv_nomul_frag_src, "yuv_nomul", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_YUV_MASK, yuv_mask_vert_src, yuv_mask_frag_src, "yuv_mask", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_YUV_MASK_NOMUL, yuv_mask_nomul_vert_src, yuv_mask_nomul_frag_src, "yuv_mask_nomul", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_YUY2, yuy2_vert_src, yuy2_frag_src, "yuy2", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_YUY2_NOMUL, yuy2_nomul_vert_src, yuy2_nomul_frag_src, "yuy2_nomul", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_YUY2_MASK, yuy2_mask_vert_src, yuy2_mask_frag_src, "yuy2_mask", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_YUY2_MASK_NOMUL, yuy2_mask_nomul_vert_src, yuy2_mask_nomul_frag_src, "yuy2_mask_nomul", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_NV12, nv12_vert_src, nv12_frag_src, "nv12", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_NV12_NOMUL, nv12_nomul_vert_src, nv12_nomul_frag_src, "nv12_nomul", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_NV12_MASK, nv12_mask_vert_src, nv12_mask_frag_src, "nv12_mask", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_NV12_MASK_NOMUL, nv12_mask_nomul_vert_src, nv12_mask_nomul_frag_src, "nv12_mask_nomul", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_YUV_709, yuv_709_vert_src, yuv_709_frag_src, "yuv_709", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_YUV_709_NOMUL, yuv_709_nomul_vert_src, yuv_709_nomul_frag_src, "yuv_709_nomul", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_YUV_709_MASK, yuv_709_mask_vert_src, yuv_709_mask_frag_src, "yuv_709_mask", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_YUV_709_MASK_NOMUL, yuv_709_mask_nomul_vert_src, yuv_709_mask_nomul_frag_src, "yuv_709_mask_nomul", SHD_YUV, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_YUY2_709, yuy2_709_vert_src, yuy2_709_frag_src, "yuy2_709", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_YUY2_709_NOMUL, yuy2_709_nomul_vert_src, yuy2_709_nomul_frag_src, "yuy2_709_nomul", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_YUY2_709_MASK, yuy2_709_mask_vert_src, yuy2_709_mask_frag_src, "yuy2_709_mask", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_YUY2_709_MASK_NOMUL, yuy2_709_mask_nomul_vert_src, yuy2_709_mask_nomul_frag_src, "yuy2_709_mask_nomul", SHD_YUY2, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
- { SHADER_NV12_709, nv12_709_vert_src, nv12_709_frag_src, "nv12_709", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 0, 0, 0 },
- { SHADER_NV12_709_NOMUL, nv12_709_nomul_vert_src, nv12_709_nomul_frag_src, "nv12_709_nomul", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 0, 1, 0 },
- { SHADER_NV12_709_MASK, nv12_709_mask_vert_src, nv12_709_mask_frag_src, "nv12_709_mask", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 1, 0, 0 },
- { SHADER_NV12_709_MASK_NOMUL, nv12_709_mask_nomul_vert_src, nv12_709_mask_nomul_frag_src, "nv12_709_mask_nomul", SHD_NV12, SHD_SAM11, SHD_SAM11, 0, 1, 1, 0 },
-};
-
* through cpp first (in which case the precision must be manually added).
*/
-#ifdef GL_ES
-#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-#endif
+FRAGMENT_SHADER
#ifndef SHD_NOMUL
varying vec4 col;
# define SWZ aaaa
#else
# ifndef SHD_BGRA
-# if defined(SHD_IMG) && defined(BIGENDIAN)
+# if defined(SHD_IMG) && defined(SHD_BIGENDIAN)
# define SWZ gbar
# else
# define SWZ bgra
#endif
# else
-# if defined(SHD_IMG) && defined(BIGENDIAN)
+# if defined(SHD_IMG) && defined(SHD_BIGENDIAN)
# define SWZ grab
# else
# define SWZ rgba
# endif
#endif
+#ifdef SHD_AFILL
+ c.a = 1.0;
+#endif
+
gl_FragColor =
c
#ifndef SHD_NOMUL
* texture2D(texa, tex_a).r
#endif
;
-
-#ifdef SHD_AFILL
- gl_FragColor.a = 1.0;
-#endif
}
#!/bin/bash
-set -e
+# This script will generate a C file containing all the shaders used by Evas
-ENDIAN="$1"
DIR=`dirname $0`
-OUTPUT=${DIR}/evas_gl_shaders"$1".x
-OUTPUT_ENUM=${DIR}/evas_gl_enum.x
-CPP="cpp -P"
-VTX_HEADER="#ifdef GL_ES
-precision highp float;
-#endif
-"
-
-FGM_HEADER="#ifdef GL_ES
-#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-#endif
-"
-
-# Hack
-FGM_HEADER_OES="#ifdef GL_ES
-# extension GL_OES_EGL_image_external : require
-# ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-# else
-precision mediump float;
-# endif
-# define SAMPLER_EXTERNAL_OES samplerExternalOES
-#else
-# define SAMPLER_EXTERNAL_OES sampler2D
-#endif
-"
+OUTPUT=${DIR}/evas_gl_shaders.x
# Skip generation if there is no diff (or no git)
if ! git rev-parse 2>> /dev/null >> /dev/null ; then exit 0 ; fi
if git diff --quiet --exit-code -- "$DIR"
then
- touch "${OUTPUT}" "${OUTPUT_ENUM}"
+ touch "${OUTPUT}"
exit 0
fi
-function upper() {
- echo $@ |tr '[:lower:]' '[:upper:]'
-}
-
-function run() {
- [ "$V" = "1" ] && echo "$@"
- "$@"
-}
-
-# Urgh
-OIFS=$IFS
-IFS=$'\n' SHADERS=(`cat ${DIR}/shaders.txt`)
-IFS=$OIFS
+exec 1<&-
+exec 1>${OUTPUT}
# Write header
-printf "/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */\n" > ${OUTPUT}
-printf "/* IF IT IS CHANGED PLEASE COMMIT THE CHANGES */\n\n" >> ${OUTPUT}
-
-# Including private for hilights and stuff :)
-printf "#include \"../evas_gl_private.h\"\n\n" >> ${OUTPUT}
-
-# Prepare list of shaders:
-shaders_source=""
-shaders_enum=""
-shaders_type=(frag vert)
-shaders_textures=""
+printf "/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */\n"
+printf "/* IF IT IS CHANGED PLEASE COMMIT THE CHANGES */\n\n"
-# Generate SHD files
-LIST=""
-for (( i = 0; i < ${#SHADERS[@]} ; i++ )) ; do
- s=${SHADERS[$i]}
- if [[ $s == \#* ]] ; then continue ; fi
+for shd in fragment vertex ; do
+ m4 ${DIR}/include.glsl ${DIR}/${shd}.glsl > ${shd}.tmp
- name=`echo $s |cut -d ':' -f 1`
- opts=`echo $s |cut -d ':' -f 2 |tr ',' '\n'`
-
- echo " SHADER $name"
- UNAME=`echo ${name} |tr "[:lower:]" "[:upper:]"`
- OPTS=""
- if [[ "$1" == "_bigendian" ]] ; then OPTS="-DBIGENDIAN"; fi
- FGM=${FGM_HEADER}
- TYPE=`echo ${name} |cut -d '_' -f 1 |tr '[:lower:]' '[:upper:]'`
- bgra=0
- mask=0
- nomul=0
- afill=0
- sam="SAM11"
- masksam="SAM11"
- tex=""
-
- # Urgh. Some fixups
- case $TYPE in
- IMG) TYPE="IMAGE";;
- IMGNAT) TYPE="IMAGENATIVE";;
- RGB) TYPE="RGB_A_PAIR";;
- TEX) TYPE="TEX_EXTERNAL";;
- esac
-
- for opt in $opts ; do
- UP=`upper $opt`
- OPTS="$OPTS -DSHD_${UP}"
- case $opt in
- tex) tex="${tex}tex ";;
- mask) tex="${tex}texm " ; mask=1;;
- texa) tex="${tex}texa ";;
- yuv) tex="${tex}texu texv ";;
- nv12) tex="${tex}texuv ";;
- yuy2) tex="${tex}texuv ";;
- bgra) bgra=1;;
- nomul) nomul=1;;
- afill) afill=1;;
- external) FGM=${FGM_HEADER_OES};;
- sam12) sam="SAM12";;
- sam21) sam="SAM21";;
- sam22) sam="SAM22";;
- masksam12) masksam="SAM12";;
- masksam21) masksam="SAM21";;
- masksam22) masksam="SAM22";;
- esac
+ OIFS=$IFS
+ IFS=$'\n'
+ printf "static const char ${shd}_glsl[] ="
+ for line in `cat ${shd}.tmp` ; do
+ printf "\n \"${line}\\\n\""
done
+ printf ";\n\n"
+ IFS=${OIFS}
- # vertex shader
- filev=${DIR}/${name}_vert.shd
- printf "${VTX_HEADER}" >| ${filev}
- run $CPP $OPTS ${DIR}/vertex.glsl >> ${filev}
-
- # fragment shader
- filef=${DIR}/${name}_frag.shd
- printf "${FGM}" >| ${filef}
- run $CPP $OPTS ${DIR}/fragment.glsl >> ${filef}
-
- k=0
- for shd in ${filef} ${filev} ; do
- shdname=${name}_${shaders_type[$k]}
- k=$(($k + 1))
-
- OIFS=$IFS
- IFS=$'\n'
- printf "static const char ${shdname}_src[] =" >> ${OUTPUT}
- for line in `cat ${shd}` ; do
- printf "\n \"${line}\\\n\"" >> ${OUTPUT}
- done
- printf ";\n\n" >> ${OUTPUT}
- IFS=${OIFS}
- done
-
- shaders_source="${shaders_source} { SHADER_${UNAME}, ${name}_vert_src, ${name}_frag_src, \"${name}\", SHD_${TYPE}, SHD_${sam}, SHD_${masksam}, ${bgra}, ${mask}, ${nomul}, ${afill} },\n"
- shaders_enum="${shaders_enum} SHADER_${UNAME},\n"
-
- # Bind textures to the programs. Only if there is more than 1 texture.
- textures=(${tex})
- if [ ${#textures[@]} -ge 2 ] ; then
- for tname in ${tex} ; do
- shaders_textures="${shaders_textures} { SHADER_${UNAME}, \"${tname}\" },\n"
- done
- fi
+ rm ${shd}.tmp
done
-printf "
-static const struct {
- Evas_GL_Shader id;
- const char *vert;
- const char *frag;
- const char *name;
- Shader_Type type;
- Shader_Sampling sam;
- Shader_Sampling masksam;
- Eina_Bool bgra : 1;
- Eina_Bool mask : 1;
- Eina_Bool nomul : 1;
- Eina_Bool afill : 1;
-} _shaders_source[] = {\n" >> ${OUTPUT}
-
-printf "${shaders_source}};\n\n" >> ${OUTPUT}
-
-printf "/* DO NOT MODIFY THIS FILE AS IT IS AUTO-GENERATED */
-/* IF IT IS CHANGED PLEASE COMMIT THE CHANGES */
-
-typedef enum {
-${shaders_enum} SHADER_LAST
-} Evas_GL_Shader;
-
-#ifdef _EVAS_GL_CONTEXT_C
-
-static struct {
- Evas_GL_Shader id;
- const char *tname;
-} _shaders_textures[] = {
-${shaders_textures} { SHADER_LAST, NULL }
-};
-
-#endif // _EVAS_GL_CONTEXT_C
-" >| ${OUTPUT_ENUM}
-
-# You can remove the files now
-#rm -f ${LIST}
-
--- /dev/null
+define(`FRAGMENT_SHADER',`
+#ifdef GL_ES
+# ifdef SHD_EXTERNAL
+# extension GL_OES_EGL_image_external : require
+# define SAMPLER_EXTERNAL_OES samplerExternalOES
+# endif
+# ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+# else
+precision mediump float;
+# endif
+#else
+# define SAMPLER_EXTERNAL_OES sampler2D
+#endif
+')
+
+define(`VERTEX_SHADER',`
+#ifdef GL_ES
+precision highp float;
+#endif
+')
+
+++ /dev/null
-# All supported shaders, format is (no spaces allowed):
-# name:opt1,opt2,opt3
-
-# Convention for names:
-# type[_SAM[_bgra[_mask[_nomul[_afill]]]]]
-
-
-# Rectangles, lines & polygons
-rect:
-rect_mask:mask
-rect_mask12:mask,masksam12
-rect_mask21:mask,masksam21
-rect_mask22:mask,masksam22
-
-
-# Fonts (alpha only)
-font:tex,alpha
-font_mask:tex,mask,alpha
-font_mask12:tex,mask,masksam12,alpha
-font_mask21:tex,mask,masksam21,alpha
-font_mask22:tex,mask,masksam22,alpha
-
-
-# Images: color version
-img:tex,img
-img_bgra:tex,img,bgra
-img_12:tex,img,sam12
-img_21:tex,img,sam21
-img_22:tex,img,sam22
-img_12_bgra:tex,img,sam12,bgra
-img_21_bgra:tex,img,sam21,bgra
-img_22_bgra:tex,img,sam22,bgra
-
-img_mask:tex,img,mask
-img_bgra_mask:tex,img,mask,bgra
-img_12_mask:tex,img,mask,sam12
-img_21_mask:tex,img,mask,sam21
-img_22_mask:tex,img,mask,sam22
-img_12_bgra_mask:tex,img,mask,sam12,bgra
-img_21_bgra_mask:tex,img,mask,sam21,bgra
-img_22_bgra_mask:tex,img,mask,sam22,bgra
-
-
-# Images: nomul version (copy above with extra nomul flag)
-img_nomul:tex,img,nomul
-img_bgra_nomul:tex,img,nomul,bgra
-img_12_nomul:tex,img,sam12,nomul
-img_21_nomul:tex,img,sam21,nomul
-img_22_nomul:tex,img,sam22,nomul
-img_12_bgra_nomul:tex,img,sam12,bgra,nomul
-img_21_bgra_nomul:tex,img,sam21,bgra,nomul
-img_22_bgra_nomul:tex,img,sam22,bgra,nomul
-
-img_mask_nomul:tex,img,mask,nomul
-img_bgra_mask_nomul:tex,img,mask,nomul,bgra
-img_12_mask_nomul:tex,img,mask,sam12,nomul
-img_21_mask_nomul:tex,img,mask,sam21,nomul
-img_22_mask_nomul:tex,img,mask,sam22,nomul
-img_12_bgra_mask_nomul:tex,img,mask,sam12,bgra,nomul
-img_21_bgra_mask_nomul:tex,img,mask,sam21,bgra,nomul
-img_22_bgra_mask_nomul:tex,img,mask,sam22,bgra,nomul
-
-
-# Now the same as above but with MASKSAM
-img_mask12:tex,img,mask,masksam12
-img_bgra_mask12:tex,img,mask,masksam12,bgra
-img_12_mask12:tex,img,mask,masksam12,sam12
-img_21_mask12:tex,img,mask,masksam12,sam21
-img_22_mask12:tex,img,mask,masksam12,sam22
-img_12_bgra_mask12:tex,img,mask,masksam12,sam12,bgra
-img_21_bgra_mask12:tex,img,mask,masksam12,sam21,bgra
-img_22_bgra_mask12:tex,img,mask,masksam12,sam22,bgra
-img_mask12_nomul:tex,img,mask,masksam12,nomul
-img_bgra_mask12_nomul:tex,img,mask,masksam12,nomul,bgra
-img_12_mask12_nomul:tex,img,mask,masksam12,sam12,nomul
-img_21_mask12_nomul:tex,img,mask,masksam12,sam21,nomul
-img_22_mask12_nomul:tex,img,mask,masksam12,sam22,nomul
-img_12_bgra_mask12_nomul:tex,img,mask,masksam12,sam12,bgra,nomul
-img_21_bgra_mask12_nomul:tex,img,mask,masksam12,sam21,bgra,nomul
-img_22_bgra_mask12_nomul:tex,img,mask,masksam12,sam22,bgra,nomul
-
-img_mask21:tex,img,mask,masksam21
-img_bgra_mask21:tex,img,mask,masksam21,bgra
-img_12_mask21:tex,img,mask,masksam21,sam12
-img_21_mask21:tex,img,mask,masksam21,sam21
-img_22_mask21:tex,img,mask,masksam21,sam22
-img_12_bgra_mask21:tex,img,mask,masksam21,sam12,bgra
-img_21_bgra_mask21:tex,img,mask,masksam21,sam21,bgra
-img_22_bgra_mask21:tex,img,mask,masksam21,sam22,bgra
-img_mask21_nomul:tex,img,mask,masksam21,nomul
-img_bgra_mask21_nomul:tex,img,mask,masksam21,nomul,bgra
-img_12_mask21_nomul:tex,img,mask,masksam21,sam12,nomul
-img_21_mask21_nomul:tex,img,mask,masksam21,sam21,nomul
-img_22_mask21_nomul:tex,img,mask,masksam21,sam22,nomul
-img_12_bgra_mask21_nomul:tex,img,mask,masksam21,sam12,bgra,nomul
-img_21_bgra_mask21_nomul:tex,img,mask,masksam21,sam21,bgra,nomul
-img_22_bgra_mask21_nomul:tex,img,mask,masksam21,sam22,bgra,nomul
-
-img_mask22:tex,img,mask,masksam22
-img_bgra_mask22:tex,img,mask,masksam22,bgra
-img_12_mask22:tex,img,mask,masksam22,sam12
-img_21_mask22:tex,img,mask,masksam22,sam21
-img_22_mask22:tex,img,mask,masksam22,sam22
-img_12_bgra_mask22:tex,img,mask,masksam22,sam12,bgra
-img_21_bgra_mask22:tex,img,mask,masksam22,sam21,bgra
-img_22_bgra_mask22:tex,img,mask,masksam22,sam22,bgra
-img_mask22_nomul:tex,img,mask,masksam22,nomul
-img_bgra_mask22_nomul:tex,img,mask,masksam22,nomul,bgra
-img_12_mask22_nomul:tex,img,mask,masksam22,sam12,nomul
-img_21_mask22_nomul:tex,img,mask,masksam22,sam21,nomul
-img_22_mask22_nomul:tex,img,mask,masksam22,sam22,nomul
-img_12_bgra_mask22_nomul:tex,img,mask,masksam22,sam12,bgra,nomul
-img_21_bgra_mask22_nomul:tex,img,mask,masksam22,sam21,bgra,nomul
-img_22_bgra_mask22_nomul:tex,img,mask,masksam22,sam22,bgra,nomul
-
-
-# Some AFILL versions
-img_afill:tex,img,afill
-img_bgra_afill:tex,img,afill,bgra
-img_nomul_afill:tex,img,nomul,afill
-img_bgra_nomul_afill:tex,img,nomul,afill,bgra
-img_12_afill:tex,img,sam12,afill
-img_21_afill:tex,img,sam21,afill
-img_22_afill:tex,img,sam22,afill
-img_12_bgra_afill:tex,img,sam12,bgra,afill
-img_21_bgra_afill:tex,img,sam21,bgra,afill
-img_22_bgra_afill:tex,img,sam22,bgra,afill
-img_12_nomul_afill:tex,img,sam12,nomul,afill
-img_21_nomul_afill:tex,img,sam21,nomul,afill
-img_22_nomul_afill:tex,img,sam22,nomul,afill
-img_12_bgra_nomul_afill:tex,img,sam12,bgra,nomul,afill
-img_21_bgra_nomul_afill:tex,img,sam21,bgra,nomul,afill
-img_22_bgra_nomul_afill:tex,img,sam22,bgra,nomul,afill
-
-
-
-
-
-
-# Images: color version
-imgnat:tex
-imgnat_bgra:tex,bgra
-imgnat_12:tex,sam12
-imgnat_21:tex,sam21
-imgnat_22:tex,sam22
-imgnat_12_bgra:tex,sam12,bgra
-imgnat_21_bgra:tex,sam21,bgra
-imgnat_22_bgra:tex,sam22,bgra
-
-imgnat_mask:tex,mask
-imgnat_bgra_mask:tex,mask,bgra
-imgnat_12_mask:tex,mask,sam12
-imgnat_21_mask:tex,mask,sam21
-imgnat_22_mask:tex,mask,sam22
-imgnat_12_bgra_mask:tex,mask,sam12,bgra
-imgnat_21_bgra_mask:tex,mask,sam21,bgra
-imgnat_22_bgra_mask:tex,mask,sam22,bgra
-
-
-# Images: nomul version (copy above with extra nomul flag)
-imgnat_nomul:tex,nomul
-imgnat_bgra_nomul:tex,nomul,bgra
-imgnat_12_nomul:tex,sam12,nomul
-imgnat_21_nomul:tex,sam21,nomul
-imgnat_22_nomul:tex,sam22,nomul
-imgnat_12_bgra_nomul:tex,sam12,bgra,nomul
-imgnat_21_bgra_nomul:tex,sam21,bgra,nomul
-imgnat_22_bgra_nomul:tex,sam22,bgra,nomul
-
-imgnat_mask_nomul:tex,mask,nomul
-imgnat_bgra_mask_nomul:tex,mask,nomul,bgra
-imgnat_12_mask_nomul:tex,mask,sam12,nomul
-imgnat_21_mask_nomul:tex,mask,sam21,nomul
-imgnat_22_mask_nomul:tex,mask,sam22,nomul
-imgnat_12_bgra_mask_nomul:tex,mask,sam12,bgra,nomul
-imgnat_21_bgra_mask_nomul:tex,mask,sam21,bgra,nomul
-imgnat_22_bgra_mask_nomul:tex,mask,sam22,bgra,nomul
-
-
-# Now the same as above but with MASKSAM
-imgnat_mask12:tex,mask,masksam12
-imgnat_bgra_mask12:tex,mask,masksam12,bgra
-imgnat_12_mask12:tex,mask,masksam12,sam12
-imgnat_21_mask12:tex,mask,masksam12,sam21
-imgnat_22_mask12:tex,mask,masksam12,sam22
-imgnat_12_bgra_mask12:tex,mask,masksam12,sam12,bgra
-imgnat_21_bgra_mask12:tex,mask,masksam12,sam21,bgra
-imgnat_22_bgra_mask12:tex,mask,masksam12,sam22,bgra
-imgnat_mask12_nomul:tex,mask,masksam12,nomul
-imgnat_bgra_mask12_nomul:tex,mask,masksam12,nomul,bgra
-imgnat_12_mask12_nomul:tex,mask,masksam12,sam12,nomul
-imgnat_21_mask12_nomul:tex,mask,masksam12,sam21,nomul
-imgnat_22_mask12_nomul:tex,mask,masksam12,sam22,nomul
-imgnat_12_bgra_mask12_nomul:tex,mask,masksam12,sam12,bgra,nomul
-imgnat_21_bgra_mask12_nomul:tex,mask,masksam12,sam21,bgra,nomul
-imgnat_22_bgra_mask12_nomul:tex,mask,masksam12,sam22,bgra,nomul
-
-imgnat_mask21:tex,mask,masksam21
-imgnat_bgra_mask21:tex,mask,masksam21,bgra
-imgnat_12_mask21:tex,mask,masksam21,sam12
-imgnat_21_mask21:tex,mask,masksam21,sam21
-imgnat_22_mask21:tex,mask,masksam21,sam22
-imgnat_12_bgra_mask21:tex,mask,masksam21,sam12,bgra
-imgnat_21_bgra_mask21:tex,mask,masksam21,sam21,bgra
-imgnat_22_bgra_mask21:tex,mask,masksam21,sam22,bgra
-imgnat_mask21_nomul:tex,mask,masksam21,nomul
-imgnat_bgra_mask21_nomul:tex,mask,masksam21,nomul,bgra
-imgnat_12_mask21_nomul:tex,mask,masksam21,sam12,nomul
-imgnat_21_mask21_nomul:tex,mask,masksam21,sam21,nomul
-imgnat_22_mask21_nomul:tex,mask,masksam21,sam22,nomul
-imgnat_12_bgra_mask21_nomul:tex,mask,masksam21,sam12,bgra,nomul
-imgnat_21_bgra_mask21_nomul:tex,mask,masksam21,sam21,bgra,nomul
-imgnat_22_bgra_mask21_nomul:tex,mask,masksam21,sam22,bgra,nomul
-
-imgnat_mask22:tex,mask,masksam22
-imgnat_bgra_mask22:tex,mask,masksam22,bgra
-imgnat_12_mask22:tex,mask,masksam22,sam12
-imgnat_21_mask22:tex,mask,masksam22,sam21
-imgnat_22_mask22:tex,mask,masksam22,sam22
-imgnat_12_bgra_mask22:tex,mask,masksam22,sam12,bgra
-imgnat_21_bgra_mask22:tex,mask,masksam22,sam21,bgra
-imgnat_22_bgra_mask22:tex,mask,masksam22,sam22,bgra
-imgnat_mask22_nomul:tex,mask,masksam22,nomul
-imgnat_bgra_mask22_nomul:tex,mask,masksam22,nomul,bgra
-imgnat_12_mask22_nomul:tex,mask,masksam22,sam12,nomul
-imgnat_21_mask22_nomul:tex,mask,masksam22,sam21,nomul
-imgnat_22_mask22_nomul:tex,mask,masksam22,sam22,nomul
-imgnat_12_bgra_mask22_nomul:tex,mask,masksam22,sam12,bgra,nomul
-imgnat_21_bgra_mask22_nomul:tex,mask,masksam22,sam21,bgra,nomul
-imgnat_22_bgra_mask22_nomul:tex,mask,masksam22,sam22,bgra,nomul
-
-
-# Some AFILL versions
-imgnat_afill:tex,afill
-imgnat_bgra_afill:tex,afill,bgra
-imgnat_nomul_afill:tex,nomul,afill
-imgnat_bgra_nomul_afill:tex,nomul,afill,bgra
-imgnat_12_afill:tex,sam12,afill
-imgnat_21_afill:tex,sam21,afill
-imgnat_22_afill:tex,sam22,afill
-imgnat_12_bgra_afill:tex,sam12,bgra,afill
-imgnat_21_bgra_afill:tex,sam21,bgra,afill
-imgnat_22_bgra_afill:tex,sam22,bgra,afill
-imgnat_12_nomul_afill:tex,sam12,nomul,afill
-imgnat_21_nomul_afill:tex,sam21,nomul,afill
-imgnat_22_nomul_afill:tex,sam22,nomul,afill
-imgnat_12_bgra_nomul_afill:tex,sam12,bgra,nomul,afill
-imgnat_21_bgra_nomul_afill:tex,sam21,bgra,nomul,afill
-imgnat_22_bgra_nomul_afill:tex,sam22,bgra,nomul,afill
-
-
-
-# RGB+A. We can add more!
-rgb_a_pair:tex,texa
-rgb_a_pair_mask:tex,texa,mask
-rgb_a_pair_nomul:tex,texa,nomul
-rgb_a_pair_mask_nomul:tex,texa,mask,nomul
-#rgb_a_pair_afill:tex,texa,afill
-#rgb_a_pair_nomul_afill:tex,texa,nomul,afill
-
-
-
-# External texture (GLES, OES)
-tex_external:external
-tex_external_afill:external,afill
-tex_external_nomul:external,nomul
-tex_external_nomul_afill:external,nomul,afill
-tex_external_mask:external,mask
-tex_external_mask_nomul:external,mask,nomul
-
-
-# YUV stuff (no need for AFILL)
-yuv:tex,yuv
-yuv_nomul:tex,yuv,nomul
-yuv_mask:tex,yuv,mask
-yuv_mask_nomul:tex,yuv,mask,nomul
-
-yuy2:tex,yuy2
-yuy2_nomul:tex,yuy2,nomul
-yuy2_mask:tex,yuy2,mask
-yuy2_mask_nomul:tex,yuy2,mask,nomul
-
-nv12:tex,nv12
-nv12_nomul:tex,nv12,nomul
-nv12_mask:tex,nv12,mask
-nv12_mask_nomul:tex,nv12,mask,nomul
-
-yuv_709:tex,yuv,yuv_709
-yuv_709_nomul:tex,yuv,yuv_709,nomul
-yuv_709_mask:tex,yuv,yuv_709,mask
-yuv_709_mask_nomul:tex,yuv,yuv_709,mask,nomul
-
-yuy2_709:tex,yuy2,yuv_709
-yuy2_709_nomul:tex,yuy2,yuv_709,nomul
-yuy2_709_mask:tex,yuy2,yuv_709,mask
-yuy2_709_mask_nomul:tex,yuy2,yuv_709,mask,nomul
-
-nv12_709:tex,nv12,yuv_709
-nv12_709_nomul:tex,nv12,yuv_709,nomul
-nv12_709_mask:tex,nv12,yuv_709,mask
-nv12_709_mask_nomul:tex,nv12,yuv_709,mask,nomul
-
* through cpp first (in which case the precision must be manually added).
*/
-#ifdef GL_ES
-precision highp float;
-#endif
+VERTEX_SHADER
attribute vec4 vertex;
uniform mat4 mvp;
-
/* All except nomul */
#ifndef SHD_NOMUL
attribute vec4 color;
Evas_GL_Preload_Render_Call glsym_evas_gl_preload_render_unlock = NULL;
Evas_GL_Preload_Render_Call glsym_evas_gl_preload_render_relax = NULL;
+glsym_func_void glsym_evas_gl_common_shaders_flush = NULL;
glsym_func_void glsym_evas_gl_common_error_set = NULL;
glsym_func_int glsym_evas_gl_common_error_get = NULL;
glsym_func_void_ptr glsym_evas_gl_common_current_context_get = NULL;
-void (*glsym_evas_gl_context_restore_set) (Eina_Bool enable) = NULL;
#ifdef GL_GLES
if (done) return;
#define LINK2GENERIC(sym) \
- glsym_##sym = dlsym(RTLD_DEFAULT, #sym);
+ glsym_##sym = dlsym(RTLD_DEFAULT, #sym); \
+ if (!glsym_##sym) ERR("Could not find function '%s'", #sym);
// Get function pointer to evas_gl_common that is now provided through the link of GL_Generic.
LINK2GENERIC(evas_gl_common_image_all_unload);
LINK2GENERIC(evas_gl_common_error_get);
LINK2GENERIC(evas_gl_common_error_set);
LINK2GENERIC(evas_gl_common_current_context_get);
- LINK2GENERIC(evas_gl_context_restore_set);
+ LINK2GENERIC(evas_gl_common_shaders_flush);
#ifdef GL_GLES
}
static void
+eng_outbuf_idle_flush(Outbuf *ob)
+{
+ if (glsym_evas_gl_common_shaders_flush)
+ glsym_evas_gl_common_shaders_flush(ob->gl_context->shared);
+}
+
+static void
_re_winfree(Render_Engine *re)
{
if (!eng_get_ob(re)->surf) return;
eng_outbuf_new_region_for_update,
eng_outbuf_push_updated_region,
eng_outbuf_push_free_region_for_update,
- NULL,
+ eng_outbuf_idle_flush,
eng_outbuf_flush,
eng_window_free,
eng_window_use,
GLXContext context);
#endif
-extern void (*glsym_evas_gl_context_restore_set) (Eina_Bool enable);
-
#endif
#include "evas_engine.h"
#include "../gl_common/evas_gl_define.h"
+#include <dlfcn.h>
-# define SET_RESTORE_CONTEXT() do { if (glsym_evas_gl_context_restore_set) glsym_evas_gl_context_restore_set(EINA_TRUE); } while(0)
+# define SET_RESTORE_CONTEXT() do { if (glsym_evas_gl_common_context_restore_set) glsym_evas_gl_common_context_restore_set(EINA_TRUE); } while(0)
static Eina_TLS _outbuf_key = 0;
static Eina_TLS _context_key = 0;
+typedef void (*glsym_func_void) ();
+glsym_func_void glsym_evas_gl_common_context_restore_set = NULL;
+
#ifdef GL_GLES
typedef EGLContext GLContext;
typedef EGLConfig GLConfig;
if (initted)
return EINA_TRUE;
+#define LINK2GENERIC(sym) \
+ glsym_##sym = dlsym(RTLD_DEFAULT, #sym); \
+ if (!glsym_##sym) ERR("Could not find function '%s'", #sym);
+
+ LINK2GENERIC(evas_gl_common_context_restore_set);
+
// FIXME: These resources are never released
if (!eina_tls_new(&_outbuf_key))
goto error;
glsym_func_void glsym_evas_gl_common_error_set = NULL;
glsym_func_int glsym_evas_gl_common_error_get = NULL;
glsym_func_void_ptr glsym_evas_gl_common_current_context_get = NULL;
-void (*glsym_evas_gl_context_restore_set) (Eina_Bool enable) = NULL;
+// TIZEN_ONLY(20160425): Fix linking to 'context_restore_set'
+//void (*glsym_evas_gl_context_restore_set) (Eina_Bool enable) = NULL;
+//
_eng_fn (*glsym_eglGetProcAddress) (const char *a) = NULL;
void *(*glsym_eglCreateImage) (EGLDisplay a, EGLContext b, EGLenum c, EGLClientBuffer d, const int *e) = NULL;
LINK2GENERIC(evas_gl_common_error_get);
LINK2GENERIC(evas_gl_common_error_set);
LINK2GENERIC(evas_gl_common_current_context_get);
- LINK2GENERIC(evas_gl_context_restore_set);
+// TIZEN_ONLY(20160425): Fix linking to 'context_restore_set'
+// LINK2GENERIC(evas_gl_context_restore_set);
+//
#define FINDSYM(dst, sym, typ) \
if (glsym_eglGetProcAddress) { \
return 0;
}
-extern void (*glsym_evas_gl_context_restore_set) (Eina_Bool enable);
+// TIZEN_ONLY(20160425): Fix linking to 'context_restore_set'
+// extern void (*glsym_evas_gl_context_restore_set) (Eina_Bool enable);
+//
#endif
#include "evas_engine.h"
+// TIZEN_ONLY(20160425): Fix linking to 'context_restore_set'
+#include <dlfcn.h>
-# define SET_RESTORE_CONTEXT() do { if (glsym_evas_gl_context_restore_set) glsym_evas_gl_context_restore_set(EINA_TRUE); } while(0)
+# define SET_RESTORE_CONTEXT() do { if (glsym_evas_gl_common_context_restore_set) glsym_evas_gl_common_context_restore_set(EINA_TRUE); } while(0)
/* local function prototypes */
+typedef void (*glsym_func_void) ();
+glsym_func_void glsym_evas_gl_common_context_restore_set = NULL;
+//
/* local variables */
static Outbuf *_evas_gl_wl_window = NULL;
/* try to allocate space for our window */
if (!(gw = calloc(1, sizeof(Outbuf))))
return NULL;
+// TIZEN_ONLY(20160425): Fix linking to 'context_restore_set'
+#define LINK2GENERIC(sym) \
+ do { \
+ if (!glsym_##sym) {\
+ glsym_##sym = dlsym(RTLD_DEFAULT, #sym); \
+ if (!glsym_##sym) ERR("Could not find function '%s'", #sym); }\
+ } while(0)
+
+ LINK2GENERIC(evas_gl_common_context_restore_set);
+//
win_count++;
gw->info = einfo;
}
END_TEST
+START_TEST(eina_test_file_mktemp)
+{
+ Eina_Tmpstr *tmpfile, *tmpdir = NULL;
+ char buf[PATH_MAX], fmt[256];
+ Eina_File_Direct_Info *info;
+ Eina_Iterator *it;
+ Eina_File *file;
+ int fd;
+
+ static const char *patterns[] = {
+ "XXXXXX",
+ "XXXXXX.txt",
+ "eina_file_test_XXXXXX",
+ "eina_file_test_XXXXXX.txt",
+ "./eina_file_test_XXXXXX.txt",
+ };
+
+ errno = 0;
+
+ /* test NULL */
+ fd = eina_file_mkstemp(NULL, NULL);
+ fail_if(fd >= 0);
+
+ fd = eina_file_mkstemp(patterns[0], NULL);
+ fail_if((fd < 0) || errno);
+
+ /* here's an attempt at removing the file, without knowing its path */
+#ifdef F_GETPATH
+ /* most likely Mac OS */
+ if (fcntl(fd, F_GETPATH, buf) != -1)
+ unlink(buf);
+#elif !defined _WIN32
+ sprintf(fmt, "/proc/self/fd/%d", fd);
+ if (readlink(fmt, buf, sizeof(buf)))
+ unlink(buf);
+#else
+ // TODO: need to implement windows support with GetFinalPathNameByHandle
+#endif
+ close(fd);
+
+ for (unsigned int k = 0; k < sizeof(patterns) / sizeof(patterns[0]); k++)
+ {
+ errno = 0;
+ tmpfile = NULL;
+ fd = eina_file_mkstemp(patterns[k], &tmpfile);
+ fail_if((fd < 0) || !tmpfile || errno);
+ file = eina_file_open(tmpfile, EINA_FALSE);
+ fail_if(!file);
+ eina_file_close(file);
+ unlink(tmpfile);
+ eina_tmpstr_del(tmpfile);
+ close(fd);
+ }
+
+ /* temp directory */
+ fail_if(!eina_file_mkdtemp("eina_file_test_XXXXXX", &tmpdir) || !tmpdir);
+
+ it = eina_file_direct_ls(tmpdir);
+ fail_if(!it);
+
+ /* should be empty! */
+ EINA_ITERATOR_FOREACH(it, info)
+ fail();
+
+ eina_iterator_free(it);
+
+ /* file inside that directory */
+ eina_file_path_join(buf, sizeof(buf), tmpdir, "eina_file_test_XXXXXX.txt");
+
+ fd = eina_file_mkstemp(buf, &tmpfile);
+ fail_if((fd < 0) || !tmpfile || errno);
+ close(fd);
+
+ it = eina_file_direct_ls(tmpdir);
+ fail_if(!it);
+
+ /* should be empty! */
+ EINA_ITERATOR_FOREACH(it, info)
+ fail_if(strcmp(info->path, tmpfile));
+
+ eina_iterator_free(it);
+
+ unlink(tmpfile);
+ remove(tmpdir);
+}
+END_TEST
+
void
eina_test_file(TCase *tc)
{
tcase_add_test(tc, eina_test_file_xattr);
#endif
tcase_add_test(tc, eina_test_file_copy);
+ tcase_add_test(tc, eina_test_file_mktemp);
}
projects / platform / upstream / efl.git / commitdiff