2008-04-29 12:10:37 -04:00
|
|
|
/*
|
2009-04-27 10:48:12 -04:00
|
|
|
* Cogl
|
2008-04-29 12:10:37 -04:00
|
|
|
*
|
2009-04-27 10:48:12 -04:00
|
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
2008-04-29 12:10:37 -04:00
|
|
|
*
|
2010-04-26 05:01:43 -04:00
|
|
|
* Copyright (C) 2008,2009,2010 Intel Corporation.
|
2008-04-29 12:10:37 -04:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2010-03-01 07:56:10 -05:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*
|
2008-04-29 12:10:37 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "cogl.h"
|
|
|
|
#include "cogl-program.h"
|
2008-10-30 13:25:00 -04:00
|
|
|
#include "cogl-shader-private.h"
|
2008-04-29 12:10:37 -04:00
|
|
|
#include "cogl-internal.h"
|
|
|
|
#include "cogl-handle.h"
|
|
|
|
#include "cogl-context.h"
|
2010-02-10 13:18:30 -05:00
|
|
|
#include "cogl-journal-private.h"
|
2008-04-29 12:10:37 -04:00
|
|
|
|
|
|
|
#include <glib.h>
|
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
#define glCreateProgram ctx->drv.pf_glCreateProgram
|
|
|
|
#define glAttachShader ctx->drv.pf_glAttachShader
|
|
|
|
#define glUseProgram ctx->drv.pf_glUseProgram
|
2009-11-17 08:52:40 -05:00
|
|
|
#define glLinkProgram ctx->drv.pf_glLinkProgram
|
|
|
|
#define glGetUniformLocation ctx->drv.pf_glGetUniformLocation
|
|
|
|
#define glUniform1f ctx->drv.pf_glUniform1f
|
|
|
|
#define glUniform2f ctx->drv.pf_glUniform2f
|
|
|
|
#define glUniform3f ctx->drv.pf_glUniform3f
|
|
|
|
#define glUniform4f ctx->drv.pf_glUniform4f
|
|
|
|
#define glUniform1fv ctx->drv.pf_glUniform1fv
|
|
|
|
#define glUniform2fv ctx->drv.pf_glUniform2fv
|
|
|
|
#define glUniform3fv ctx->drv.pf_glUniform3fv
|
|
|
|
#define glUniform4fv ctx->drv.pf_glUniform4fv
|
|
|
|
#define glUniform1i ctx->drv.pf_glUniform1i
|
|
|
|
#define glUniform2i ctx->drv.pf_glUniform2i
|
|
|
|
#define glUniform3i ctx->drv.pf_glUniform3i
|
|
|
|
#define glUniform4i ctx->drv.pf_glUniform4i
|
|
|
|
#define glUniform1iv ctx->drv.pf_glUniform1iv
|
|
|
|
#define glUniform2iv ctx->drv.pf_glUniform2iv
|
|
|
|
#define glUniform3iv ctx->drv.pf_glUniform3iv
|
|
|
|
#define glUniform4iv ctx->drv.pf_glUniform4iv
|
|
|
|
#define glUniformMatrix2fv ctx->drv.pf_glUniformMatrix2fv
|
|
|
|
#define glUniformMatrix3fv ctx->drv.pf_glUniformMatrix3fv
|
|
|
|
#define glUniformMatrix4fv ctx->drv.pf_glUniformMatrix4fv
|
2010-04-26 05:01:43 -04:00
|
|
|
#define glDeleteProgram ctx->drv.pf_glDeleteProgram
|
2008-04-29 12:10:37 -04:00
|
|
|
|
|
|
|
static void _cogl_program_free (CoglProgram *program);
|
|
|
|
|
2009-04-01 12:16:44 -04:00
|
|
|
COGL_HANDLE_DEFINE (Program, program);
|
2008-04-29 12:10:37 -04:00
|
|
|
|
|
|
|
static void
|
|
|
|
_cogl_program_free (CoglProgram *program)
|
|
|
|
{
|
|
|
|
/* Frees program resources but its handle is not
|
|
|
|
released! Do that separately before this! */
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glDeleteProgram (program->gl_handle));
|
2008-04-29 12:10:37 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
CoglHandle
|
|
|
|
cogl_create_program (void)
|
|
|
|
{
|
|
|
|
CoglProgram *program;
|
2010-05-27 03:28:29 -04:00
|
|
|
_COGL_GET_CONTEXT (ctx, NULL);
|
2008-04-29 12:10:37 -04:00
|
|
|
|
|
|
|
program = g_slice_new (CoglProgram);
|
2010-04-26 05:01:43 -04:00
|
|
|
program->gl_handle = glCreateProgram ();
|
2008-04-29 12:10:37 -04:00
|
|
|
|
|
|
|
return _cogl_program_handle_new (program);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
cogl_program_attach_shader (CoglHandle program_handle,
|
|
|
|
CoglHandle shader_handle)
|
|
|
|
{
|
|
|
|
CoglProgram *program;
|
|
|
|
CoglShader *shader;
|
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
2009-04-27 10:48:12 -04:00
|
|
|
|
2008-04-29 12:10:37 -04:00
|
|
|
if (!cogl_is_program (program_handle) || !cogl_is_shader (shader_handle))
|
|
|
|
return;
|
|
|
|
|
|
|
|
program = _cogl_program_pointer_from_handle (program_handle);
|
|
|
|
shader = _cogl_shader_pointer_from_handle (shader_handle);
|
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glAttachShader (program->gl_handle, shader->gl_handle));
|
2008-04-29 12:10:37 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
cogl_program_link (CoglHandle handle)
|
|
|
|
{
|
|
|
|
CoglProgram *program;
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
2009-04-27 10:48:12 -04:00
|
|
|
|
2008-04-29 12:10:37 -04:00
|
|
|
if (!cogl_is_program (handle))
|
|
|
|
return;
|
|
|
|
|
|
|
|
program = _cogl_program_pointer_from_handle (handle);
|
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glLinkProgram (program->gl_handle));
|
2008-04-29 12:10:37 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
cogl_program_use (CoglHandle handle)
|
|
|
|
{
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
2009-04-27 10:48:12 -04:00
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
g_return_if_fail (handle == COGL_INVALID_HANDLE ||
|
|
|
|
cogl_is_program (handle));
|
[cogl] Improving Cogl journal to minimize driver overheads + GPU state changes
Previously the journal was always flushed at the end of
_cogl_rectangles_with_multitexture_coords, (i.e. the end of any
cogl_rectangle* calls) but now we have broadened the potential for batching
geometry. In ideal circumstances we will only flush once per scene.
In summary the journal works like this:
When you use any of the cogl_rectangle* APIs then nothing is emitted to the
GPU at this point, we just log one or more quads into the journal. A
journal entry consists of the quad coordinates, an associated material
reference, and a modelview matrix. Ideally the journal only gets flushed
once at the end of a scene, but in fact there are things to consider that
may cause unwanted flushing, including:
- modifying materials mid-scene
This is because each quad in the journal has an associated material
reference (i.e. not copy), so if you try and modify a material that is
already referenced in the journal we force a flush first)
NOTE: For now this means you should avoid using cogl_set_source_color()
since that currently uses a single shared material. Later we
should change it to use a pool of materials that is recycled
when the journal is flushed.
- modifying any state that isn't currently logged, such as depth, fog and
backface culling enables.
The first thing that happens when flushing, is to upload all the vertex data
associated with the journal into a single VBO.
We then go through a process of splitting up the journal into batches that
have compatible state so they can be emitted to the GPU together. This is
currently broken up into 3 levels so we can stagger the state changes:
1) we break the journal up according to changes in the number of material layers
associated with logged quads. The number of layers in a material determines
the stride of the associated vertices, so we have to update our vertex
array offsets at this level. (i.e. calling gl{Vertex,Color},Pointer etc)
2) we further split batches up according to material compatability. (e.g.
materials with different textures) We flush material state at this level.
3) Finally we split batches up according to modelview changes. At this level
we update the modelview matrix and actually emit the actual draw command.
This commit is largely about putting the initial design in-place; this will be
followed by other changes that take advantage of the extended batching.
2009-06-17 13:46:42 -04:00
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
if (ctx->current_program == 0 && handle != 0)
|
|
|
|
ctx->legacy_state_set++;
|
|
|
|
else if (handle == 0 && ctx->current_program != 0)
|
|
|
|
ctx->legacy_state_set--;
|
2008-04-29 12:10:37 -04:00
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
if (handle != COGL_INVALID_HANDLE)
|
|
|
|
cogl_handle_ref (handle);
|
|
|
|
if (ctx->current_program != COGL_INVALID_HANDLE)
|
|
|
|
cogl_handle_unref (ctx->current_program);
|
|
|
|
ctx->current_program = handle;
|
2008-04-29 12:10:37 -04:00
|
|
|
}
|
|
|
|
|
2009-05-12 09:15:18 -04:00
|
|
|
int
|
2008-04-29 12:10:37 -04:00
|
|
|
cogl_program_get_uniform_location (CoglHandle handle,
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-09 20:57:32 -05:00
|
|
|
const char *uniform_name)
|
2008-04-29 12:10:37 -04:00
|
|
|
{
|
|
|
|
CoglProgram *program;
|
|
|
|
_COGL_GET_CONTEXT (ctx, 0);
|
2009-04-27 10:48:12 -04:00
|
|
|
|
2008-04-29 12:10:37 -04:00
|
|
|
if (!cogl_is_program (handle))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
program = _cogl_program_pointer_from_handle (handle);
|
|
|
|
|
2009-11-17 08:52:40 -05:00
|
|
|
return glGetUniformLocation (program->gl_handle, uniform_name);
|
2008-04-29 12:10:37 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-05-12 09:15:18 -04:00
|
|
|
cogl_program_uniform_1f (int uniform_no,
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-09 20:57:32 -05:00
|
|
|
float value)
|
2008-04-29 12:10:37 -04:00
|
|
|
{
|
2010-04-26 05:01:43 -04:00
|
|
|
CoglProgram *program;
|
|
|
|
|
2008-04-29 12:10:37 -04:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
2010-04-26 05:01:43 -04:00
|
|
|
|
|
|
|
program = ctx->current_program;
|
|
|
|
|
|
|
|
g_return_if_fail (program != NULL);
|
|
|
|
|
|
|
|
_cogl_gl_use_program_wrapper (program->gl_handle);
|
|
|
|
|
|
|
|
GE (glUniform1f (uniform_no, value));
|
2008-04-29 12:10:37 -04:00
|
|
|
}
|
2008-11-18 10:08:40 -05:00
|
|
|
|
2008-11-18 10:21:02 -05:00
|
|
|
void
|
2009-05-12 09:15:18 -04:00
|
|
|
cogl_program_uniform_1i (int uniform_no,
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-09 20:57:32 -05:00
|
|
|
int value)
|
2008-11-18 10:21:02 -05:00
|
|
|
{
|
2010-04-26 05:01:43 -04:00
|
|
|
CoglProgram *program;
|
|
|
|
|
2008-11-18 10:21:02 -05:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
2010-04-26 05:01:43 -04:00
|
|
|
|
|
|
|
program = ctx->current_program;
|
|
|
|
|
|
|
|
g_return_if_fail (program != NULL);
|
|
|
|
|
|
|
|
_cogl_gl_use_program_wrapper (program->gl_handle);
|
|
|
|
|
|
|
|
GE (glUniform1i (uniform_no, value));
|
2008-11-18 10:21:02 -05:00
|
|
|
}
|
|
|
|
|
2008-11-18 10:08:40 -05:00
|
|
|
void
|
2009-05-12 09:15:18 -04:00
|
|
|
cogl_program_uniform_float (int uniform_no,
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-09 20:57:32 -05:00
|
|
|
int size,
|
|
|
|
int count,
|
2008-11-18 10:08:40 -05:00
|
|
|
const GLfloat *value)
|
|
|
|
{
|
2010-04-26 05:01:43 -04:00
|
|
|
CoglProgram *program;
|
|
|
|
|
2008-11-18 10:08:40 -05:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
program = ctx->current_program;
|
|
|
|
|
|
|
|
g_return_if_fail (program != NULL);
|
|
|
|
|
|
|
|
_cogl_gl_use_program_wrapper (program->gl_handle);
|
|
|
|
|
2008-11-18 10:08:40 -05:00
|
|
|
switch (size)
|
|
|
|
{
|
|
|
|
case 1:
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glUniform1fv (uniform_no, count, value));
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
case 2:
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glUniform2fv (uniform_no, count, value));
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
case 3:
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glUniform3fv (uniform_no, count, value));
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
case 4:
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glUniform4fv (uniform_no, count, value));
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_warning ("%s called with invalid size parameter", G_STRFUNC);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-05-12 09:15:18 -04:00
|
|
|
cogl_program_uniform_int (int uniform_no,
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-09 20:57:32 -05:00
|
|
|
int size,
|
|
|
|
int count,
|
2009-05-12 09:15:18 -04:00
|
|
|
const int *value)
|
2008-11-18 10:08:40 -05:00
|
|
|
{
|
2010-04-26 05:01:43 -04:00
|
|
|
CoglProgram *program;
|
|
|
|
|
2008-11-18 10:08:40 -05:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
program = ctx->current_program;
|
|
|
|
|
|
|
|
g_return_if_fail (program != NULL);
|
|
|
|
|
|
|
|
_cogl_gl_use_program_wrapper (program->gl_handle);
|
|
|
|
|
2008-11-18 10:08:40 -05:00
|
|
|
switch (size)
|
|
|
|
{
|
|
|
|
case 1:
|
2009-11-17 08:52:40 -05:00
|
|
|
glUniform1iv (uniform_no, count, value);
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
case 2:
|
2009-11-17 08:52:40 -05:00
|
|
|
glUniform2iv (uniform_no, count, value);
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
case 3:
|
2009-11-17 08:52:40 -05:00
|
|
|
glUniform3iv (uniform_no, count, value);
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
case 4:
|
2009-11-17 08:52:40 -05:00
|
|
|
glUniform4iv (uniform_no, count, value);
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_warning ("%s called with invalid size parameter", G_STRFUNC);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-05-12 09:15:18 -04:00
|
|
|
cogl_program_uniform_matrix (int uniform_no,
|
cogl: improves header and coding style consistency
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.
There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.
The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:
return_type
cogl_function_name (CoglType arg0,
CoglType arg1);
Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.
The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
2010-02-09 20:57:32 -05:00
|
|
|
int size,
|
|
|
|
int count,
|
2008-11-18 10:08:40 -05:00
|
|
|
gboolean transpose,
|
|
|
|
const GLfloat *value)
|
|
|
|
{
|
2010-04-26 05:01:43 -04:00
|
|
|
CoglProgram *program;
|
|
|
|
|
2008-11-18 10:08:40 -05:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2010-04-26 05:01:43 -04:00
|
|
|
program = ctx->current_program;
|
|
|
|
|
|
|
|
g_return_if_fail (program != NULL);
|
|
|
|
|
|
|
|
_cogl_gl_use_program_wrapper (program->gl_handle);
|
|
|
|
|
2008-11-18 10:08:40 -05:00
|
|
|
switch (size)
|
|
|
|
{
|
|
|
|
case 2 :
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glUniformMatrix2fv (uniform_no, count, transpose, value));
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
case 3 :
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glUniformMatrix3fv (uniform_no, count, transpose, value));
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
case 4 :
|
2010-04-26 05:01:43 -04:00
|
|
|
GE (glUniformMatrix4fv (uniform_no, count, transpose, value));
|
2008-11-18 10:08:40 -05:00
|
|
|
break;
|
|
|
|
default :
|
|
|
|
g_warning ("%s called with invalid size parameter", G_STRFUNC);
|
|
|
|
}
|
|
|
|
}
|