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

* clutter/cogl/gles/cogl-gles2-wrapper.h:

Browse Source 
* clutter/cogl/gles/cogl-gles2-wrapper.c: All of the settings and
	uniforms are now proxied into COGL variables instead of setting
	the GL uniforms directly. Just before glDrawArrays is executed a
	shader is generated using the given settings to avoid using 'if'
	statements. The shaders are cached.

	* clutter/cogl/gles/cogl-fixed-vertex-shader.glsl: 
	* clutter/cogl/gles/cogl-fixed-fragment-shader.glsl: The shaders
	are now split into parts using comments instead of 'if' statements
	so that the simplest shader can be generated on the fly.

	* clutter/cogl/gles/stringify.sh: Now splits up the shader sources
	into separate C strings where deliminated by special comments.

	* clutter/cogl/gles/cogl-program.h: 
	* clutter/cogl/gles/cogl-program.c: A custom shader can no longer
	be directly linked with the fixed-functionality replacement
	because the replacement changes depending on the settings. Instead
	the bound shader is linked with the appropriate replacement shader
	just before glDrawArrays is executed. The custom uniform variables
	must also be proxied through COGL variables because their location
	can change when relinked.
This commit is contained in:
Neil Roberts 2008-06-24 16:21:40 +00:00
parent eac5e21f1c
commit d4da3a3e2a
8 changed files with 744 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
ChangeLog
View File

@ -1,3 +1,29 @@
2008-06-24 Neil Roberts <neil@o-hand.com>
* clutter/cogl/gles/cogl-gles2-wrapper.h:
* clutter/cogl/gles/cogl-gles2-wrapper.c: All of the settings and
uniforms are now proxied into COGL variables instead of setting
the GL uniforms directly. Just before glDrawArrays is executed a
shader is generated using the given settings to avoid using 'if'
statements. The shaders are cached.
* clutter/cogl/gles/cogl-fixed-vertex-shader.glsl:
* clutter/cogl/gles/cogl-fixed-fragment-shader.glsl: The shaders
are now split into parts using comments instead of 'if' statements
so that the simplest shader can be generated on the fly.
* clutter/cogl/gles/stringify.sh: Now splits up the shader sources
into separate C strings where deliminated by special comments.
* clutter/cogl/gles/cogl-program.h:
* clutter/cogl/gles/cogl-program.c: A custom shader can no longer
be directly linked with the fixed-functionality replacement
because the replacement changes depending on the settings. Instead
the bound shader is linked with the appropriate replacement shader
just before glDrawArrays is executed. The custom uniform variables
must also be proxied through COGL variables because their location
can change when relinked.
2008-06-24 Øyvind Kolås <pippin@o-hand.com>
* clutter/fruity/clutter-fruity.c: removed dead code and unused

116
clutter/cogl/gles/cogl-fixed-fragment-shader.glsl
View File

@ -1,3 +1,5 @@
/*** cogl_fixed_fragment_shader_start ***/
/* There is no default precision for floats in fragment shaders in
GLES 2 so we need to define one */
precision mediump float;
@ -8,86 +10,64 @@ varying vec2 tex_coord;
varying float fog_amount;
/* Texturing options */
uniform bool texture_2d_enabled;
uniform sampler2D texture_unit;
uniform bool alpha_only;
/* Fogging options */
uniform bool fog_enabled;
uniform vec4 fog_color;
/* Alpha test options */
uniform bool alpha_test_enabled;
uniform int alpha_test_func;
uniform float alpha_test_ref;
/* Alpha test functions */
const int GL_NEVER = 0x0200;
const int GL_LESS = 0x0201;
const int GL_EQUAL = 0x0202;
const int GL_LEQUAL = 0x0203;
const int GL_GREATER = 0x0204;
const int GL_NOTEQUAL = 0x0205;
const int GL_GEQUAL = 0x0206;
void
main (void)
{
if (texture_2d_enabled)
{
if (alpha_only)
{
/* If the texture only has an alpha channel (eg, with the
textures from the pango renderer) then the RGB components
will be black. We want to use the RGB from the current
color in that case */
gl_FragColor = frag_color;
gl_FragColor.a *= texture2D (texture_unit, tex_coord).a;
}
else
gl_FragColor = frag_color * texture2D (texture_unit, tex_coord);
}
else
gl_FragColor = frag_color;
/*** cogl_fixed_fragment_shader_texture_alpha_only ***/
if (fog_enabled)
/* Mix the calculated color with the fog color */
gl_FragColor.rgb = mix (fog_color.rgb, gl_FragColor.rgb, fog_amount);
/* If the texture only has an alpha channel (eg, with the textures
from the pango renderer) then the RGB components will be
black. We want to use the RGB from the current color in that
case */
gl_FragColor = frag_color;
gl_FragColor.a *= texture2D (texture_unit, tex_coord).a;
/*** cogl_fixed_fragment_shader_texture ***/
/* This pointless extra variable is needed to work around an
apparent bug in the PowerVR drivers. Without it the alpha
blending seems to stop working */
vec4 frag_color_copy = frag_color;
gl_FragColor = frag_color_copy * texture2D (texture_unit, tex_coord);
/*** cogl_fixed_fragment_shader_solid_color ***/
gl_FragColor = frag_color;
/*** cogl_fixed_fragment_shader_fog ***/
/* Mix the calculated color with the fog color */
gl_FragColor.rgb = mix (fog_color.rgb, gl_FragColor.rgb, fog_amount);
/* Alpha testing */
if (alpha_test_enabled)
{
if (alpha_test_func == GL_NEVER)
discard;
else if (alpha_test_func == GL_LESS)
{
if (gl_FragColor.a >= alpha_test_ref)
discard;
}
else if (alpha_test_func == GL_EQUAL)
{
if (gl_FragColor.a != alpha_test_ref)
discard;
}
else if (alpha_test_func == GL_LEQUAL)
{
if (gl_FragColor.a > alpha_test_ref)
discard;
}
else if (alpha_test_func == GL_GREATER)
{
if (gl_FragColor.a <= alpha_test_ref)
discard;
}
else if (alpha_test_func == GL_NOTEQUAL)
{
if (gl_FragColor.a == alpha_test_ref)
discard;
}
else if (alpha_test_func == GL_GEQUAL)
{
if (gl_FragColor.a < alpha_test_ref)
discard;
}
}
/*** cogl_fixed_fragment_shader_alpha_never ***/
discard;
/*** cogl_fixed_fragment_shader_alpha_less ***/
if (gl_FragColor.a >= alpha_test_ref)
discard;
/*** cogl_fixed_fragment_shader_alpha_equal ***/
if (gl_FragColor.a != alpha_test_ref)
discard;
/*** cogl_fixed_fragment_shader_alpha_lequal ***/
if (gl_FragColor.a > alpha_test_ref)
discard;
/*** cogl_fixed_fragment_shader_alpha_greater ***/
if (gl_FragColor.a <= alpha_test_ref)
discard;
/*** cogl_fixed_fragment_shader_alpha_notequal ***/
if (gl_FragColor.a == alpha_test_ref)
discard;
/*** cogl_fixed_fragment_shader_alpha_gequal ***/
if (gl_FragColor.a < alpha_test_ref)
discard;
/*** cogl_fixed_fragment_shader_end ***/
}

