isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-01 12:20:47 -05:00
Code Issues Packages Projects Releases Wiki Activity

cogl-gles2: Prefix internal GLES 2 wrapper symbols with _

Browse Source 
Some internal symbols used for the GLES 2 wrapper were accidentally
being exported. This prepends an underscore to them so they won't
appear in the shared library.
This commit is contained in:
Neil Roberts 2010-06-11 14:36:38 +01:00
parent 0bbf50f905
commit 9343cb849a
6 changed files with 213 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cogl/driver/gles/cogl-context-driver.c
View File

@ -40,7 +40,7 @@ _cogl_create_context_driver (CoglContext *_context)
/* Init the GLES2 wrapper */ /* Init the GLES2 wrapper */
#ifdef HAVE_COGL_GLES2 #ifdef HAVE_COGL_GLES2
cogl_gles2_wrapper_init (&_context->drv.gles2); _cogl_gles2_wrapper_init (&_context->drv.gles2);
#endif #endif
} }

30
cogl/driver/gles/cogl-fixed-fragment-shader.glsl
View File

@ -1,20 +1,20 @@
/*** cogl_fixed_fragment_shader_variables_start ***/ /*** _cogl_fixed_fragment_shader_variables_start ***/
/* There is no default precision for floats in fragment shaders in /* There is no default precision for floats in fragment shaders in
GLES 2 so we need to define one */ GLES 2 so we need to define one */
precision highp float; precision highp float;
/*** cogl_fixed_fragment_shader_inputs ***/ /*** _cogl_fixed_fragment_shader_inputs ***/
/* Inputs from the vertex shader */ /* Inputs from the vertex shader */
varying vec4 frag_color; varying vec4 frag_color;
varying float fog_amount; varying float fog_amount;
/*** cogl_fixed_fragment_shader_texturing_options ***/ /*** _cogl_fixed_fragment_shader_texturing_options ***/
/* Texturing options */ /* Texturing options */
/*** cogl_fixed_fragment_shader_fogging_options ***/ /*** _cogl_fixed_fragment_shader_fogging_options ***/
/* Fogging options */ /* Fogging options */
uniform vec4 fog_color; uniform vec4 fog_color;
@ -22,41 +22,41 @@ uniform vec4 fog_color;
/* Alpha test options */ /* Alpha test options */
uniform float alpha_test_ref; uniform float alpha_test_ref;
/*** cogl_fixed_fragment_shader_main_declare ***/ /*** _cogl_fixed_fragment_shader_main_declare ***/
void void
main (void) main (void)
{ {
/*** cogl_fixed_fragment_shader_main_start ***/ /*** _cogl_fixed_fragment_shader_main_start ***/
/*** cogl_fixed_fragment_shader_fog ***/ /*** _cogl_fixed_fragment_shader_fog ***/
/* Mix the calculated color with the fog color */ /* Mix the calculated color with the fog color */
gl_FragColor.rgb = mix (fog_color.rgb, gl_FragColor.rgb, fog_amount); gl_FragColor.rgb = mix (fog_color.rgb, gl_FragColor.rgb, fog_amount);
/* Alpha testing */ /* Alpha testing */
/*** cogl_fixed_fragment_shader_alpha_never ***/ /*** _cogl_fixed_fragment_shader_alpha_never ***/
discard; discard;
/*** cogl_fixed_fragment_shader_alpha_less ***/ /*** _cogl_fixed_fragment_shader_alpha_less ***/
if (gl_FragColor.a >= alpha_test_ref) if (gl_FragColor.a >= alpha_test_ref)
discard; discard;
/*** cogl_fixed_fragment_shader_alpha_equal ***/ /*** _cogl_fixed_fragment_shader_alpha_equal ***/
if (gl_FragColor.a != alpha_test_ref) if (gl_FragColor.a != alpha_test_ref)
discard; discard;
/*** cogl_fixed_fragment_shader_alpha_lequal ***/ /*** _cogl_fixed_fragment_shader_alpha_lequal ***/
if (gl_FragColor.a > alpha_test_ref) if (gl_FragColor.a > alpha_test_ref)
discard; discard;
/*** cogl_fixed_fragment_shader_alpha_greater ***/ /*** _cogl_fixed_fragment_shader_alpha_greater ***/
if (gl_FragColor.a <= alpha_test_ref) if (gl_FragColor.a <= alpha_test_ref)
discard; discard;
/*** cogl_fixed_fragment_shader_alpha_notequal ***/ /*** _cogl_fixed_fragment_shader_alpha_notequal ***/
if (gl_FragColor.a == alpha_test_ref) if (gl_FragColor.a == alpha_test_ref)
discard; discard;
/*** cogl_fixed_fragment_shader_alpha_gequal ***/ /*** _cogl_fixed_fragment_shader_alpha_gequal ***/
if (gl_FragColor.a < alpha_test_ref) if (gl_FragColor.a < alpha_test_ref)
discard; discard;
/*** cogl_fixed_fragment_shader_end ***/ /*** _cogl_fixed_fragment_shader_end ***/
} }

24
cogl/driver/gles/cogl-fixed-vertex-shader.glsl
View File