46
clutter/cogl/gles/cogl-fixed-vertex-shader.glsl
View File

@ -1,3 +1,5 @@
/*** cogl_fixed_vertex_shader_start ***/
/* Per vertex attributes */
attribute vec4 vertex_attrib;
attribute vec4 tex_coord_attrib;
@ -14,17 +16,10 @@ varying vec2 tex_coord;
varying float fog_amount;
/* Fogging options */
uniform bool fog_enabled;
uniform int fog_mode;
uniform float fog_density;
uniform float fog_start;
uniform float fog_end;
/* Fogging modes */
const int GL_LINEAR = 0x2601;
const int GL_EXP = 0x0800;
const int GL_EXP2 = 0x0801;
void
main (void)
{
@ -38,23 +33,26 @@ main (void)
/* Pass the interpolated vertex color on to the fragment shader */
frag_color = color_attrib;
if (fog_enabled)
{
/* Estimate the distance from the eye using just the
z-coordinate to use as the fog coord */
vec4 eye_coord = modelview_matrix * vertex_attrib;
float fog_coord = abs (eye_coord.z / eye_coord.w);
/*** cogl_fixed_vertex_shader_fog_start ***/
/* Calculate the fog amount per-vertex and interpolate it for
the fragment shader */
if (fog_mode == GL_EXP)
fog_amount = exp (-fog_density * fog_coord);
else if (fog_mode == GL_EXP2)
fog_amount = exp (-fog_density * fog_coord
* fog_density * fog_coord);
else
fog_amount = (fog_end - fog_coord) / (fog_end - fog_start);
/* Estimate the distance from the eye using just the z-coordinate to
use as the fog coord */
vec4 eye_coord = modelview_matrix * vertex_attrib;
float fog_coord = abs (eye_coord.z / eye_coord.w);
fog_amount = clamp (fog_amount, 0.0, 1.0);
}
/* Calculate the fog amount per-vertex and interpolate it for the
fragment shader */
/*** cogl_fixed_vertex_shader_fog_exp ***/
fog_amount = exp (-fog_density * fog_coord);
/*** cogl_fixed_vertex_shader_fog_exp2 ***/
fog_amount = exp (-fog_density * fog_coord
* fog_density * fog_coord);
/*** cogl_fixed_vertex_shader_fog_linear ***/
fog_amount = (fog_end - fog_coord) / (fog_end - fog_start);
/*** cogl_fixed_vertex_shader_fog_end ***/
fog_amount = clamp (fog_amount, 0.0, 1.0);
/*** cogl_fixed_vertex_shader_end ***/
}

596
clutter/cogl/gles/cogl-gles2-wrapper.c
View File

@ -36,6 +36,8 @@
#include "cogl-fixed-vertex-shader.h"
#include "cogl-fixed-fragment-shader.h"
#include "cogl-context.h"
#include "cogl-shader.h"
#include "cogl-program.h"
#define _COGL_GET_GLES2_WRAPPER(wvar, retval) \
CoglGles2Wrapper *wvar; \
@ -45,6 +47,24 @@
wvar = &__ctxvar->gles2; \
}
#define _COGL_GLES2_CHANGE_SETTING(w, var, val) \
do \
if ((w)->settings.var != (val)) \
{ \
(w)->settings.var = (val); \
(w)->settings_dirty = TRUE; \
} \
while (0)
#define _COGL_GLES2_CHANGE_UNIFORM(w, flag, var, val) \
do \
if ((w)->var != (val)) \
{ \
(w)->var = (val); \
(w)->dirty_uniforms |= COGL_GLES2_DIRTY_ ## flag; \
} \
while (0)
#define COGL_GLES2_WRAPPER_VERTEX_ATTRIB 0
#define COGL_GLES2_WRAPPER_TEX_COORD_ATTRIB 1
#define COGL_GLES2_WRAPPER_COLOR_ATTRIB 2
@ -83,62 +103,10 @@ cogl_gles2_wrapper_create_shader (GLenum type, const char *source)
void
cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper)
{
GLint status;
GLfixed default_fog_color[4] = { 0, 0, 0, 0 };
memset (wrapper, 0, sizeof (CoglGles2Wrapper));
/* Create the shader program */
wrapper->vertex_shader
= cogl_gles2_wrapper_create_shader (GL_VERTEX_SHADER,
cogl_fixed_vertex_shader);
if (wrapper->vertex_shader == 0)
return;
wrapper->fragment_shader
= cogl_gles2_wrapper_create_shader (GL_FRAGMENT_SHADER,
cogl_fixed_fragment_shader);
if (wrapper->fragment_shader == 0)
{
glDeleteShader (wrapper->vertex_shader);
return;
}
wrapper->program = glCreateProgram ();
glAttachShader (wrapper->program, wrapper->fragment_shader);
glAttachShader (wrapper->program, wrapper->vertex_shader);
cogl_gles2_wrapper_bind_attributes (wrapper->program);
glLinkProgram (wrapper->program);
glGetProgramiv (wrapper->program, GL_LINK_STATUS, &status);
if (!status)
{
char log[1024];
GLint len;
glGetProgramInfoLog (wrapper->program, sizeof (log) - 1, &len, log);
log[len] = '\0';
g_critical ("%s", log);
glDeleteProgram (wrapper->program);
glDeleteShader (wrapper->vertex_shader);
glDeleteShader (wrapper->fragment_shader);
return;
}
glUseProgram (wrapper->program);
wrapper->uniforms = &wrapper->fixed_uniforms;
cogl_gles2_wrapper_get_uniforms (wrapper->program, wrapper->uniforms);
/* Always use the first texture unit */
glUniform1i (wrapper->uniforms->bound_texture_uniform, 0);
/* Initialize the stacks */
cogl_wrap_glMatrixMode (GL_TEXTURE);
cogl_wrap_glLoadIdentity ();
@ -147,8 +115,6 @@ cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper)
cogl_wrap_glMatrixMode (GL_MODELVIEW);
cogl_wrap_glLoadIdentity ();
wrapper->mvp_uptodate = GL_FALSE;
/* Initialize the fogging options */
cogl_wrap_glDisable (GL_FOG);
cogl_wrap_glFogx (GL_FOG_MODE, GL_LINEAR);
@ -162,6 +128,293 @@ cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper)
cogl_wrap_glAlphaFunc (GL_ALWAYS, 0.0f);
}
static gboolean
cogl_gles2_settings_equal (const CoglGles2WrapperSettings *a,
const CoglGles2WrapperSettings *b,
gboolean vertex_tests,
gboolean fragment_tests)
{
if (fragment_tests)
{
if (a->texture_2d_enabled != b->texture_2d_enabled)
return FALSE;
if (a->texture_2d_enabled && a->alpha_only != b->alpha_only)
return FALSE;
if (a->alpha_test_enabled != b->alpha_test_enabled)
return FALSE;
if (a->alpha_test_enabled && a->alpha_test_func != b->alpha_test_func)
return FALSE;
}
if (a->fog_enabled != b->fog_enabled)
return FALSE;
if (vertex_tests && a->fog_enabled && a->fog_mode != b->fog_mode)
return FALSE;
return TRUE;
}
static CoglGles2WrapperShader *
cogl_gles2_get_vertex_shader (const CoglGles2WrapperSettings *settings)
{
GString *shader_source;
GLuint shader_obj;
CoglGles2WrapperShader *shader;
GSList *node;
_COGL_GET_GLES2_WRAPPER (w, NULL);
/* Check if we already have a vertex shader for these settings */
for (node = w->compiled_vertex_shaders; node; node = node->next)
if (cogl_gles2_settings_equal (settings,
&((CoglGles2WrapperShader *)
node->data)->settings,
TRUE, FALSE))
return (CoglGles2WrapperShader *) node->data;
/* Otherwise create a new shader */
shader_source = g_string_new (cogl_fixed_vertex_shader_start);
if (settings->fog_enabled)
{
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_start);
switch (settings->fog_mode)
{
case GL_EXP:
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_exp);
break;
case GL_EXP2:
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_exp2);
break;
default:
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_linear);
break;
}
g_string_append (shader_source, cogl_fixed_vertex_shader_fog_end);
}
g_string_append (shader_source, cogl_fixed_vertex_shader_end);
shader_obj = cogl_gles2_wrapper_create_shader (GL_VERTEX_SHADER,
shader_source->str);
g_string_free (shader_source, TRUE);
if (shader_obj == 0)
return NULL;
shader = g_slice_new (CoglGles2WrapperShader);
shader->shader = shader_obj;
shader->settings = *settings;
w->compiled_vertex_shaders = g_slist_prepend (w->compiled_vertex_shaders,
shader);
return shader;
}
static CoglGles2WrapperShader *
cogl_gles2_get_fragment_shader (const CoglGles2WrapperSettings *settings)
{
GString *shader_source;
GLuint shader_obj;
CoglGles2WrapperShader *shader;
GSList *node;
_COGL_GET_GLES2_WRAPPER (w, NULL);
/* Check if we already have a fragment shader for these settings */
for (node = w->compiled_fragment_shaders; node; node = node->next)
if (cogl_gles2_settings_equal (settings,
&((CoglGles2WrapperShader *)
node->data)->settings,
FALSE, TRUE))
return (CoglGles2WrapperShader *) node->data;
/* Otherwise create a new shader */
shader_source = g_string_new (cogl_fixed_fragment_shader_start);
if (settings->texture_2d_enabled)
{
if (settings->alpha_only)
g_string_append (shader_source,
cogl_fixed_fragment_shader_texture_alpha_only);
else
g_string_append (shader_source,
cogl_fixed_fragment_shader_texture);
}
else
g_string_append (shader_source, cogl_fixed_fragment_shader_solid_color);
if (settings->fog_enabled)
g_string_append (shader_source, cogl_fixed_fragment_shader_fog);
if (settings->alpha_test_enabled)
switch (settings->alpha_test_func)
{
case GL_NEVER:
g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_never);
break;
case GL_LESS:
g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_less);
break;
case GL_EQUAL:
g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_equal);
break;
case GL_LEQUAL:
g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_lequal);
break;
case GL_GREATER:
g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_greater);
break;
case GL_NOTEQUAL:
g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_notequal);
break;
case GL_GEQUAL:
g_string_append (shader_source,
cogl_fixed_fragment_shader_alpha_gequal);
}
g_string_append (shader_source, cogl_fixed_fragment_shader_end);
shader_obj = cogl_gles2_wrapper_create_shader (GL_FRAGMENT_SHADER,
shader_source->str);
g_string_free (shader_source, TRUE);
if (shader_obj == 0)
return NULL;
shader = g_slice_new (CoglGles2WrapperShader);
shader->shader = shader_obj;
shader->settings = *settings;
w->compiled_fragment_shaders = g_slist_prepend (w->compiled_fragment_shaders,
shader);
return shader;
}
static CoglGles2WrapperProgram *
cogl_gles2_wrapper_get_program (const CoglGles2WrapperSettings *settings)
{
GSList *node;
CoglGles2WrapperProgram *program;
CoglGles2WrapperShader *vertex_shader, *fragment_shader;
GLint status;
gboolean custom_vertex_shader = FALSE, custom_fragment_shader = FALSE;
CoglProgram *user_program = NULL;
int i;
_COGL_GET_GLES2_WRAPPER (w, NULL);
/* Check if we've already got a program for these settings */
for (node = w->compiled_programs; node; node = node->next)
{
program = (CoglGles2WrapperProgram *) node->data;
if (cogl_gles2_settings_equal (settings, &program->settings, TRUE, TRUE)
&& program->settings.user_program == settings->user_program)
return (CoglGles2WrapperProgram *) node->data;
}
/* Otherwise create a new program */
/* Check whether the currently used custom program has vertex and
fragment shaders */
if (w->settings.user_program != COGL_INVALID_HANDLE)
{
user_program
= _cogl_program_pointer_from_handle (w->settings.user_program);
for (node = user_program->attached_shaders; node; node = node->next)
{
CoglShader *shader
= _cogl_shader_pointer_from_handle ((CoglHandle) node->data);
if (shader->type == CGL_VERTEX_SHADER)
custom_vertex_shader = TRUE;
else if (shader->type == CGL_FRAGMENT_SHADER)
custom_fragment_shader = TRUE;
}
}
/* Get or create the fixed functionality shaders for these settings
if there is no custom replacement */
if (!custom_vertex_shader)
{
vertex_shader = cogl_gles2_get_vertex_shader (settings);
if (vertex_shader == NULL)
return NULL;
}
if (!custom_fragment_shader)
{
fragment_shader = cogl_gles2_get_fragment_shader (settings);
if (fragment_shader == NULL)
return NULL;
}
program = g_slice_new (CoglGles2WrapperProgram);
program->program = glCreateProgram ();
if (!custom_vertex_shader)
glAttachShader (program->program, vertex_shader->shader);
if (!custom_fragment_shader)
glAttachShader (program->program, fragment_shader->shader);
if (user_program)
for (node = user_program->attached_shaders; node; node = node->next)
{
CoglShader *shader
= _cogl_shader_pointer_from_handle ((CoglHandle) node->data);
glAttachShader (program->program, shader->gl_handle);
}
cogl_gles2_wrapper_bind_attributes (program->program);
glLinkProgram (program->program);
glGetProgramiv (program->program, GL_LINK_STATUS, &status);
if (!status)
{
char log[1024];
GLint len;
glGetProgramInfoLog (program->program, sizeof (log) - 1, &len, log);
log[len] = '\0';
g_critical ("%s", log);
glDeleteProgram (program->program);
g_slice_free (CoglGles2WrapperProgram, program);
return NULL;
}
program->settings = *settings;
cogl_gles2_wrapper_get_uniforms (program->program, &program->uniforms);
/* We haven't tried to get a location for any of the custom uniforms
yet */
for (i = 0; i < COGL_GLES2_NUM_CUSTOM_UNIFORMS; i++)
program->custom_uniforms[i] = COGL_GLES2_UNBOUND_CUSTOM_UNIFORM;
w->compiled_programs = g_slist_append (w->compiled_programs, program);
return program;
}
void
cogl_gles2_wrapper_bind_attributes (GLuint program)
{
@ -183,17 +436,9 @@ cogl_gles2_wrapper_get_uniforms (GLuint program,
= glGetUniformLocation (program, "modelview_matrix");
uniforms->texture_matrix_uniform
= glGetUniformLocation (program, "texture_matrix");
uniforms->texture_2d_enabled_uniform
= glGetUniformLocation (program, "texture_2d_enabled");
uniforms->bound_texture_uniform
= glGetUniformLocation (program, "texture_unit");
uniforms->alpha_only_uniform
= glGetUniformLocation (program, "alpha_only");
uniforms->fog_enabled_uniform
= glGetUniformLocation (program, "fog_enabled");
uniforms->fog_mode_uniform
= glGetUniformLocation (program, "fog_mode");
uniforms->fog_density_uniform
= glGetUniformLocation (program, "fog_density");
uniforms->fog_start_uniform
@ -203,10 +448,6 @@ cogl_gles2_wrapper_get_uniforms (GLuint program,
uniforms->fog_color_uniform
= glGetUniformLocation (program, "fog_color");
uniforms->alpha_test_enabled_uniform
= glGetUniformLocation (program, "alpha_test_enabled");
uniforms->alpha_test_func_uniform
= glGetUniformLocation (program, "alpha_test_func");
uniforms->alpha_test_ref_uniform
= glGetUniformLocation (program, "alpha_test_ref");
}
@ -214,42 +455,50 @@ cogl_gles2_wrapper_get_uniforms (GLuint program,
void
cogl_gles2_wrapper_deinit (CoglGles2Wrapper *wrapper)
{
if (wrapper->program)
GSList *node, *next;
for (node = wrapper->compiled_programs; node; node = next)
{
glDeleteProgram (wrapper->program);
wrapper->program = 0;
next = node->next;
glDeleteProgram (((CoglGles2WrapperProgram *) node->data)->program);
g_slist_free1 (node);
}
if (wrapper->vertex_shader)
wrapper->compiled_programs = NULL;
for (node = wrapper->compiled_vertex_shaders; node; node = next)
{
glDeleteShader (wrapper->vertex_shader);
wrapper->vertex_shader = 0;
next = node->next;
glDeleteShader (((CoglGles2WrapperShader *) node->data)->shader);
g_slist_free1 (node);
}
if (wrapper->fragment_shader)
wrapper->compiled_vertex_shaders = NULL;
for (node = wrapper->compiled_fragment_shaders; node; node = next)
{
glDeleteShader (wrapper->fragment_shader);
wrapper->fragment_shader = 0;
next = node->next;
glDeleteShader (((CoglGles2WrapperShader *) node->data)->shader);
g_slist_free1 (node);
}
wrapper->compiled_fragment_shaders = NULL;
}
void
cogl_gles2_wrapper_update_matrix (CoglGles2Wrapper *wrapper, GLenum matrix_num)
{
const float *matrix;
switch (matrix_num)
{
default:
case GL_MODELVIEW:
wrapper->dirty_uniforms |= COGL_GLES2_DIRTY_MVP_MATRIX
| COGL_GLES2_DIRTY_MODELVIEW_MATRIX;
break;
case GL_PROJECTION:
/* Queue a recalculation of the combined modelview and
projection matrix at the next draw */
wrapper->mvp_uptodate = GL_FALSE;
wrapper->dirty_uniforms |= COGL_GLES2_DIRTY_MVP_MATRIX;
break;
case GL_TEXTURE:
matrix = wrapper->texture_stack + wrapper->texture_stack_pos * 16;
glUniformMatrix4fv (wrapper->uniforms->texture_matrix_uniform,
1, GL_FALSE, matrix);
wrapper->dirty_uniforms |= COGL_GLES2_DIRTY_TEXTURE_MATRIX;
break;
}
}
@ -530,26 +779,105 @@ cogl_wrap_glColorPointer (GLint size, GLenum type, GLsizei stride,
void
cogl_wrap_glDrawArrays (GLenum mode, GLint first, GLsizei count)
{
CoglGles2WrapperProgram *program;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
/* Make sure the modelview+projection matrix is up to date */
if (!w->mvp_uptodate)
/* Check if we need to switch programs */
if (w->settings_dirty)
{
float mvp_matrix[16];
const float *modelview_matrix = w->modelview_stack
+ w->modelview_stack_pos * 16;
/* Find or create a program for the current settings */
program = cogl_gles2_wrapper_get_program (&w->settings);
cogl_gles2_wrapper_mult_matrix (mvp_matrix,
w->projection_stack
+ w->projection_stack_pos * 16,
modelview_matrix);
if (program == NULL)
/* Can't compile a shader so there is nothing we can do */
return;
glUniformMatrix4fv (w->uniforms->mvp_matrix_uniform, 1,
GL_FALSE, mvp_matrix);
glUniformMatrix4fv (w->uniforms->modelview_matrix_uniform, 1, GL_FALSE,
modelview_matrix);
/* Start using it if we aren't already */
if (w->current_program != program)
{
glUseProgram (program->program);
w->current_program = program;
/* All of the uniforms are probably now out of date */
w->dirty_uniforms = COGL_GLES2_DIRTY_ALL;
w->dirty_custom_uniforms = (1 << COGL_GLES2_NUM_CUSTOM_UNIFORMS) - 1;
}
w->settings_dirty = FALSE;
}
else
program = w->current_program;
w->mvp_uptodate = GL_TRUE;
/* Make sure all of the uniforms are up to date */
if (w->dirty_uniforms)
{
if ((w->dirty_uniforms & (COGL_GLES2_DIRTY_MVP_MATRIX
| COGL_GLES2_DIRTY_MODELVIEW_MATRIX)))
{
float mvp_matrix[16];
const float *modelview_matrix = w->modelview_stack
+ w->modelview_stack_pos * 16;
cogl_gles2_wrapper_mult_matrix (mvp_matrix,
w->projection_stack
+ w->projection_stack_pos * 16,
modelview_matrix);
if (program->uniforms.mvp_matrix_uniform != -1)
glUniformMatrix4fv (program->uniforms.mvp_matrix_uniform, 1,
GL_FALSE, mvp_matrix);
if (program->uniforms.modelview_matrix_uniform != -1)
glUniformMatrix4fv (program->uniforms.modelview_matrix_uniform, 1,
GL_FALSE, modelview_matrix);
}
if ((w->dirty_uniforms & COGL_GLES2_DIRTY_TEXTURE_MATRIX)
&& program->uniforms.texture_matrix_uniform != -1)
glUniformMatrix4fv (program->uniforms.texture_matrix_uniform, 1,
GL_FALSE,
w->texture_stack + w->texture_stack_pos * 16);
if ((w->dirty_uniforms & COGL_GLES2_DIRTY_FOG_DENSITY)
&& program->uniforms.fog_density_uniform != -1)
glUniform1f (program->uniforms.fog_density_uniform, w->fog_density);
if ((w->dirty_uniforms & COGL_GLES2_DIRTY_FOG_START)
&& program->uniforms.fog_start_uniform != -1)
glUniform1f (program->uniforms.fog_start_uniform, w->fog_start);
if ((w->dirty_uniforms & COGL_GLES2_DIRTY_FOG_END)
&& program->uniforms.fog_end_uniform != -1)
glUniform1f (program->uniforms.fog_end_uniform, w->fog_end);
if ((w->dirty_uniforms & COGL_GLES2_DIRTY_ALPHA_TEST_REF)
&& program->uniforms.alpha_test_ref_uniform != -1)
glUniform1f (program->uniforms.alpha_test_ref_uniform,
w->alpha_test_ref);
w->dirty_uniforms = 0;
}
if (w->dirty_custom_uniforms)
{
int i;
if (w->settings.user_program != COGL_INVALID_HANDLE)
{
CoglProgram *user_program
= _cogl_program_pointer_from_handle (w->settings.user_program);
const char *uniform_name;
for (i = 0; i < COGL_GLES2_NUM_CUSTOM_UNIFORMS; i++)
if ((w->dirty_custom_uniforms & (1 << i))
&& (uniform_name = user_program->custom_uniform_names[i]))
{
if (program->custom_uniforms[i]
== COGL_GLES2_UNBOUND_CUSTOM_UNIFORM)
program->custom_uniforms[i]
= glGetUniformLocation (program->program, uniform_name);
if (program->custom_uniforms[i] >= 0)
glUniform1f (program->custom_uniforms[i],
w->custom_uniforms[i]);
}
}
w->dirty_custom_uniforms = 0;
}
glDrawArrays (mode, first, count);
@ -566,8 +894,7 @@ cogl_gles2_wrapper_bind_texture (GLenum target, GLuint texture,
/* We need to keep track of whether the texture is alpha-only
because the emulation of GL_MODULATE needs to work differently in
that case */
glUniform1i (w->uniforms->alpha_only_uniform,
internal_format == GL_ALPHA ? GL_TRUE : GL_FALSE);
_COGL_GLES2_CHANGE_SETTING (w, alpha_only, internal_format == GL_ALPHA);
}
void
@ -586,15 +913,15 @@ cogl_wrap_glEnable (GLenum cap)
switch (cap)
{
case GL_TEXTURE_2D:
glUniform1i (w->uniforms->texture_2d_enabled_uniform, GL_TRUE);
_COGL_GLES2_CHANGE_SETTING (w, texture_2d_enabled, TRUE);
break;
case GL_FOG:
glUniform1i (w->uniforms->fog_enabled_uniform, GL_TRUE);
_COGL_GLES2_CHANGE_SETTING (w, fog_enabled, TRUE);
break;
case GL_ALPHA_TEST:
glUniform1i (w->uniforms->alpha_test_enabled_uniform, GL_TRUE);
_COGL_GLES2_CHANGE_SETTING (w, alpha_test_enabled, TRUE);
break;
default:
@ -610,15 +937,15 @@ cogl_wrap_glDisable (GLenum cap)
switch (cap)
{
case GL_TEXTURE_2D:
glUniform1i (w->uniforms->texture_2d_enabled_uniform, GL_FALSE);
_COGL_GLES2_CHANGE_SETTING (w, texture_2d_enabled, FALSE);
break;
case GL_FOG:
glUniform1i (w->uniforms->fog_enabled_uniform, GL_FALSE);
_COGL_GLES2_CHANGE_SETTING (w, fog_enabled, FALSE);
break;
case GL_ALPHA_TEST:
glUniform1i (w->uniforms->alpha_test_enabled_uniform, GL_FALSE);
_COGL_GLES2_CHANGE_SETTING (w, alpha_test_enabled, FALSE);
break;
default:
@ -670,8 +997,8 @@ cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref)
else if (ref > 1.0f)
ref = 1.0f;
glUniform1i (w->uniforms->alpha_test_func_uniform, func);
glUniform1f (w->uniforms->alpha_test_ref_uniform, ref);
_COGL_GLES2_CHANGE_SETTING (w, alpha_test_func, func);
_COGL_GLES2_CHANGE_UNIFORM (w, ALPHA_TEST_REF, alpha_test_ref, ref);
}
void
@ -753,22 +1080,22 @@ cogl_wrap_glFogx (GLenum pname, GLfixed param)
switch (pname)
{
case GL_FOG_MODE:
glUniform1i (w->uniforms->fog_mode_uniform, param);
_COGL_GLES2_CHANGE_SETTING (w, fog_mode, param);
break;
case GL_FOG_DENSITY:
glUniform1f (w->uniforms->fog_density_uniform,
CLUTTER_FIXED_TO_FLOAT (param));
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_DENSITY, fog_density,
CLUTTER_FIXED_TO_FLOAT (param));
break;
case GL_FOG_START:
glUniform1f (w->uniforms->fog_start_uniform,
CLUTTER_FIXED_TO_FLOAT (param));
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_START, fog_start,
CLUTTER_FIXED_TO_FLOAT (param));
break;
case GL_FOG_END:
glUniform1f (w->uniforms->fog_end_uniform,
CLUTTER_FIXED_TO_FLOAT (param));
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_END, fog_end,
CLUTTER_FIXED_TO_FLOAT (param));
break;
}
}
@ -776,14 +1103,15 @@ cogl_wrap_glFogx (GLenum pname, GLfixed param)
void
cogl_wrap_glFogxv (GLenum pname, const GLfixed *params)
{
int i;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
if (pname == GL_FOG_COLOR)
glUniform4f (w->uniforms->fog_color_uniform,
CLUTTER_FIXED_TO_FLOAT (params[0]),
CLUTTER_FIXED_TO_FLOAT (params[1]),
CLUTTER_FIXED_TO_FLOAT (params[2]),
CLUTTER_FIXED_TO_FLOAT (params[3]));
{
for (i = 0; i < 4; i++)
w->fog_color[i] = CLUTTER_FIXED_TO_FLOAT (params[i]);
w->dirty_uniforms |= COGL_GLES2_DIRTY_FOG_COLOR;
}
}
void
@ -792,3 +1120,33 @@ cogl_wrap_glTexParameteri (GLenum target, GLenum pname, GLfloat param)
if (pname != GL_GENERATE_MIPMAP)
glTexParameteri (target, pname, param);
}
void
_cogl_gles2_clear_cache_for_program (CoglHandle user_program)
{
GSList *node, *next, *last = NULL;
CoglGles2WrapperProgram *program;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
/* Remove any cached programs that link against this custom program */
for (node = w->compiled_programs; node; node = next)
{
next = node->next;
program = (CoglGles2WrapperProgram *) node->data;
if (program->settings.user_program == user_program)
{
glDeleteProgram (program->program);
if (last)
last->next = next;
else
w->compiled_programs = next;
g_slist_free1 (node);
}
else
last = node;
}
}