@ -1,29 +1,29 @@
/*** cogl_fixed_vertex_shader_per_vertex_attribs ***/ /*** _cogl_fixed_vertex_shader_per_vertex_attribs ***/
/* Per vertex attributes */ /* Per vertex attributes */
attribute vec4 vertex_attrib; attribute vec4 vertex_attrib;
attribute vec4 color_attrib; attribute vec4 color_attrib;
/*** cogl_fixed_vertex_shader_transform_matrices ***/ /*** _cogl_fixed_vertex_shader_transform_matrices ***/
/* Transformation matrices */ /* Transformation matrices */
uniform mat4 modelview_matrix; uniform mat4 modelview_matrix;
uniform mat4 mvp_matrix; /* combined modelview and projection matrix */ uniform mat4 mvp_matrix; /* combined modelview and projection matrix */
/*** cogl_fixed_vertex_shader_output_variables ***/ /*** _cogl_fixed_vertex_shader_output_variables ***/
/* Outputs to the fragment shader */ /* Outputs to the fragment shader */
varying vec4 frag_color; varying vec4 frag_color;
varying float fog_amount; varying float fog_amount;
/*** cogl_fixed_vertex_shader_fogging_options ***/ /*** _cogl_fixed_vertex_shader_fogging_options ***/
/* Fogging options */ /* Fogging options */
uniform float fog_density; uniform float fog_density;
uniform float fog_start; uniform float fog_start;
uniform float fog_end; uniform float fog_end;
/*** cogl_fixed_vertex_shader_main_start ***/ /*** _cogl_fixed_vertex_shader_main_start ***/
void void
main (void) main (void)
@ -35,12 +35,12 @@ main (void)
/* Calculate the transformed texture coordinate */ /* Calculate the transformed texture coordinate */
/*** cogl_fixed_vertex_shader_frag_color_start ***/ /*** _cogl_fixed_vertex_shader_frag_color_start ***/
/* Pass the interpolated vertex color on to the fragment shader */ /* Pass the interpolated vertex color on to the fragment shader */
frag_color = color_attrib; frag_color = color_attrib;
/*** cogl_fixed_vertex_shader_fog_start ***/ /*** _cogl_fixed_vertex_shader_fog_start ***/
/* Estimate the distance from the eye using just the z-coordinate to /* Estimate the distance from the eye using just the z-coordinate to
use as the fog coord */ use as the fog coord */
@ -50,16 +50,16 @@ main (void)
/* Calculate the fog amount per-vertex and interpolate it for the /* Calculate the fog amount per-vertex and interpolate it for the
fragment shader */ fragment shader */
/*** cogl_fixed_vertex_shader_fog_exp ***/ /*** _cogl_fixed_vertex_shader_fog_exp ***/
fog_amount = exp (-fog_density * fog_coord); fog_amount = exp (-fog_density * fog_coord);
/*** cogl_fixed_vertex_shader_fog_exp2 ***/ /*** _cogl_fixed_vertex_shader_fog_exp2 ***/
fog_amount = exp (-fog_density * fog_coord fog_amount = exp (-fog_density * fog_coord
* fog_density * fog_coord); * fog_density * fog_coord);
/*** cogl_fixed_vertex_shader_fog_linear ***/ /*** _cogl_fixed_vertex_shader_fog_linear ***/
fog_amount = (fog_end - fog_coord) / (fog_end - fog_start); fog_amount = (fog_end - fog_coord) / (fog_end - fog_start);
/*** cogl_fixed_vertex_shader_fog_end ***/ /*** _cogl_fixed_vertex_shader_fog_end ***/
fog_amount = clamp (fog_amount, 0.0, 1.0); fog_amount = clamp (fog_amount, 0.0, 1.0);
/*** cogl_fixed_vertex_shader_end ***/ /*** _cogl_fixed_vertex_shader_end ***/
} }

201
cogl/driver/gles/cogl-gles2-wrapper.c
View File