110
clutter/cogl/gles/cogl-gles2-wrapper.h
View File

@ -32,39 +32,64 @@ G_BEGIN_DECLS
typedef struct _CoglGles2Wrapper CoglGles2Wrapper;
typedef struct _CoglGles2WrapperUniforms CoglGles2WrapperUniforms;
typedef struct _CoglGles2WrapperSettings CoglGles2WrapperSettings;
typedef struct _CoglGles2WrapperProgram CoglGles2WrapperProgram;
typedef struct _CoglGles2WrapperShader CoglGles2WrapperShader;
#define COGL_GLES2_NUM_CUSTOM_UNIFORMS 16
#define COGL_GLES2_UNBOUND_CUSTOM_UNIFORM -2
/* Must be a power of two */
#define COGL_GLES2_MODELVIEW_STACK_SIZE 32
#define COGL_GLES2_PROJECTION_STACK_SIZE 2
#define COGL_GLES2_TEXTURE_STACK_SIZE 2
#define COGL_GLES2_MODELVIEW_STACK_SIZE 32
#define COGL_GLES2_PROJECTION_STACK_SIZE 2
#define COGL_GLES2_TEXTURE_STACK_SIZE 2
enum
{
COGL_GLES2_DIRTY_MVP_MATRIX = 1 << 0,
COGL_GLES2_DIRTY_MODELVIEW_MATRIX = 1 << 1,
COGL_GLES2_DIRTY_TEXTURE_MATRIX = 1 << 2,
COGL_GLES2_DIRTY_FOG_DENSITY = 1 << 3,
COGL_GLES2_DIRTY_FOG_START = 1 << 4,
COGL_GLES2_DIRTY_FOG_END = 1 << 5,
COGL_GLES2_DIRTY_FOG_COLOR = 1 << 6,
COGL_GLES2_DIRTY_ALPHA_TEST_REF = 1 << 7,
COGL_GLES2_DIRTY_ALL = (1 << 8) - 1
};
struct _CoglGles2WrapperUniforms
{
GLint mvp_matrix_uniform;
GLint modelview_matrix_uniform;
GLint texture_matrix_uniform;
GLint texture_2d_enabled_uniform;
GLint bound_texture_uniform;
GLint alpha_only_uniform;
GLint fog_enabled_uniform;
GLint fog_mode_uniform;
GLint fog_density_uniform;
GLint fog_start_uniform;
GLint fog_end_uniform;
GLint fog_color_uniform;
GLint alpha_test_enabled_uniform;
GLint alpha_test_func_uniform;
GLint alpha_test_ref_uniform;
};
struct _CoglGles2WrapperSettings
{
gboolean texture_2d_enabled;
gboolean alpha_only;
gboolean alpha_test_enabled;
GLint alpha_test_func;
gboolean fog_enabled;
GLint fog_mode;
/* The current in-use user program */
CoglHandle user_program;
};
struct _CoglGles2Wrapper
{
GLuint program;
GLuint vertex_shader;
GLuint fragment_shader;
GLuint matrix_mode;
GLfloat modelview_stack[COGL_GLES2_MODELVIEW_STACK_SIZE * 16];
GLuint modelview_stack_pos;
@ -73,19 +98,61 @@ struct _CoglGles2Wrapper
GLfloat texture_stack[COGL_GLES2_TEXTURE_STACK_SIZE * 16];
GLuint texture_stack_pos;
/* The uniforms for the fixed-functionality emulation program */
CoglGles2WrapperUniforms fixed_uniforms;
/* The uniforms for the currently bound program */
CoglGles2WrapperUniforms *uniforms;
/* The combined modelview and projection matrix is only updated at
the last minute in glDrawArrays to avoid recalculating it for
every change to the modelview matrix */
GLboolean mvp_uptodate;
/* The currently bound program */
CoglGles2WrapperProgram *current_program;
/* The current settings */
CoglGles2WrapperSettings settings;
/* Whether the settings have changed since the last draw */
gboolean settings_dirty;
/* Uniforms that have changed since the last draw */
int dirty_uniforms, dirty_custom_uniforms;
/* List of all compiled program combinations */
GSList *compiled_programs;
/* List of all compiled vertex shaders */
GSList *compiled_vertex_shaders;
/* List of all compiled fragment shaders */
GSList *compiled_fragment_shaders;
/* Values for the uniforms */
GLfloat alpha_test_ref;
GLfloat fog_density;
GLfloat fog_start;
GLfloat fog_end;
GLfloat fog_color[4];
GLfloat custom_uniforms[COGL_GLES2_NUM_CUSTOM_UNIFORMS];
};
struct _CoglGles2WrapperProgram
{
GLuint program;
/* The settings that were used to generate this combination */
CoglGles2WrapperSettings settings;
/* The uniforms for this program */
CoglGles2WrapperUniforms uniforms;
GLint custom_uniforms[COGL_GLES2_NUM_CUSTOM_UNIFORMS];
};
struct _CoglGles2WrapperShader
{
GLuint shader;
/* The settings that were used to generate this shader */
CoglGles2WrapperSettings settings;
};
/* These defines are missing from GL ES 2 but we can still use them
with the wrapper funcions */
with the wrapper functions */
#ifndef GL_MODELVIEW
@ -122,6 +189,9 @@ struct _CoglGles2Wrapper
#define GL_TEXTURE_ENV_MODE 0x2200
#define GL_MODULATE 0x2100
#define GL_EXP 0x8000
#define GL_EXP2 0x8001
#endif /* GL_MODELVIEW */
void cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper);
@ -184,6 +254,8 @@ void cogl_gles2_wrapper_get_uniforms (GLuint program,
void cogl_gles2_wrapper_update_matrix (CoglGles2Wrapper *wrapper,
GLenum matrix_num);
void _cogl_gles2_clear_cache_for_program (CoglHandle program);
#else /* HAVE_COGL_GLES2 */
/* If we're not using GL ES 2 then just use the GL functions

152
clutter/cogl/gles/cogl-program.c
View File

@ -35,6 +35,8 @@
#ifdef HAVE_COGL_GLES2
#include <string.h>
#include "cogl-shader.h"
#include "cogl-program.h"
@ -45,26 +47,38 @@ COGL_HANDLE_DEFINE (Program, program, program_handles);
static void
_cogl_program_free (CoglProgram *program)
{
/* Frees program resources but its handle is not
released! Do that separately before this! */
int i;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
glDeleteProgram (program->gl_handle);
/* Unref all of the attached shaders */
g_slist_foreach (program->attached_shaders, (GFunc) cogl_shader_unref, NULL);
/* Destroy the list */
g_slist_free (program->attached_shaders);
_cogl_gles2_clear_cache_for_program ((CoglHandle) program);
if (ctx->gles2.settings.user_program == (CoglHandle) program)
{
ctx->gles2.settings.user_program = COGL_INVALID_HANDLE;
ctx->gles2.settings_dirty = TRUE;
}
for (i = 0; i < COGL_GLES2_NUM_CUSTOM_UNIFORMS; i++)
if (program->custom_uniform_names[i])
g_free (program->custom_uniform_names[i]);
}
CoglHandle
cogl_create_program (void)
{
CoglProgram *program;
_COGL_GET_CONTEXT (ctx, 0);
program = g_slice_new (CoglProgram);
program->ref_count = 1;
program->gl_handle = glCreateProgram ();
program->attached_vertex_shader = FALSE;
program->attached_fragment_shader = FALSE;
program->attached_fixed_vertex_shader = FALSE;
program->attached_fixed_fragment_shader = FALSE;
program->attached_shaders = NULL;
memset (program->custom_uniform_names, 0,
COGL_GLES2_NUM_CUSTOM_UNIFORMS * sizeof (char *));
COGL_HANDLE_DEBUG_NEW (program, program);
@ -76,7 +90,6 @@ cogl_program_attach_shader (CoglHandle program_handle,
CoglHandle shader_handle)
{
CoglProgram *program;
CoglShader *shader;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -84,110 +97,66 @@ cogl_program_attach_shader (CoglHandle program_handle,
return;
program = _cogl_program_pointer_from_handle (program_handle);
shader = _cogl_shader_pointer_from_handle (shader_handle);
program->attached_shaders
= g_slist_prepend (program->attached_shaders,
cogl_shader_ref (shader_handle));
if (shader->type == GL_VERTEX_SHADER)
{
if (program->attached_fixed_vertex_shader)
{
glDetachShader (program->gl_handle, ctx->gles2.vertex_shader);
program->attached_fixed_vertex_shader = FALSE;
}
program->attached_vertex_shader = TRUE;
}
else if (shader->type == GL_FRAGMENT_SHADER)
{
if (program->attached_fixed_fragment_shader)
{
glDetachShader (program->gl_handle, ctx->gles2.fragment_shader);
program->attached_fixed_fragment_shader = FALSE;
}
program->attached_fragment_shader = TRUE;
}
glAttachShader (program->gl_handle, shader->gl_handle);
/* Whenever the shader changes we will need to relink the program
with the fixed functionality shaders so we should forget the
cached programs */
_cogl_gles2_clear_cache_for_program (program);
}
void
cogl_program_link (CoglHandle handle)
{
CoglProgram *program;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
if (!cogl_is_program (handle))
return;
program = _cogl_program_pointer_from_handle (handle);
if (!program->attached_vertex_shader
&& !program->attached_fixed_vertex_shader)
{
glAttachShader (program->gl_handle, ctx->gles2.vertex_shader);
program->attached_fixed_vertex_shader = TRUE;
}
if (!program->attached_fragment_shader
&& !program->attached_fixed_fragment_shader)
{
glAttachShader (program->gl_handle, ctx->gles2.fragment_shader);
program->attached_fixed_fragment_shader = TRUE;
}
/* Set the attributes so that the wrapper functions will still work */
cogl_gles2_wrapper_bind_attributes (program->gl_handle);
glLinkProgram (program->gl_handle);
/* Retrieve the uniforms */
cogl_gles2_wrapper_get_uniforms (program->gl_handle,
&program->uniforms);
/* There's no point in linking the program here because it will have
to be relinked with a different fixed functionality shader
whenever the settings change */
}
void
cogl_program_use (CoglHandle handle)
{
CoglProgram *program;
GLuint gl_handle;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
if (handle != COGL_INVALID_HANDLE && !cogl_is_program (handle))
return;
if (handle == COGL_INVALID_HANDLE)
{
/* Go back to the fixed-functionality emulator program */
gl_handle = ctx->gles2.program;
ctx->gles2.uniforms = &ctx->gles2.fixed_uniforms;
}
else
{
program = _cogl_program_pointer_from_handle (handle);
gl_handle = program->gl_handle;
/* Use the uniforms in the program */
ctx->gles2.uniforms = &program->uniforms;
}
glUseProgram (gl_handle);
/* Update all of the matrix attributes */
cogl_gles2_wrapper_update_matrix (&ctx->gles2, GL_MODELVIEW);
cogl_gles2_wrapper_update_matrix (&ctx->gles2, GL_PROJECTION);
cogl_gles2_wrapper_update_matrix (&ctx->gles2, GL_TEXTURE);
ctx->gles2.settings.user_program = handle;
ctx->gles2.settings_dirty = TRUE;
}
COGLint
cogl_program_get_uniform_location (CoglHandle handle,
const gchar *uniform_name)
{
int i;
CoglProgram *program;
_COGL_GET_CONTEXT (ctx, 0);
if (!cogl_is_program (handle))
return 0;
return -1;
program = _cogl_program_pointer_from_handle (handle);
return glGetUniformLocation (program->gl_handle, uniform_name);
/* We can't just ask the GL program object for the uniform location
directly because it will change every time the program is linked
with a new fixed functionality shader. Instead we make our own
mapping of uniform numbers and cache the names */
for (i = 0; program->custom_uniform_names[i]
&& i < COGL_GLES2_NUM_CUSTOM_UNIFORMS; i++)
if (!strcmp (program->custom_uniform_names[i], uniform_name))
return i;
if (i < COGL_GLES2_NUM_CUSTOM_UNIFORMS)
{
program->custom_uniform_names[i] = g_strdup (uniform_name);
return i;
}
else
/* We've run out of space for new uniform names so just pretend it
isn't there */
return -1;
}
void
@ -195,7 +164,12 @@ cogl_program_uniform_1f (COGLint uniform_no,
gfloat value)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
glUniform1f (uniform_no, value);
if (uniform_no >= 0 && uniform_no < COGL_GLES2_NUM_CUSTOM_UNIFORMS)
{
ctx->gles2.custom_uniforms[uniform_no] = value;
ctx->gles2.dirty_custom_uniforms |= 1 << uniform_no;
}
}
#else /* HAVE_COGL_GLES2 */

10
clutter/cogl/gles/cogl-program.h
View File

@ -33,16 +33,10 @@ typedef struct _CoglProgram CoglProgram;
struct _CoglProgram
{
guint ref_count;
GLuint gl_handle;
/* Keep track of which types of shader we've attached so we can link
in our replacement fixed functionality shader */
gboolean attached_vertex_shader;
gboolean attached_fragment_shader;
gboolean attached_fixed_vertex_shader;
gboolean attached_fixed_fragment_shader;
GSList *attached_shaders;
CoglGles2WrapperUniforms uniforms;
char *custom_uniform_names[COGL_GLES2_NUM_CUSTOM_UNIFORMS];
};
CoglProgram *_cogl_program_pointer_from_handle (CoglHandle handle);

19
clutter/cogl/gles/stringify.sh
View File

@ -44,7 +44,11 @@ if test "$#" = 2; then
echo "#ifndef ${guardname}" >> "${headername}";
echo "#define ${guardname}" >> "${headername}";
echo >> "${headername}";
echo "extern const char ${varname}[];" >> "${headername}";
sed -n \
-e 's/^ *\/\*\*\* \([a-zA-Z0-9_]*\) \*\*\*\//extern const char \1[];/p' \
< "$2" >> "${headername}";
echo >> "${headername}";
echo "#endif /* ${guardname} */" >> "${headername}";
@ -57,9 +61,16 @@ else
output_copyright "${cname}";
echo >> "${cname}";
echo "const char ${varname}[] =" >> "${cname}";
sed -e 's/"/\\"/' -e 's/^/ \"/' -e 's/$/\\n"/' \
sed -n \
-e h \
-e 's/^ *\/\*\*\* \([a-zA-Z0-9_]*\) \*\*\*\// ;\nconst char \1[] =/' \
-e 't got' \
-e g \
-e 's/"/\\"/' \
-e 's/^/ "/' \
-e 's/$/\\n"/' \
-e ': got' \
-e p \
< "$1" >> "${cname}";
echo " ;" >> "${cname}";
fi;