@ -118,7 +118,7 @@ initialize_texture_units (CoglGles2Wrapper *w)
/* We will need to set the matrix mode to GL_TEXTURE to /* We will need to set the matrix mode to GL_TEXTURE to
* initialise any new texture units, so we save the current * initialise any new texture units, so we save the current
* mode for restoring afterwards */ * mode for restoring afterwards */
GE( cogl_wrap_glGetIntegerv (GL_MATRIX_MODE, &prev_mode)); GE( _cogl_wrap_glGetIntegerv (GL_MATRIX_MODE, &prev_mode));
for (i = 0; i < COGL_GLES2_MAX_TEXTURE_UNITS; i++) for (i = 0; i < COGL_GLES2_MAX_TEXTURE_UNITS; i++)
{ {
@ -128,36 +128,36 @@ initialize_texture_units (CoglGles2Wrapper *w)
memset (new_unit, 0, sizeof (CoglGles2WrapperTextureUnit)); memset (new_unit, 0, sizeof (CoglGles2WrapperTextureUnit));
w->active_texture_unit = i; w->active_texture_unit = i;
GE( cogl_wrap_glMatrixMode (GL_TEXTURE)); GE( _cogl_wrap_glMatrixMode (GL_TEXTURE));
GE( cogl_wrap_glLoadIdentity ()); GE( _cogl_wrap_glLoadIdentity ());
/* The real GL default is GL_MODULATE but the shader only /* The real GL default is GL_MODULATE but the shader only
supports GL_COMBINE so let's default to that instead */ supports GL_COMBINE so let's default to that instead */
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
GL_COMBINE) ); GL_COMBINE) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB,
GL_MODULATE) ); GL_MODULATE) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_RGB, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_RGB,
GL_PREVIOUS) ); GL_PREVIOUS) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_RGB, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_RGB,
GL_TEXTURE) ); GL_TEXTURE) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
GL_SRC_COLOR) ); GL_SRC_COLOR) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB,
GL_SRC_COLOR) ); GL_SRC_COLOR) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA,
GL_MODULATE) ); GL_MODULATE) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_ALPHA, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_ALPHA,
GL_PREVIOUS) ); GL_PREVIOUS) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_ALPHA, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_ALPHA,
GL_TEXTURE) ); GL_TEXTURE) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA,
GL_SRC_COLOR) ); GL_SRC_COLOR) );
GE( cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GE( _cogl_wrap_glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA,
GL_SRC_COLOR) ); GL_SRC_COLOR) );
} }
GE( cogl_wrap_glMatrixMode ((GLenum) prev_mode)); GE( _cogl_wrap_glMatrixMode ((GLenum) prev_mode));
w->settings.texture_units = 0; w->settings.texture_units = 0;
@ -165,34 +165,34 @@ initialize_texture_units (CoglGles2Wrapper *w)
} }
void void
cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper) _cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper)
{ {
GLfloat default_fog_color[4] = { 0, 0, 0, 0 }; GLfloat default_fog_color[4] = { 0, 0, 0, 0 };
memset (wrapper, 0, sizeof (CoglGles2Wrapper)); memset (wrapper, 0, sizeof (CoglGles2Wrapper));
/* Initialize the stacks */ /* Initialize the stacks */
cogl_wrap_glMatrixMode (GL_PROJECTION); _cogl_wrap_glMatrixMode (GL_PROJECTION);
cogl_wrap_glLoadIdentity (); _cogl_wrap_glLoadIdentity ();
cogl_wrap_glMatrixMode (GL_MODELVIEW); _cogl_wrap_glMatrixMode (GL_MODELVIEW);
cogl_wrap_glLoadIdentity (); _cogl_wrap_glLoadIdentity ();
/* The gl*ActiveTexture wrappers will initialise the texture /* The gl*ActiveTexture wrappers will initialise the texture
* stack for the texture unit when it's first activated */ * stack for the texture unit when it's first activated */
cogl_wrap_glActiveTexture (GL_TEXTURE0); _cogl_wrap_glActiveTexture (GL_TEXTURE0);
cogl_wrap_glClientActiveTexture (GL_TEXTURE0); _cogl_wrap_glClientActiveTexture (GL_TEXTURE0);
/* Initialize the fogging options */ /* Initialize the fogging options */
cogl_wrap_glDisable (GL_FOG); _cogl_wrap_glDisable (GL_FOG);
cogl_wrap_glFogf (GL_FOG_MODE, GL_LINEAR); _cogl_wrap_glFogf (GL_FOG_MODE, GL_LINEAR);
cogl_wrap_glFogf (GL_FOG_DENSITY, 1.0); _cogl_wrap_glFogf (GL_FOG_DENSITY, 1.0);
cogl_wrap_glFogf (GL_FOG_START, 0); _cogl_wrap_glFogf (GL_FOG_START, 0);
cogl_wrap_glFogf (GL_FOG_END, 1); _cogl_wrap_glFogf (GL_FOG_END, 1);
cogl_wrap_glFogfv (GL_FOG_COLOR, default_fog_color); _cogl_wrap_glFogfv (GL_FOG_COLOR, default_fog_color);
/* Initialize alpha testing */ /* Initialize alpha testing */
cogl_wrap_glDisable (GL_ALPHA_TEST); _cogl_wrap_glDisable (GL_ALPHA_TEST);
cogl_wrap_glAlphaFunc (GL_ALWAYS, 0.0f); _cogl_wrap_glAlphaFunc (GL_ALWAYS, 0.0f);
initialize_texture_units (wrapper); initialize_texture_units (wrapper);
} }
@ -295,7 +295,7 @@ cogl_gles2_get_vertex_shader (const CoglGles2WrapperSettings *settings)
return (CoglGles2WrapperShader *) node->data; return (CoglGles2WrapperShader *) node->data;
/* Otherwise create a new shader */ /* Otherwise create a new shader */
shader_source = g_string_new (cogl_fixed_vertex_shader_per_vertex_attribs); shader_source = g_string_new (_cogl_fixed_vertex_shader_per_vertex_attribs);
for (i = 0; i < COGL_GLES2_MAX_TEXTURE_UNITS; i++) for (i = 0; i < COGL_GLES2_MAX_TEXTURE_UNITS; i++)
if (COGL_GLES2_TEXTURE_UNIT_IS_ENABLED (settings->texture_units, i)) if (COGL_GLES2_TEXTURE_UNIT_IS_ENABLED (settings->texture_units, i))
@ -308,8 +308,8 @@ cogl_gles2_get_vertex_shader (const CoglGles2WrapperSettings *settings)
if (COGL_GLES2_TEXTURE_UNIT_IS_ENABLED (settings->texture_units, i)) if (COGL_GLES2_TEXTURE_UNIT_IS_ENABLED (settings->texture_units, i))
n_texture_units = i + 1; n_texture_units = i + 1;
g_string_append (shader_source, cogl_fixed_vertex_shader_transform_matrices); g_string_append (shader_source, _cogl_fixed_vertex_shader_transform_matrices);
g_string_append (shader_source, cogl_fixed_vertex_shader_output_variables); g_string_append (shader_source, _cogl_fixed_vertex_shader_output_variables);
if (n_texture_units > 0) if (n_texture_units > 0)
{ {
@ -322,8 +322,8 @@ cogl_gles2_get_vertex_shader (const CoglGles2WrapperSettings *settings)
n_texture_units); n_texture_units);
} }
g_string_append (shader_source, cogl_fixed_vertex_shader_fogging_options); g_string_append (shader_source, _cogl_fixed_vertex_shader_fogging_options);
g_string_append (shader_source, cogl_fixed_vertex_shader_main_start); g_string_append (shader_source, _cogl_fixed_vertex_shader_main_start);
for (i = 0; i < COGL_GLES2_MAX_TEXTURE_UNITS; i++) for (i = 0; i < COGL_GLES2_MAX_TEXTURE_UNITS; i++)
if (COGL_GLES2_TEXTURE_UNIT_IS_ENABLED (settings->texture_units, i)) if (COGL_GLES2_TEXTURE_UNIT_IS_ENABLED (settings->texture_units, i))
@ -339,31 +339,31 @@ cogl_gles2_get_vertex_shader (const CoglGles2WrapperSettings *settings)
i); i);
} }
g_string_append (shader_source, cogl_fixed_vertex_shader_frag_color_start); g_string_append (shader_source, _cogl_fixed_vertex_shader_frag_color_start);
if (settings->fog_enabled) if (settings->fog_enabled)
{ {
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_start); g_string_append (shader_source, _cogl_fixed_vertex_shader_fog_start);
switch (settings->fog_mode) switch (settings->fog_mode)
{ {
case GL_EXP: case GL_EXP:
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_exp); g_string_append (shader_source, _cogl_fixed_vertex_shader_fog_exp);
break; break;
case GL_EXP2: case GL_EXP2:
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_exp2); g_string_append (shader_source, _cogl_fixed_vertex_shader_fog_exp2);
break; break;
default: default:
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_linear); g_string_append (shader_source, _cogl_fixed_vertex_shader_fog_linear);
break; break;
} }
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_end); g_string_append (shader_source, _cogl_fixed_vertex_shader_fog_end);
} }
g_string_append (shader_source, cogl_fixed_vertex_shader_end); g_string_append (shader_source, _cogl_fixed_vertex_shader_end);
shader_obj = cogl_gles2_wrapper_create_shader (GL_VERTEX_SHADER, shader_obj = cogl_gles2_wrapper_create_shader (GL_VERTEX_SHADER,
shader_source->str); shader_source->str);
@ -585,14 +585,14 @@ cogl_gles2_get_fragment_shader (const CoglGles2WrapperSettings *settings)
return (CoglGles2WrapperShader *) node->data; return (CoglGles2WrapperShader *) node->data;
/* Otherwise create a new shader */ /* Otherwise create a new shader */
shader_source = g_string_new (cogl_fixed_fragment_shader_variables_start); shader_source = g_string_new (_cogl_fixed_fragment_shader_variables_start);
/* Find the biggest enabled texture unit index */ /* Find the biggest enabled texture unit index */
for (i = 0; i < COGL_GLES2_MAX_TEXTURE_UNITS; i++) for (i = 0; i < COGL_GLES2_MAX_TEXTURE_UNITS; i++)
if (COGL_GLES2_TEXTURE_UNIT_IS_ENABLED (settings->texture_units, i)) if (COGL_GLES2_TEXTURE_UNIT_IS_ENABLED (settings->texture_units, i))
n_texture_units = i + 1; n_texture_units = i + 1;
g_string_append (shader_source, cogl_fixed_fragment_shader_inputs); g_string_append (shader_source, _cogl_fixed_fragment_shader_inputs);
if (n_texture_units > 0) if (n_texture_units > 0)
{ {
@ -600,17 +600,18 @@ cogl_gles2_get_fragment_shader (const CoglGles2WrapperSettings *settings)
"varying vec2 tex_coord[%d];\n", "varying vec2 tex_coord[%d];\n",
n_texture_units); n_texture_units);
g_string_append (shader_source, cogl_fixed_fragment_shader_texturing_options); g_string_append (shader_source,
_cogl_fixed_fragment_shader_texturing_options);
g_string_append_printf (shader_source, g_string_append_printf (shader_source,
"uniform sampler2D texture_unit[%d];\n", "uniform sampler2D texture_unit[%d];\n",
n_texture_units); n_texture_units);
} }
g_string_append (shader_source, cogl_fixed_fragment_shader_fogging_options); g_string_append (shader_source, _cogl_fixed_fragment_shader_fogging_options);
g_string_append (shader_source, cogl_fixed_fragment_shader_main_declare); g_string_append (shader_source, _cogl_fixed_fragment_shader_main_declare);
g_string_append (shader_source, cogl_fixed_fragment_shader_main_start); g_string_append (shader_source, _cogl_fixed_fragment_shader_main_start);
/* This pointless extra variable is needed to work around an /* This pointless extra variable is needed to work around an
apparent bug in the PowerVR drivers. Without it the alpha apparent bug in the PowerVR drivers. Without it the alpha
@ -667,41 +668,41 @@ cogl_gles2_get_fragment_shader (const CoglGles2WrapperSettings *settings)
} }
if (settings->fog_enabled) if (settings->fog_enabled)
g_string_append (shader_source, cogl_fixed_fragment_shader_fog); g_string_append (shader_source, _cogl_fixed_fragment_shader_fog);
if (settings->alpha_test_enabled) if (settings->alpha_test_enabled)
switch (settings->alpha_test_func) switch (settings->alpha_test_func)
{ {
case GL_NEVER: case GL_NEVER:
g_string_append (shader_source, g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_never); _cogl_fixed_fragment_shader_alpha_never);
break; break;
case GL_LESS: case GL_LESS:
g_string_append (shader_source, g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_less); _cogl_fixed_fragment_shader_alpha_less);
break; break;
case GL_EQUAL: case GL_EQUAL:
g_string_append (shader_source, g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_equal); _cogl_fixed_fragment_shader_alpha_equal);
break; break;
case GL_LEQUAL: case GL_LEQUAL:
g_string_append (shader_source, g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_lequal); _cogl_fixed_fragment_shader_alpha_lequal);
break; break;
case GL_GREATER: case GL_GREATER:
g_string_append (shader_source, g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_greater); _cogl_fixed_fragment_shader_alpha_greater);
break; break;
case GL_NOTEQUAL: case GL_NOTEQUAL:
g_string_append (shader_source, g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_notequal); _cogl_fixed_fragment_shader_alpha_notequal);
break; break;
case GL_GEQUAL: case GL_GEQUAL:
g_string_append (shader_source, g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_gequal); _cogl_fixed_fragment_shader_alpha_gequal);
} }
g_string_append (shader_source, cogl_fixed_fragment_shader_end); g_string_append (shader_source, _cogl_fixed_fragment_shader_end);
shader_obj = cogl_gles2_wrapper_create_shader (GL_FRAGMENT_SHADER, shader_obj = cogl_gles2_wrapper_create_shader (GL_FRAGMENT_SHADER,
shader_source->str); shader_source->str);
@ -896,7 +897,7 @@ cogl_gles2_wrapper_get_program (const CoglGles2WrapperSettings *settings)
} }
void void
cogl_gles2_wrapper_deinit (CoglGles2Wrapper *wrapper) _cogl_gles2_wrapper_deinit (CoglGles2Wrapper *wrapper)
{ {
GSList *node, *next; GSList *node, *next;
int i; int i;
@ -959,7 +960,7 @@ cogl_gles2_wrapper_notify_matrix_changed (CoglGles2Wrapper *wrapper,
} }
void void
cogl_wrap_glMatrixMode (GLenum mode) _cogl_wrap_glMatrixMode (GLenum mode)
{ {
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -991,7 +992,7 @@ cogl_gles2_get_current_matrix (CoglGles2Wrapper *wrapper)
} }
void void
cogl_wrap_glLoadIdentity (void) _cogl_wrap_glLoadIdentity (void)
{ {
CoglMatrix *matrix; CoglMatrix *matrix;
@ -1005,7 +1006,7 @@ cogl_wrap_glLoadIdentity (void)
} }
void void
cogl_wrap_glLoadMatrixf (const GLfloat *m) _cogl_wrap_glLoadMatrixf (const GLfloat *m)
{ {
CoglMatrix *matrix; CoglMatrix *matrix;
@ -1019,7 +1020,7 @@ cogl_wrap_glLoadMatrixf (const GLfloat *m)
} }
void void
cogl_wrap_glVertexPointer (GLint size, GLenum type, GLsizei stride, _cogl_wrap_glVertexPointer (GLint size, GLenum type, GLsizei stride,
const GLvoid *pointer) const GLvoid *pointer)
{ {
glVertexAttribPointer (COGL_GLES2_WRAPPER_VERTEX_ATTRIB, size, type, glVertexAttribPointer (COGL_GLES2_WRAPPER_VERTEX_ATTRIB, size, type,
@ -1027,7 +1028,7 @@ cogl_wrap_glVertexPointer (GLint size, GLenum type, GLsizei stride,
} }
void void
cogl_wrap_glTexCoordPointer (GLint size, GLenum type, GLsizei stride, _cogl_wrap_glTexCoordPointer (GLint size, GLenum type, GLsizei stride,
const GLvoid *pointer) const GLvoid *pointer)
{ {
int active_unit; int active_unit;
@ -1047,15 +1048,15 @@ cogl_wrap_glTexCoordPointer (GLint size, GLenum type, GLsizei stride,
} }
void void
cogl_wrap_glColorPointer (GLint size, GLenum type, GLsizei stride, _cogl_wrap_glColorPointer (GLint size, GLenum type, GLsizei stride,
const GLvoid *pointer) const GLvoid *pointer)
{ {
glVertexAttribPointer (COGL_GLES2_WRAPPER_COLOR_ATTRIB, size, type, glVertexAttribPointer (COGL_GLES2_WRAPPER_COLOR_ATTRIB, size, type,
GL_TRUE, stride, pointer); GL_TRUE, stride, pointer);
} }
void void
cogl_wrap_glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer) _cogl_wrap_glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
{ {
glVertexAttribPointer (COGL_GLES2_WRAPPER_NORMAL_ATTRIB, 1, type, glVertexAttribPointer (COGL_GLES2_WRAPPER_NORMAL_ATTRIB, 1, type,
GL_FALSE, stride, pointer); GL_FALSE, stride, pointer);
@ -1134,7 +1135,7 @@ cogl_gles2_do_set_uniform (GLint location, CoglBoxedValue *value)
} }
static void static void
cogl_wrap_prepare_for_draw (void) _cogl_wrap_prepare_for_draw (void)
{ {
CoglGles2WrapperProgram *program; CoglGles2WrapperProgram *program;
@ -1320,24 +1321,24 @@ cogl_wrap_prepare_for_draw (void)
} }
void void
cogl_wrap_glDrawArrays (GLenum mode, GLint first, GLsizei count) _cogl_wrap_glDrawArrays (GLenum mode, GLint first, GLsizei count)
{ {
cogl_wrap_prepare_for_draw (); _cogl_wrap_prepare_for_draw ();
glDrawArrays (mode, first, count); glDrawArrays (mode, first, count);
} }
void void
cogl_wrap_glDrawElements (GLenum mode, GLsizei count, GLenum type, _cogl_wrap_glDrawElements (GLenum mode, GLsizei count, GLenum type,
const GLvoid *indices) const GLvoid *indices)
{ {
cogl_wrap_prepare_for_draw (); _cogl_wrap_prepare_for_draw ();
glDrawElements (mode, count, type, indices); glDrawElements (mode, count, type, indices);
} }
void void
cogl_wrap_glTexEnvi (GLenum target, GLenum pname, GLint param) _cogl_wrap_glTexEnvi (GLenum target, GLenum pname, GLint param)
{ {
if (target == GL_TEXTURE_ENV) if (target == GL_TEXTURE_ENV)
{ {
@ -1382,7 +1383,7 @@ cogl_wrap_glTexEnvi (GLenum target, GLenum pname, GLint param)
} }
void void
cogl_wrap_glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params) _cogl_wrap_glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params)
{ {
if (target == GL_TEXTURE_ENV && pname == GL_TEXTURE_ENV_COLOR) if (target == GL_TEXTURE_ENV && pname == GL_TEXTURE_ENV_COLOR)
{ {
@ -1397,7 +1398,7 @@ cogl_wrap_glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params)
} }
void void
cogl_wrap_glClientActiveTexture (GLenum texture) _cogl_wrap_glClientActiveTexture (GLenum texture)
{ {
int texture_unit_index = texture - GL_TEXTURE0; int texture_unit_index = texture - GL_TEXTURE0;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1407,7 +1408,7 @@ cogl_wrap_glClientActiveTexture (GLenum texture)
} }
void void
cogl_wrap_glActiveTexture (GLenum texture) _cogl_wrap_glActiveTexture (GLenum texture)
{ {
int texture_unit_index = texture - GL_TEXTURE0; int texture_unit_index = texture - GL_TEXTURE0;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1419,7 +1420,7 @@ cogl_wrap_glActiveTexture (GLenum texture)
} }
void void
cogl_wrap_glEnable (GLenum cap) _cogl_wrap_glEnable (GLenum cap)
{ {
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1450,7 +1451,7 @@ cogl_wrap_glEnable (GLenum cap)
} }
void void
cogl_wrap_glDisable (GLenum cap) _cogl_wrap_glDisable (GLenum cap)
{ {
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1481,7 +1482,7 @@ cogl_wrap_glDisable (GLenum cap)
} }
void void
cogl_wrap_glEnableClientState (GLenum array) _cogl_wrap_glEnableClientState (GLenum array)
{ {
CoglGles2WrapperTextureUnit *texture_unit; CoglGles2WrapperTextureUnit *texture_unit;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1512,7 +1513,7 @@ cogl_wrap_glEnableClientState (GLenum array)
} }
void void
cogl_wrap_glDisableClientState (GLenum array) _cogl_wrap_glDisableClientState (GLenum array)
{ {
CoglGles2WrapperTextureUnit *texture_unit; CoglGles2WrapperTextureUnit *texture_unit;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1543,7 +1544,7 @@ cogl_wrap_glDisableClientState (GLenum array)
} }
void void
cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref) _cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref)
{ {
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1557,26 +1558,26 @@ cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref)
} }
void void
cogl_wrap_glColor4f (GLclampf r, GLclampf g, GLclampf b, GLclampf a) _cogl_wrap_glColor4f (GLclampf r, GLclampf g, GLclampf b, GLclampf a)
{ {
glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB, r, g, b, a); glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB, r, g, b, a);
} }
void void
cogl_wrap_glColor4ub (GLubyte r, GLubyte g, GLubyte b, GLubyte a) _cogl_wrap_glColor4ub (GLubyte r, GLubyte g, GLubyte b, GLubyte a)
{ {
glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB, glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB,
r/255.0, g/255.0, b/255.0, a/255.0); r/255.0, g/255.0, b/255.0, a/255.0);
} }
void void
cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation) _cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation)
{ {
/* FIXME */ /* FIXME */
} }
void void
cogl_wrap_glGetIntegerv (GLenum pname, GLint *params) _cogl_wrap_glGetIntegerv (GLenum pname, GLint *params)
{ {
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1603,7 +1604,7 @@ cogl_wrap_glGetIntegerv (GLenum pname, GLint *params)
} }
void void
cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params) _cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params)
{ {
CoglGles2WrapperTextureUnit *texture_unit; CoglGles2WrapperTextureUnit *texture_unit;
@ -1631,7 +1632,7 @@ cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params)
} }
void void
cogl_wrap_glFogf (GLenum pname, GLfloat param) _cogl_wrap_glFogf (GLenum pname, GLfloat param)
{ {
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1659,7 +1660,7 @@ cogl_wrap_glFogf (GLenum pname, GLfloat param)
} }
void void
cogl_wrap_glFogfv (GLenum pname, const GLfloat *params) _cogl_wrap_glFogfv (GLenum pname, const GLfloat *params)
{ {
int i; int i;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1674,14 +1675,14 @@ cogl_wrap_glFogfv (GLenum pname, const GLfloat *params)
} }
void void
cogl_wrap_glTexParameteri (GLenum target, GLenum pname, GLfloat param) _cogl_wrap_glTexParameteri (GLenum target, GLenum pname, GLfloat param)
{ {
if (pname != GL_GENERATE_MIPMAP) if (pname != GL_GENERATE_MIPMAP)
glTexParameteri (target, pname, param); glTexParameteri (target, pname, param);
} }
void void
cogl_wrap_glMaterialfv (GLenum face, GLenum pname, const GLfloat *params) _cogl_wrap_glMaterialfv (GLenum face, GLenum pname, const GLfloat *params)
{ {
/* FIXME: the GLES 2 backend doesn't yet support lighting so this /* FIXME: the GLES 2 backend doesn't yet support lighting so this
function can't do anything */ function can't do anything */

166
cogl/driver/gles/cogl-gles2-wrapper.h
View File

@ -317,115 +317,115 @@ struct _CoglGles2WrapperShader
#endif /* GL_MODELVIEW */ #endif /* GL_MODELVIEW */
void cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper); void _cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper);
void cogl_gles2_wrapper_deinit (CoglGles2Wrapper *wrapper); void _cogl_gles2_wrapper_deinit (CoglGles2Wrapper *wrapper);
void cogl_wrap_glPushMatrix (); void _cogl_wrap_glPushMatrix ();
void cogl_wrap_glPopMatrix (); void _cogl_wrap_glPopMatrix ();
void cogl_wrap_glMatrixMode (GLenum mode); void _cogl_wrap_glMatrixMode (GLenum mode);
void cogl_wrap_glLoadIdentity (); void _cogl_wrap_glLoadIdentity ();
void cogl_wrap_glMultMatrixf (const GLfloat *m); void _cogl_wrap_glMultMatrixf (const GLfloat *m);
void cogl_wrap_glLoadMatrixf (const GLfloat *m); void _cogl_wrap_glLoadMatrixf (const GLfloat *m);
void cogl_wrap_glFrustumf (GLfloat left, GLfloat right, void _cogl_wrap_glFrustumf (GLfloat left, GLfloat right,
GLfloat bottom, GLfloat top, GLfloat bottom, GLfloat top,
GLfloat z_near, GLfloat z_far); GLfloat z_near, GLfloat z_far);
void cogl_wrap_glScalef (GLfloat x, GLfloat y, GLfloat z); void _cogl_wrap_glScalef (GLfloat x, GLfloat y, GLfloat z);
void cogl_wrap_glTranslatef (GLfloat x, GLfloat y, GLfloat z); void _cogl_wrap_glTranslatef (GLfloat x, GLfloat y, GLfloat z);
void cogl_wrap_glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); void _cogl_wrap_glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
void cogl_wrap_glOrthof (GLfloat left, GLfloat right, void _cogl_wrap_glOrthof (GLfloat left, GLfloat right,
GLfloat bottom, GLfloat top, GLfloat bottom, GLfloat top,
GLfloat near, GLfloat far); GLfloat near, GLfloat far);
void cogl_wrap_glEnable (GLenum cap); void _cogl_wrap_glEnable (GLenum cap);
void cogl_wrap_glDisable (GLenum cap); void _cogl_wrap_glDisable (GLenum cap);
void cogl_wrap_glTexCoordPointer (GLint size, GLenum type, GLsizei stride, void _cogl_wrap_glTexCoordPointer (GLint size, GLenum type, GLsizei stride,
const GLvoid *pointer); const GLvoid *pointer);
void cogl_wrap_glVertexPointer (GLint size, GLenum type, GLsizei stride, void _cogl_wrap_glVertexPointer (GLint size, GLenum type, GLsizei stride,
const GLvoid *pointer); const GLvoid *pointer);
void cogl_wrap_glColorPointer (GLint size, GLenum type, GLsizei stride, void _cogl_wrap_glColorPointer (GLint size, GLenum type, GLsizei stride,
const GLvoid *pointer); const GLvoid *pointer);
void cogl_wrap_glNormalPointer (GLenum type, GLsizei stride, void _cogl_wrap_glNormalPointer (GLenum type, GLsizei stride,
const GLvoid *pointer); const GLvoid *pointer);
void cogl_wrap_glTexEnvi (GLenum target, GLenum pname, GLint param); void _cogl_wrap_glTexEnvi (GLenum target, GLenum pname, GLint param);
void cogl_wrap_glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params); void _cogl_wrap_glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params);
void cogl_wrap_glClientActiveTexture (GLenum texture); void _cogl_wrap_glClientActiveTexture (GLenum texture);
void cogl_wrap_glActiveTexture (GLenum texture); void _cogl_wrap_glActiveTexture (GLenum texture);
void cogl_wrap_glEnableClientState (GLenum array); void _cogl_wrap_glEnableClientState (GLenum array);
void cogl_wrap_glDisableClientState (GLenum array); void _cogl_wrap_glDisableClientState (GLenum array);
void cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref); void _cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref);
void cogl_wrap_glColor4f (GLclampf r, GLclampf g, GLclampf b, GLclampf a); void _cogl_wrap_glColor4f (GLclampf r, GLclampf g, GLclampf b, GLclampf a);
void cogl_wrap_glColor4ub (GLubyte r, GLubyte g, GLubyte b, GLubyte a); void _cogl_wrap_glColor4ub (GLubyte r, GLubyte g, GLubyte b, GLubyte a);
void cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation); void _cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation);
void cogl_wrap_glGetIntegerv (GLenum pname, GLint *params); void _cogl_wrap_glGetIntegerv (GLenum pname, GLint *params);
void cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params); void _cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params);
void cogl_wrap_glFogf (GLenum pname, GLfloat param); void _cogl_wrap_glFogf (GLenum pname, GLfloat param);
void cogl_wrap_glFogfv (GLenum pname, const GLfloat *params); void _cogl_wrap_glFogfv (GLenum pname, const GLfloat *params);
void cogl_wrap_glDrawArrays (GLenum mode, GLint first, GLsizei count); void _cogl_wrap_glDrawArrays (GLenum mode, GLint first, GLsizei count);
void cogl_wrap_glDrawElements (GLenum mode, GLsizei count, GLenum type, void _cogl_wrap_glDrawElements (GLenum mode, GLsizei count, GLenum type,
const GLvoid *indices); const GLvoid *indices);
void cogl_wrap_glTexParameteri (GLenum target, GLenum pname, GLfloat param); void _cogl_wrap_glTexParameteri (GLenum target, GLenum pname, GLfloat param);
void cogl_wrap_glMaterialfv (GLenum face, GLenum pname, const GLfloat *params); void _cogl_wrap_glMaterialfv (GLenum face, GLenum pname, const GLfloat *params);
/* This function is only available on GLES 2 */ /* This function is only available on GLES 2 */
#define cogl_wrap_glGenerateMipmap glGenerateMipmap #define _cogl_wrap_glGenerateMipmap glGenerateMipmap
void _cogl_gles2_clear_cache_for_program (CoglHandle program); void _cogl_gles2_clear_cache_for_program (CoglHandle program);
/* Remap the missing GL functions to use the wrappers */ /* Remap the missing GL functions to use the wrappers */
#ifndef COGL_GLES2_WRAPPER_NO_REMAP #ifndef COGL_GLES2_WRAPPER_NO_REMAP
#define glDrawArrays cogl_wrap_glDrawArrays #define glDrawArrays _cogl_wrap_glDrawArrays
#define glDrawElements cogl_wrap_glDrawElements #define glDrawElements _cogl_wrap_glDrawElements
#define glPushMatrix cogl_wrap_glPushMatrix #define glPushMatrix _cogl_wrap_glPushMatrix
#define glPopMatrix cogl_wrap_glPopMatrix #define glPopMatrix _cogl_wrap_glPopMatrix
#define glMatrixMode cogl_wrap_glMatrixMode #define glMatrixMode _cogl_wrap_glMatrixMode
#define glLoadIdentity cogl_wrap_glLoadIdentity #define glLoadIdentity _cogl_wrap_glLoadIdentity
#define glMultMatrixf cogl_wrap_glMultMatrixf #define glMultMatrixf _cogl_wrap_glMultMatrixf
#define glLoadMatrixf cogl_wrap_glLoadMatrixf #define glLoadMatrixf _cogl_wrap_glLoadMatrixf
#define glFrustumf cogl_wrap_glFrustumf #define glFrustumf _cogl_wrap_glFrustumf
#define glScalef cogl_wrap_glScalef #define glScalef _cogl_wrap_glScalef
#define glTranslatef cogl_wrap_glTranslatef #define glTranslatef _cogl_wrap_glTranslatef
#define glRotatef cogl_wrap_glRotatef #define glRotatef _cogl_wrap_glRotatef
#define glOrthof cogl_wrap_glOrthof #define glOrthof _cogl_wrap_glOrthof
#define glEnable cogl_wrap_glEnable #define glEnable _cogl_wrap_glEnable
#define glDisable cogl_wrap_glDisable #define glDisable _cogl_wrap_glDisable
#define glTexCoordPointer cogl_wrap_glTexCoordPointer #define glTexCoordPointer _cogl_wrap_glTexCoordPointer
#define glVertexPointer cogl_wrap_glVertexPointer #define glVertexPointer _cogl_wrap_glVertexPointer
#define glColorPointer cogl_wrap_glColorPointer #define glColorPointer _cogl_wrap_glColorPointer
#define glNormalPointer cogl_wrap_glNormalPointer #define glNormalPointer _cogl_wrap_glNormalPointer
#define glTexEnvi cogl_wrap_glTexEnvi #define glTexEnvi _cogl_wrap_glTexEnvi
#define glTexEnvfv cogl_wrap_glTexEnvfv #define glTexEnvfv _cogl_wrap_glTexEnvfv
#define glActiveTexture cogl_wrap_glActiveTexture #define glActiveTexture _cogl_wrap_glActiveTexture
#define glClientActiveTexture cogl_wrap_glClientActiveTexture #define glClientActiveTexture _cogl_wrap_glClientActiveTexture
#define glEnableClientState cogl_wrap_glEnableClientState #define glEnableClientState _cogl_wrap_glEnableClientState
#define glDisableClientState cogl_wrap_glDisableClientState #define glDisableClientState _cogl_wrap_glDisableClientState
#define glAlphaFunc cogl_wrap_glAlphaFunc #define glAlphaFunc _cogl_wrap_glAlphaFunc
#define glColor4f cogl_wrap_glColor4f #define glColor4f _cogl_wrap_glColor4f
#define glColor4ub cogl_wrap_glColor4ub #define glColor4ub _cogl_wrap_glColor4ub
#define glClipPlanef cogl_wrap_glClipPlanef #define glClipPlanef _cogl_wrap_glClipPlanef
#define glGetIntegerv cogl_wrap_glGetIntegerv #define glGetIntegerv _cogl_wrap_glGetIntegerv
#define glGetFloatv cogl_wrap_glGetFloatv #define glGetFloatv _cogl_wrap_glGetFloatv
#define glFogf cogl_wrap_glFogf #define glFogf _cogl_wrap_glFogf
#define glFogfv cogl_wrap_glFogfv #define glFogfv _cogl_wrap_glFogfv
#define glTexParameteri cogl_wrap_glTexParameteri #define glTexParameteri _cogl_wrap_glTexParameteri
#define glMaterialfv cogl_wrap_glMaterialfv #define glMaterialfv _cogl_wrap_glMaterialfv
#endif /* COGL_GLES2_WRAPPER_NO_REMAP */ #endif /* COGL_GLES2_WRAPPER_NO_REMAP */
#else /* HAVE_COGL_GLES2 */ #else /* HAVE_COGL_GLES2 */
/* COGL uses the automatic mipmap generation for GLES 1 so /* COGL uses the automatic mipmap generation for GLES 1 so
glGenerateMipmap doesn't need to do anything */ glGenerateMipmap doesn't need to do anything */
#define cogl_wrap_glGenerateMipmap(x) ((void) 0) #define _cogl_wrap_glGenerateMipmap(x) ((void) 0)
/* GLES doesn't have glDrawRangeElements, so we simply pretend it does /* GLES doesn't have glDrawRangeElements, so we simply pretend it does
* but that it makes no use of the start, end constraints: */ * but that it makes no use of the start, end constraints: */

2
cogl/driver/gles/cogl-texture-driver.c
View File

@ -325,7 +325,7 @@ _cogl_texture_driver_allows_foreign_gl_target (GLenum gl_target)
void void
_cogl_texture_driver_gl_generate_mipmaps (GLenum gl_target) _cogl_texture_driver_gl_generate_mipmaps (GLenum gl_target)
{ {
GE( cogl_wrap_glGenerateMipmap (gl_target) ); GE( _cogl_wrap_glGenerateMipmap (gl_target) );
} }
CoglPixelFormat CoglPixelFormat