2008-04-30 15:05:17 +00:00
|
|
|
/*
|
2009-04-27 14:48:12 +00:00
|
|
|
* Cogl
|
2008-04-30 15:05:17 +00:00
|
|
|
*
|
2009-04-27 14:48:12 +00:00
|
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
2008-04-30 15:05:17 +00:00
|
|
|
*
|
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-10 01:57:32 +00:00
|
|
|
* Copyright (C) 2007,2008,2009,2010 Intel Corporation.
|
2008-04-30 15:05:17 +00: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 12:56:10 +00:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*
|
2008-04-30 15:05:17 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "cogl.h"
|
2010-07-25 20:36:41 +00:00
|
|
|
#include "cogl-debug.h"
|
2008-04-30 15:05:17 +00:00
|
|
|
#include "cogl-internal.h"
|
|
|
|
#include "cogl-context.h"
|
2009-09-16 13:01:57 +00:00
|
|
|
#include "cogl-journal-private.h"
|
2009-03-23 12:29:15 +00:00
|
|
|
#include "cogl-texture-private.h"
|
2010-10-27 17:54:57 +00:00
|
|
|
#include "cogl-pipeline-private.h"
|
|
|
|
#include "cogl-pipeline-opengl-private.h"
|
2009-06-01 16:10:22 +00:00
|
|
|
#include "cogl-vertex-buffer-private.h"
|
2009-11-26 19:06:35 +00:00
|
|
|
#include "cogl-framebuffer-private.h"
|
2010-10-18 16:17:22 +00:00
|
|
|
#include "cogl-vertex-attribute-private.h"
|
2008-04-30 15:05:17 +00:00
|
|
|
|
|
|
|
#include <string.h>
|
2009-01-20 16:20:54 +00:00
|
|
|
#include <math.h>
|
2008-04-30 15:05:17 +00:00
|
|
|
|
|
|
|
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16
|
|
|
|
|
2009-10-17 03:06:56 +00:00
|
|
|
#ifdef HAVE_COGL_GL
|
|
|
|
#define glClientActiveTexture ctx->drv.pf_glClientActiveTexture
|
|
|
|
#endif
|
|
|
|
|
[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 17:46:42 +00:00
|
|
|
|
2009-09-16 10:56:17 +00:00
|
|
|
typedef struct _TextureSlicedQuadState
|
|
|
|
{
|
2010-10-27 17:54:57 +00:00
|
|
|
CoglPipeline *pipeline;
|
2009-09-16 10:56:17 +00:00
|
|
|
float tex_virtual_origin_x;
|
|
|
|
float tex_virtual_origin_y;
|
|
|
|
float quad_origin_x;
|
|
|
|
float quad_origin_y;
|
|
|
|
float v_to_q_scale_x;
|
|
|
|
float v_to_q_scale_y;
|
|
|
|
float quad_len_x;
|
|
|
|
float quad_len_y;
|
|
|
|
gboolean flipped_x;
|
|
|
|
gboolean flipped_y;
|
2010-10-27 17:54:57 +00:00
|
|
|
CoglPipelineWrapModeOverrides *wrap_mode_overrides;
|
2009-09-16 10:56:17 +00:00
|
|
|
} TextureSlicedQuadState;
|
|
|
|
|
|
|
|
typedef struct _TextureSlicedPolygonState
|
|
|
|
{
|
2010-01-04 11:43:00 +00:00
|
|
|
const CoglTextureVertex *vertices;
|
2009-09-16 10:56:17 +00:00
|
|
|
int n_vertices;
|
|
|
|
int stride;
|
2010-10-18 16:17:22 +00:00
|
|
|
CoglVertexAttribute **attributes;
|
2009-09-16 10:56:17 +00:00
|
|
|
} TextureSlicedPolygonState;
|
|
|
|
|
2009-03-23 12:29:15 +00:00
|
|
|
static void
|
2009-09-16 10:56:17 +00:00
|
|
|
log_quad_sub_textures_cb (CoglHandle texture_handle,
|
|
|
|
GLuint gl_handle,
|
|
|
|
GLenum gl_target,
|
2009-12-02 17:17:24 +00:00
|
|
|
const float *subtexture_coords,
|
|
|
|
const float *virtual_coords,
|
2009-09-16 10:56:17 +00:00
|
|
|
void *user_data)
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
2009-09-16 10:56:17 +00:00
|
|
|
TextureSlicedQuadState *state = user_data;
|
|
|
|
float quad_coords[4];
|
|
|
|
|
|
|
|
#define TEX_VIRTUAL_TO_QUAD(V, Q, AXIS) \
|
|
|
|
do { \
|
|
|
|
Q = V - state->tex_virtual_origin_##AXIS; \
|
|
|
|
Q *= state->v_to_q_scale_##AXIS; \
|
|
|
|
if (state->flipped_##AXIS) \
|
|
|
|
Q = state->quad_len_##AXIS - Q; \
|
|
|
|
Q += state->quad_origin_##AXIS; \
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
TEX_VIRTUAL_TO_QUAD (virtual_coords[0], quad_coords[0], x);
|
|
|
|
TEX_VIRTUAL_TO_QUAD (virtual_coords[1], quad_coords[1], y);
|
|
|
|
|
|
|
|
TEX_VIRTUAL_TO_QUAD (virtual_coords[2], quad_coords[2], x);
|
|
|
|
TEX_VIRTUAL_TO_QUAD (virtual_coords[3], quad_coords[3], y);
|
|
|
|
|
|
|
|
#undef TEX_VIRTUAL_TO_QUAD
|
|
|
|
|
|
|
|
COGL_NOTE (DRAW,
|
|
|
|
"~~~~~ slice\n"
|
|
|
|
"qx1: %f\t"
|
|
|
|
"qy1: %f\n"
|
|
|
|
"qx2: %f\t"
|
|
|
|
"qy2: %f\n"
|
|
|
|
"tx1: %f\t"
|
|
|
|
"ty1: %f\n"
|
|
|
|
"tx2: %f\t"
|
|
|
|
"ty2: %f\n",
|
|
|
|
quad_coords[0], quad_coords[1],
|
|
|
|
quad_coords[2], quad_coords[3],
|
|
|
|
subtexture_coords[0], subtexture_coords[1],
|
|
|
|
subtexture_coords[2], subtexture_coords[3]);
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
/* FIXME: when the wrap mode becomes part of the pipeline we need to
|
2009-09-16 10:56:17 +00:00
|
|
|
* be able to override the wrap mode when logging a quad. */
|
2010-02-11 15:33:01 +00:00
|
|
|
_cogl_journal_log_quad (quad_coords,
|
2010-10-27 17:54:57 +00:00
|
|
|
state->pipeline,
|
2009-09-16 10:56:17 +00:00
|
|
|
1, /* one layer */
|
|
|
|
0, /* don't need to use fallbacks */
|
|
|
|
gl_handle, /* replace the layer0 texture */
|
2010-04-01 17:35:32 +00:00
|
|
|
state->wrap_mode_overrides, /* use GL_CLAMP_TO_EDGE */
|
2009-09-16 10:56:17 +00:00
|
|
|
subtexture_coords,
|
|
|
|
4);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This path doesn't currently support multitexturing but is used for
|
|
|
|
* CoglTextures that don't support repeating using the GPU so we need to
|
|
|
|
* manually emit extra geometry to fake the repeating. This includes:
|
|
|
|
*
|
|
|
|
* - CoglTexture2DSliced: when made of > 1 slice or if the users given
|
|
|
|
* texture coordinates require repeating,
|
|
|
|
* - CoglTexture2DAtlas: if the users given texture coordinates require
|
|
|
|
* repeating,
|
|
|
|
* - CoglTextureRectangle: if the users given texture coordinates require
|
|
|
|
* repeating,
|
|
|
|
* - CoglTexturePixmap: if the users given texture coordinates require
|
|
|
|
* repeating
|
|
|
|
*/
|
|
|
|
/* TODO: support multitexturing */
|
|
|
|
static void
|
2010-10-27 17:54:57 +00:00
|
|
|
_cogl_texture_quad_multiple_primitives (CoglHandle tex_handle,
|
|
|
|
CoglPipeline *pipeline,
|
|
|
|
gboolean clamp_s,
|
|
|
|
gboolean clamp_t,
|
|
|
|
const float *position,
|
|
|
|
float tx_1,
|
|
|
|
float ty_1,
|
|
|
|
float tx_2,
|
|
|
|
float ty_2)
|
2009-09-16 10:56:17 +00:00
|
|
|
{
|
|
|
|
TextureSlicedQuadState state;
|
2010-10-27 17:54:57 +00:00
|
|
|
CoglPipelineWrapModeOverrides wrap_mode_overrides;
|
2009-09-16 10:56:17 +00:00
|
|
|
gboolean tex_virtual_flipped_x;
|
|
|
|
gboolean tex_virtual_flipped_y;
|
|
|
|
gboolean quad_flipped_x;
|
|
|
|
gboolean quad_flipped_y;
|
2010-04-01 17:35:32 +00:00
|
|
|
CoglHandle first_layer;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2010-04-01 10:31:33 +00:00
|
|
|
/* If the wrap mode is clamp to edge then we'll recursively draw the
|
|
|
|
stretched part and replace the coordinates */
|
|
|
|
if (clamp_s && tx_1 != tx_2)
|
|
|
|
{
|
|
|
|
float *replacement_position = g_newa (float, 4);
|
|
|
|
float old_tx_1 = tx_1, old_tx_2 = tx_2;
|
|
|
|
|
|
|
|
memcpy (replacement_position, position, sizeof (float) * 4);
|
|
|
|
|
|
|
|
tx_1 = CLAMP (tx_1, 0.0f, 1.0f);
|
|
|
|
tx_2 = CLAMP (tx_2, 0.0f, 1.0f);
|
|
|
|
|
|
|
|
if (old_tx_1 != tx_1)
|
|
|
|
{
|
|
|
|
/* Draw the left part of the quad as a stretched copy of tx_1 */
|
|
|
|
float tmp_position[] =
|
|
|
|
{ position[0], position[1],
|
|
|
|
(position[0] +
|
|
|
|
(position[2] - position[0]) *
|
|
|
|
(tx_1 - old_tx_1) / (old_tx_2 - old_tx_1)),
|
|
|
|
position[3] };
|
2010-10-27 17:54:57 +00:00
|
|
|
_cogl_texture_quad_multiple_primitives (tex_handle, pipeline,
|
2010-04-01 10:31:33 +00:00
|
|
|
FALSE, clamp_t,
|
|
|
|
tmp_position,
|
|
|
|
tx_1, ty_1, tx_1, ty_2);
|
|
|
|
replacement_position[0] = tmp_position[2];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (old_tx_2 != tx_2)
|
|
|
|
{
|
|
|
|
/* Draw the right part of the quad as a stretched copy of tx_2 */
|
|
|
|
float tmp_position[] =
|
|
|
|
{ (position[0] +
|
|
|
|
(position[2] - position[0]) *
|
|
|
|
(tx_2 - old_tx_1) / (old_tx_2 - old_tx_1)),
|
|
|
|
position[1], position[2], position[3] };
|
2010-10-27 17:54:57 +00:00
|
|
|
_cogl_texture_quad_multiple_primitives (tex_handle, pipeline,
|
2010-04-01 10:31:33 +00:00
|
|
|
FALSE, clamp_t,
|
|
|
|
tmp_position,
|
|
|
|
tx_2, ty_1, tx_2, ty_2);
|
|
|
|
replacement_position[2] = tmp_position[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there's no main part left then we don't need to continue */
|
|
|
|
if (tx_1 == tx_2)
|
|
|
|
return;
|
|
|
|
|
|
|
|
position = replacement_position;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (clamp_t && ty_1 != ty_2)
|
|
|
|
{
|
|
|
|
float *replacement_position = g_newa (float, 4);
|
|
|
|
float old_ty_1 = ty_1, old_ty_2 = ty_2;
|
|
|
|
|
|
|
|
memcpy (replacement_position, position, sizeof (float) * 4);
|
|
|
|
|
|
|
|
ty_1 = CLAMP (ty_1, 0.0f, 1.0f);
|
|
|
|
ty_2 = CLAMP (ty_2, 0.0f, 1.0f);
|
|
|
|
|
|
|
|
if (old_ty_1 != ty_1)
|
|
|
|
{
|
|
|
|
/* Draw the top part of the quad as a stretched copy of ty_1 */
|
|
|
|
float tmp_position[] =
|
|
|
|
{ position[0], position[1], position[2],
|
|
|
|
(position[1] +
|
|
|
|
(position[3] - position[1]) *
|
|
|
|
(ty_1 - old_ty_1) / (old_ty_2 - old_ty_1)) };
|
2010-10-27 17:54:57 +00:00
|
|
|
_cogl_texture_quad_multiple_primitives (tex_handle, pipeline,
|
2010-04-01 10:31:33 +00:00
|
|
|
clamp_s, FALSE,
|
|
|
|
tmp_position,
|
|
|
|
tx_1, ty_1, tx_2, ty_1);
|
|
|
|
replacement_position[1] = tmp_position[3];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (old_ty_2 != ty_2)
|
|
|
|
{
|
|
|
|
/* Draw the bottom part of the quad as a stretched copy of ty_2 */
|
|
|
|
float tmp_position[] =
|
|
|
|
{ position[0],
|
|
|
|
(position[1] +
|
|
|
|
(position[3] - position[1]) *
|
|
|
|
(ty_2 - old_ty_1) / (old_ty_2 - old_ty_1)),
|
|
|
|
position[2], position[3] };
|
2010-10-27 17:54:57 +00:00
|
|
|
_cogl_texture_quad_multiple_primitives (tex_handle, pipeline,
|
2010-04-01 10:31:33 +00:00
|
|
|
clamp_s, FALSE,
|
|
|
|
tmp_position,
|
|
|
|
tx_1, ty_2, tx_2, ty_2);
|
|
|
|
replacement_position[3] = tmp_position[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there's no main part left then we don't need to continue */
|
|
|
|
if (ty_1 == ty_2)
|
|
|
|
return;
|
|
|
|
|
|
|
|
position = replacement_position;
|
|
|
|
}
|
|
|
|
|
2010-04-01 17:35:32 +00:00
|
|
|
state.wrap_mode_overrides = NULL;
|
2010-05-27 14:18:15 +00:00
|
|
|
memset (&wrap_mode_overrides, 0, sizeof (wrap_mode_overrides));
|
2009-03-23 12:29:15 +00:00
|
|
|
|
|
|
|
/* We can't use hardware repeat so we need to set clamp to edge
|
2010-04-01 17:35:32 +00:00
|
|
|
otherwise it might pull in edge pixels from the other side. By
|
|
|
|
default WRAP_MODE_AUTOMATIC becomes CLAMP_TO_EDGE so we only need
|
|
|
|
to override if the wrap mode is repeat */
|
2010-10-27 17:54:57 +00:00
|
|
|
first_layer = _cogl_pipeline_get_layers (pipeline)->data;
|
|
|
|
if (_cogl_pipeline_layer_get_wrap_mode_s (first_layer) ==
|
|
|
|
COGL_PIPELINE_WRAP_MODE_REPEAT)
|
2010-04-01 17:35:32 +00:00
|
|
|
{
|
|
|
|
state.wrap_mode_overrides = &wrap_mode_overrides;
|
|
|
|
wrap_mode_overrides.values[0].s =
|
2010-10-27 17:54:57 +00:00
|
|
|
COGL_PIPELINE_WRAP_MODE_OVERRIDE_CLAMP_TO_EDGE;
|
2010-04-01 17:35:32 +00:00
|
|
|
}
|
2010-10-27 17:54:57 +00:00
|
|
|
if (_cogl_pipeline_layer_get_wrap_mode_t (first_layer) ==
|
|
|
|
COGL_PIPELINE_WRAP_MODE_REPEAT)
|
2010-04-01 17:35:32 +00:00
|
|
|
{
|
|
|
|
state.wrap_mode_overrides = &wrap_mode_overrides;
|
|
|
|
wrap_mode_overrides.values[0].t =
|
2010-10-27 17:54:57 +00:00
|
|
|
COGL_PIPELINE_WRAP_MODE_OVERRIDE_CLAMP_TO_EDGE;
|
2010-04-01 17:35:32 +00:00
|
|
|
}
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
state.pipeline = pipeline;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2009-09-16 10:56:17 +00:00
|
|
|
/* Get together the data we need to transform the virtual texture
|
|
|
|
* coordinates of each slice into quad coordinates...
|
|
|
|
*
|
|
|
|
* NB: We need to consider that the quad coordinates and the texture
|
|
|
|
* coordinates may be inverted along the x or y axis, and must preserve the
|
|
|
|
* inversions when we emit the final geometry.
|
|
|
|
*/
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-02-11 15:33:01 +00:00
|
|
|
#define X0 0
|
|
|
|
#define Y0 1
|
|
|
|
#define X1 2
|
|
|
|
#define Y1 3
|
|
|
|
|
2009-09-16 10:56:17 +00:00
|
|
|
tex_virtual_flipped_x = (tx_1 > tx_2) ? TRUE : FALSE;
|
|
|
|
tex_virtual_flipped_y = (ty_1 > ty_2) ? TRUE : FALSE;
|
|
|
|
state.tex_virtual_origin_x = tex_virtual_flipped_x ? tx_2 : tx_1;
|
|
|
|
state.tex_virtual_origin_y = tex_virtual_flipped_y ? ty_2 : ty_1;
|
|
|
|
|
2010-02-11 15:33:01 +00:00
|
|
|
quad_flipped_x = (position[X0] > position[X1]) ? TRUE : FALSE;
|
|
|
|
quad_flipped_y = (position[Y0] > position[Y1]) ? TRUE : FALSE;
|
|
|
|
state.quad_origin_x = quad_flipped_x ? position[X1] : position[X0];
|
|
|
|
state.quad_origin_y = quad_flipped_y ? position[Y1] : position[Y0];
|
2009-09-16 10:56:17 +00:00
|
|
|
|
|
|
|
/* flatten the two forms of coordinate inversion into one... */
|
|
|
|
state.flipped_x = tex_virtual_flipped_x ^ quad_flipped_x;
|
|
|
|
state.flipped_y = tex_virtual_flipped_y ^ quad_flipped_y;
|
|
|
|
|
|
|
|
/* We use the _len_AXIS naming here instead of _width and _height because
|
|
|
|
* log_quad_slice_cb uses a macro with symbol concatenation to handle both
|
|
|
|
* axis, so this is more convenient... */
|
2010-02-11 15:33:01 +00:00
|
|
|
state.quad_len_x = fabs (position[X1] - position[X0]);
|
|
|
|
state.quad_len_y = fabs (position[Y1] - position[Y0]);
|
|
|
|
|
|
|
|
#undef X0
|
|
|
|
#undef Y0
|
|
|
|
#undef X1
|
|
|
|
#undef Y1
|
2009-09-16 10:56:17 +00:00
|
|
|
|
|
|
|
state.v_to_q_scale_x = fabs (state.quad_len_x / (tx_2 - tx_1));
|
|
|
|
state.v_to_q_scale_y = fabs (state.quad_len_y / (ty_2 - ty_1));
|
|
|
|
|
|
|
|
_cogl_texture_foreach_sub_texture_in_region (tex_handle,
|
|
|
|
tx_1, ty_1, tx_2, ty_2,
|
|
|
|
log_quad_sub_textures_cb,
|
|
|
|
&state);
|
2009-03-23 12:29:15 +00:00
|
|
|
}
|
|
|
|
|
2009-09-16 10:56:17 +00:00
|
|
|
/* This path supports multitexturing but only when each of the layers is
|
|
|
|
* handled with a single GL texture. Also if repeating is necessary then
|
|
|
|
* _cogl_texture_can_hardware_repeat() must return TRUE.
|
|
|
|
* This includes layers made from:
|
|
|
|
*
|
|
|
|
* - CoglTexture2DSliced: if only comprised of a single slice with optional
|
|
|
|
* waste, assuming the users given texture coordinates don't require
|
|
|
|
* repeating.
|
|
|
|
* - CoglTexture{1D,2D,3D}: always.
|
|
|
|
* - CoglTexture2DAtlas: assuming the users given texture coordinates don't
|
|
|
|
* require repeating.
|
|
|
|
* - CoglTextureRectangle: assuming the users given texture coordinates don't
|
|
|
|
* require repeating.
|
|
|
|
* - CoglTexturePixmap: assuming the users given texture coordinates don't
|
|
|
|
* require repeating.
|
|
|
|
*/
|
2009-03-23 12:29:15 +00:00
|
|
|
static gboolean
|
2010-10-27 17:54:57 +00:00
|
|
|
_cogl_multitexture_quad_single_primitive (const float *position,
|
|
|
|
CoglPipeline *pipeline,
|
|
|
|
guint32 fallback_layers,
|
|
|
|
const float *user_tex_coords,
|
|
|
|
int user_tex_coords_len)
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
2010-10-27 17:54:57 +00:00
|
|
|
int n_layers = cogl_pipeline_get_n_layers (pipeline);
|
[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 17:46:42 +00:00
|
|
|
float *final_tex_coords = alloca (sizeof (float) * 4 * n_layers);
|
2009-03-23 12:29:15 +00:00
|
|
|
const GList *layers;
|
|
|
|
GList *tmp;
|
|
|
|
int i;
|
2010-10-27 17:54:57 +00:00
|
|
|
CoglPipelineWrapModeOverrides wrap_mode_overrides;
|
2010-04-01 17:35:32 +00:00
|
|
|
/* This will be set to point to wrap_mode_overrides when an override
|
|
|
|
is needed */
|
2010-10-27 17:54:57 +00:00
|
|
|
CoglPipelineWrapModeOverrides *wrap_mode_overrides_p = NULL;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, FALSE);
|
|
|
|
|
2010-04-01 10:31:33 +00:00
|
|
|
memset (&wrap_mode_overrides, 0, sizeof (wrap_mode_overrides));
|
|
|
|
|
2009-03-23 12:29:15 +00:00
|
|
|
/*
|
|
|
|
* Validate the texture coordinates for this rectangle.
|
|
|
|
*/
|
2010-10-27 17:54:57 +00:00
|
|
|
layers = _cogl_pipeline_get_layers (pipeline);
|
2009-03-23 12:29:15 +00:00
|
|
|
for (tmp = (GList *)layers, i = 0; tmp != NULL; tmp = tmp->next, i++)
|
|
|
|
{
|
2010-03-01 21:49:04 +00:00
|
|
|
CoglHandle layer = (CoglHandle)tmp->data;
|
|
|
|
CoglHandle tex_handle;
|
|
|
|
const float *in_tex_coords;
|
|
|
|
float *out_tex_coords;
|
|
|
|
float default_tex_coords[4] = {0.0, 0.0, 1.0, 1.0};
|
|
|
|
CoglTransformResult transform_result;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
tex_handle = _cogl_pipeline_layer_get_texture (layer);
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2009-06-19 11:15:12 +00:00
|
|
|
/* COGL_INVALID_HANDLE textures are handled by
|
2010-10-27 17:54:57 +00:00
|
|
|
* _cogl_pipeline_flush_gl_state */
|
2009-06-19 11:15:12 +00:00
|
|
|
if (tex_handle == COGL_INVALID_HANDLE)
|
|
|
|
continue;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2009-11-27 15:47:22 +00:00
|
|
|
/* If the user didn't supply texture coordinates for this layer
|
|
|
|
then use the default coords */
|
|
|
|
if (i >= user_tex_coords_len / 4)
|
|
|
|
in_tex_coords = default_tex_coords;
|
|
|
|
else
|
|
|
|
in_tex_coords = &user_tex_coords[i * 4];
|
|
|
|
|
2009-03-23 12:29:15 +00:00
|
|
|
out_tex_coords = &final_tex_coords[i * 4];
|
|
|
|
|
2009-11-27 15:47:22 +00:00
|
|
|
memcpy (out_tex_coords, in_tex_coords, sizeof (GLfloat) * 4);
|
|
|
|
|
2010-03-01 21:49:04 +00:00
|
|
|
/* Convert the texture coordinates to GL.
|
|
|
|
*/
|
|
|
|
transform_result =
|
|
|
|
_cogl_texture_transform_quad_coords_to_gl (tex_handle,
|
|
|
|
out_tex_coords);
|
2009-03-23 12:29:15 +00:00
|
|
|
/* If the texture has waste or we are using GL_TEXTURE_RECT we
|
2009-11-27 15:47:22 +00:00
|
|
|
* can't handle texture repeating so we can't use the layer if
|
|
|
|
* repeating is required.
|
2009-09-16 10:56:17 +00:00
|
|
|
*
|
|
|
|
* NB: We already know that no texture matrix is being used if the
|
|
|
|
* texture doesn't support hardware repeat.
|
2009-03-23 12:29:15 +00:00
|
|
|
*/
|
2010-03-01 21:49:04 +00:00
|
|
|
if (transform_result == COGL_TRANSFORM_SOFTWARE_REPEAT)
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
|
|
|
if (i == 0)
|
|
|
|
{
|
|
|
|
if (n_layers > 1)
|
|
|
|
{
|
|
|
|
static gboolean warning_seen = FALSE;
|
|
|
|
if (!warning_seen)
|
|
|
|
g_warning ("Skipping layers 1..n of your material since "
|
2009-09-16 10:56:17 +00:00
|
|
|
"the first layer doesn't support hardware "
|
|
|
|
"repeat (e.g. because of waste or use of "
|
|
|
|
"GL_TEXTURE_RECTANGLE_ARB) and you supplied "
|
|
|
|
"texture coordinates outside the range [0,1]."
|
|
|
|
"Falling back to software repeat assuming "
|
2009-03-23 12:29:15 +00:00
|
|
|
"layer 0 is the most important one keep");
|
|
|
|
warning_seen = TRUE;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
static gboolean warning_seen = FALSE;
|
|
|
|
if (!warning_seen)
|
|
|
|
g_warning ("Skipping layer %d of your material "
|
2009-09-16 10:56:17 +00:00
|
|
|
"since you have supplied texture coords "
|
|
|
|
"outside the range [0,1] but the texture "
|
|
|
|
"doesn't support hardware repeat (e.g. "
|
|
|
|
"because of waste or use of "
|
|
|
|
"GL_TEXTURE_RECTANGLE_ARB). This isn't "
|
|
|
|
"supported with multi-texturing.", i);
|
2009-03-23 12:29:15 +00:00
|
|
|
warning_seen = TRUE;
|
|
|
|
|
|
|
|
/* NB: marking for fallback will replace the layer with
|
|
|
|
* a default transparent texture */
|
[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 17:46:42 +00:00
|
|
|
fallback_layers |= (1 << i);
|
2009-03-23 12:29:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-01 17:35:32 +00:00
|
|
|
/* By default WRAP_MODE_AUTOMATIC becomes to CLAMP_TO_EDGE. If
|
|
|
|
the texture coordinates need repeating then we'll override
|
|
|
|
this to GL_REPEAT. Otherwise we'll leave it at CLAMP_TO_EDGE
|
|
|
|
so that it won't blend in pixels from the opposite side when
|
|
|
|
the full texture is drawn with GL_LINEAR filter mode */
|
2010-03-01 21:49:04 +00:00
|
|
|
if (transform_result == COGL_TRANSFORM_HARDWARE_REPEAT)
|
2010-04-01 17:35:32 +00:00
|
|
|
{
|
2010-10-27 17:54:57 +00:00
|
|
|
if (_cogl_pipeline_layer_get_wrap_mode_s (layer) ==
|
|
|
|
COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
|
2010-04-01 17:35:32 +00:00
|
|
|
{
|
|
|
|
wrap_mode_overrides.values[i].s
|
2010-10-27 17:54:57 +00:00
|
|
|
= COGL_PIPELINE_WRAP_MODE_OVERRIDE_REPEAT;
|
2010-04-01 17:35:32 +00:00
|
|
|
wrap_mode_overrides_p = &wrap_mode_overrides;
|
|
|
|
}
|
2010-10-27 17:54:57 +00:00
|
|
|
if (_cogl_pipeline_layer_get_wrap_mode_t (layer) ==
|
|
|
|
COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
|
2010-04-01 17:35:32 +00:00
|
|
|
{
|
|
|
|
wrap_mode_overrides.values[i].t
|
2010-10-27 17:54:57 +00:00
|
|
|
= COGL_PIPELINE_WRAP_MODE_OVERRIDE_REPEAT;
|
2010-04-01 17:35:32 +00:00
|
|
|
wrap_mode_overrides_p = &wrap_mode_overrides;
|
|
|
|
}
|
|
|
|
}
|
2009-03-23 12:29:15 +00:00
|
|
|
}
|
|
|
|
|
2010-02-11 15:33:01 +00:00
|
|
|
_cogl_journal_log_quad (position,
|
2010-10-27 17:54:57 +00:00
|
|
|
pipeline,
|
2009-03-23 12:29:15 +00:00
|
|
|
n_layers,
|
[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 17:46:42 +00:00
|
|
|
fallback_layers,
|
2009-03-23 12:29:15 +00:00
|
|
|
0, /* don't replace the layer0 texture */
|
2010-04-01 17:35:32 +00:00
|
|
|
wrap_mode_overrides_p,
|
2009-03-23 12:29:15 +00:00
|
|
|
final_tex_coords,
|
|
|
|
n_layers * 4);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct _CoglMutiTexturedRect
|
|
|
|
{
|
2010-02-11 15:33:01 +00:00
|
|
|
const float *position; /* x0,y0,x1,y1 */
|
|
|
|
const float *tex_coords; /* (tx0,ty0,tx1,ty1)(tx0,ty0,tx1,ty1)(... */
|
|
|
|
int tex_coords_len; /* number of floats in tex_coords? */
|
2009-03-23 12:29:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cogl_rectangles_with_multitexture_coords (
|
|
|
|
struct _CoglMutiTexturedRect *rects,
|
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-10 01:57:32 +00:00
|
|
|
int n_rects)
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
2010-10-27 17:54:57 +00:00
|
|
|
CoglPipeline *pipeline;
|
2010-10-25 12:25:21 +00:00
|
|
|
const GList *layers;
|
|
|
|
int n_layers;
|
|
|
|
const GList *tmp;
|
|
|
|
guint32 fallback_layers = 0;
|
|
|
|
gboolean all_use_sliced_quad_fallback = FALSE;
|
|
|
|
int i;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
pipeline = cogl_get_source ();
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
layers = _cogl_pipeline_get_layers (pipeline);
|
|
|
|
n_layers = cogl_pipeline_get_n_layers (pipeline);
|
2009-03-23 12:29:15 +00:00
|
|
|
|
|
|
|
/*
|
2010-10-27 17:54:57 +00:00
|
|
|
* Validate all the layers of the current source pipeline...
|
2009-03-23 12:29:15 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
for (tmp = layers, i = 0; tmp != NULL; tmp = tmp->next, i++)
|
|
|
|
{
|
|
|
|
CoglHandle layer = tmp->data;
|
2009-06-19 11:15:12 +00:00
|
|
|
CoglHandle tex_handle;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-01-14 17:57:43 +00:00
|
|
|
/* We need to ensure the mipmaps are ready before deciding
|
2010-06-04 16:06:32 +00:00
|
|
|
* anything else about the texture because the texture storage
|
|
|
|
* could completely change if it needs to be migrated out of the
|
|
|
|
* atlas and will affect how we validate the layer.
|
|
|
|
*
|
|
|
|
* FIXME: this needs to be generalized. There could be any
|
|
|
|
* number of things that might require a shuffling of the
|
|
|
|
* underlying texture storage. We could add two mechanisms to
|
|
|
|
* generalize this a bit...
|
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* 1) add a _cogl_pipeline_layer_update_storage() function that
|
2010-06-04 16:06:32 +00:00
|
|
|
* would for instance consider if mipmapping is necessary and
|
|
|
|
* potentially migrate the texture from an atlas.
|
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* 2) allow setting of transient primitive-flags on a pipeline
|
2010-06-04 16:06:32 +00:00
|
|
|
* that may affect the outcome of _update_storage(). One flag
|
|
|
|
* could indicate that we expect to sample beyond the bounds of
|
|
|
|
* the texture border.
|
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* flags = COGL_PIPELINE_PRIMITIVE_FLAG_VALID_BORDERS;
|
|
|
|
* _cogl_pipeline_layer_assert_primitive_flags (layer, flags)
|
|
|
|
* _cogl_pipeline_layer_update_storage (layer)
|
2010-06-04 16:06:32 +00:00
|
|
|
* enqueue primitive in journal
|
|
|
|
*
|
|
|
|
* when the primitive is dequeued and drawn we should:
|
2010-10-27 17:54:57 +00:00
|
|
|
* _cogl_pipeline_flush_gl_state (pipeline)
|
2010-06-04 16:06:32 +00:00
|
|
|
* draw primitive
|
2010-10-27 17:54:57 +00:00
|
|
|
* _cogl_pipeline_unassert_primitive_flags (layer, flags);
|
2010-06-04 16:06:32 +00:00
|
|
|
*
|
2010-10-27 17:54:57 +00:00
|
|
|
* _cogl_pipeline_layer_update_storage should take into
|
2010-06-04 16:06:32 +00:00
|
|
|
* consideration all the asserted primitive requirements. (E.g.
|
|
|
|
* there could be multiple primitives in the journal - or in a
|
|
|
|
* renderlist in the future - that need mipmaps or that need
|
|
|
|
* valid contents beyond their borders (for cogl_polygon)
|
|
|
|
* meaning they can't work with textures in an atas, so
|
2010-10-27 17:54:57 +00:00
|
|
|
* _cogl_pipeline_layer_update_storage would pass on these
|
2010-06-04 16:06:32 +00:00
|
|
|
* requirements to the texture atlas backend which would make
|
|
|
|
* sure the referenced texture is migrated out of the atlas and
|
|
|
|
* mipmaps are generated.)
|
|
|
|
*/
|
2010-10-27 17:54:57 +00:00
|
|
|
_cogl_pipeline_layer_pre_paint (layer);
|
2010-01-14 17:57:43 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
tex_handle = _cogl_pipeline_layer_get_texture (layer);
|
2009-06-19 11:15:12 +00:00
|
|
|
|
|
|
|
/* COGL_INVALID_HANDLE textures are handled by
|
2010-10-27 17:54:57 +00:00
|
|
|
* _cogl_pipeline_flush_gl_state */
|
2009-06-19 11:15:12 +00:00
|
|
|
if (tex_handle == COGL_INVALID_HANDLE)
|
|
|
|
continue;
|
|
|
|
|
2009-03-23 12:29:15 +00:00
|
|
|
/* XXX:
|
|
|
|
* For now, if the first layer is sliced then all other layers are
|
|
|
|
* ignored since we currently don't support multi-texturing with
|
|
|
|
* sliced textures. If the first layer is not sliced then any other
|
|
|
|
* layers found to be sliced will be skipped. (with a warning)
|
|
|
|
*
|
|
|
|
* TODO: Add support for multi-texturing rectangles with sliced
|
|
|
|
* textures if no texture matrices are in use.
|
|
|
|
*/
|
|
|
|
if (cogl_texture_is_sliced (tex_handle))
|
|
|
|
{
|
|
|
|
if (i == 0)
|
|
|
|
{
|
[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 17:46:42 +00:00
|
|
|
fallback_layers = ~1; /* fallback all except the first layer */
|
2009-03-23 12:29:15 +00:00
|
|
|
all_use_sliced_quad_fallback = TRUE;
|
|
|
|
if (tmp->next)
|
|
|
|
{
|
|
|
|
static gboolean warning_seen = FALSE;
|
|
|
|
if (!warning_seen)
|
2010-10-27 17:54:57 +00:00
|
|
|
g_warning ("Skipping layers 1..n of your pipeline since "
|
2009-03-23 12:29:15 +00:00
|
|
|
"the first layer is sliced. We don't currently "
|
|
|
|
"support any multi-texturing with sliced "
|
|
|
|
"textures but assume layer 0 is the most "
|
|
|
|
"important to keep");
|
|
|
|
warning_seen = TRUE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
static gboolean warning_seen = FALSE;
|
|
|
|
if (!warning_seen)
|
2010-10-27 17:54:57 +00:00
|
|
|
g_warning ("Skipping layer %d of your pipeline consisting of "
|
2009-03-23 12:29:15 +00:00
|
|
|
"a sliced texture (unsuported for multi texturing)",
|
|
|
|
i);
|
|
|
|
warning_seen = TRUE;
|
|
|
|
|
|
|
|
/* NB: marking for fallback will replace the layer with
|
|
|
|
* a default transparent texture */
|
[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 17:46:42 +00:00
|
|
|
fallback_layers |= (1 << i);
|
2009-03-23 12:29:15 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-16 10:56:17 +00:00
|
|
|
/* If the texture can't be repeated with the GPU (e.g. because it has
|
|
|
|
* waste or if using GL_TEXTURE_RECTANGLE_ARB) then we don't support
|
|
|
|
* multi texturing since we don't know if the result will end up trying
|
|
|
|
* to texture from the waste area. */
|
2010-10-27 17:54:57 +00:00
|
|
|
if (_cogl_pipeline_layer_has_user_matrix (layer)
|
2009-09-16 10:56:17 +00:00
|
|
|
&& !_cogl_texture_can_hardware_repeat (tex_handle))
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
|
|
|
static gboolean warning_seen = FALSE;
|
|
|
|
if (!warning_seen)
|
2010-10-27 17:54:57 +00:00
|
|
|
g_warning ("Skipping layer %d of your pipeline since a custom "
|
2009-09-16 10:56:17 +00:00
|
|
|
"texture matrix was given for a texture that can't be "
|
|
|
|
"repeated using the GPU and the result may try to "
|
|
|
|
"sample beyond the bounds of the texture ",
|
|
|
|
i);
|
2009-03-23 12:29:15 +00:00
|
|
|
warning_seen = TRUE;
|
|
|
|
|
|
|
|
/* NB: marking for fallback will replace the layer with
|
|
|
|
* a default transparent texture */
|
[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 17:46:42 +00:00
|
|
|
fallback_layers |= (1 << i);
|
2009-03-23 12:29:15 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Emit geometry for each of the rectangles...
|
|
|
|
*/
|
|
|
|
|
|
|
|
for (i = 0; i < n_rects; i++)
|
|
|
|
{
|
2009-09-16 10:56:17 +00:00
|
|
|
CoglHandle first_layer, tex_handle;
|
|
|
|
const float default_tex_coords[4] = {0.0, 0.0, 1.0, 1.0};
|
|
|
|
const float *tex_coords;
|
2010-04-01 10:31:33 +00:00
|
|
|
gboolean clamp_s, clamp_t;
|
2009-09-16 10:56:17 +00:00
|
|
|
|
|
|
|
if (!all_use_sliced_quad_fallback)
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
2009-09-16 10:56:17 +00:00
|
|
|
gboolean success =
|
2010-02-11 15:33:01 +00:00
|
|
|
_cogl_multitexture_quad_single_primitive (rects[i].position,
|
2010-10-27 17:54:57 +00:00
|
|
|
pipeline,
|
2009-09-16 10:56:17 +00:00
|
|
|
fallback_layers,
|
|
|
|
rects[i].tex_coords,
|
|
|
|
rects[i].tex_coords_len);
|
|
|
|
|
|
|
|
/* NB: If _cogl_multitexture_quad_single_primitive fails then it
|
|
|
|
* means the user tried to use texture repeat with a texture that
|
|
|
|
* can't be repeated by the GPU (e.g. due to waste or use of
|
|
|
|
* GL_TEXTURE_RECTANGLE_ARB) */
|
|
|
|
if (success)
|
|
|
|
continue;
|
2009-03-23 12:29:15 +00:00
|
|
|
}
|
2009-09-16 10:56:17 +00:00
|
|
|
|
|
|
|
/* If multitexturing failed or we are drawing with a sliced texture
|
|
|
|
* then we only support a single layer so we pluck out the texture
|
2010-10-27 17:54:57 +00:00
|
|
|
* from the first pipeline layer... */
|
|
|
|
layers = _cogl_pipeline_get_layers (pipeline);
|
2009-09-16 10:56:17 +00:00
|
|
|
first_layer = layers->data;
|
2010-10-27 17:54:57 +00:00
|
|
|
tex_handle = _cogl_pipeline_layer_get_texture (first_layer);
|
2009-09-16 10:56:17 +00:00
|
|
|
|
|
|
|
if (rects[i].tex_coords)
|
|
|
|
tex_coords = rects[i].tex_coords;
|
|
|
|
else
|
|
|
|
tex_coords = default_tex_coords;
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
clamp_s = (_cogl_pipeline_layer_get_wrap_mode_s (first_layer) ==
|
|
|
|
COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE);
|
|
|
|
clamp_t = (_cogl_pipeline_layer_get_wrap_mode_t (first_layer) ==
|
|
|
|
COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE);
|
2010-04-01 10:31:33 +00:00
|
|
|
|
|
|
|
COGL_NOTE (DRAW, "Drawing Tex Quad (Multi-Prim Mode)");
|
|
|
|
|
2009-09-16 10:56:17 +00:00
|
|
|
_cogl_texture_quad_multiple_primitives (tex_handle,
|
2010-10-27 17:54:57 +00:00
|
|
|
pipeline,
|
2010-04-01 10:31:33 +00:00
|
|
|
clamp_s, clamp_t,
|
2010-02-11 15:33:01 +00:00
|
|
|
rects[i].position,
|
2009-09-16 10:56:17 +00:00
|
|
|
tex_coords[0],
|
|
|
|
tex_coords[1],
|
|
|
|
tex_coords[2],
|
|
|
|
tex_coords[3]);
|
2009-03-23 12:29:15 +00:00
|
|
|
}
|
|
|
|
|
[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 17:46:42 +00:00
|
|
|
#if 0
|
|
|
|
/* XXX: The current journal doesn't handle changes to the model view matrix
|
|
|
|
* so for now we force a flush at the end of every primitive. */
|
2009-03-23 12:29:15 +00:00
|
|
|
_cogl_journal_flush ();
|
[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 17:46:42 +00:00
|
|
|
#endif
|
2009-03-23 12:29:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
cogl_rectangles (const float *verts,
|
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-10 01:57:32 +00:00
|
|
|
unsigned int n_rects)
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
2009-06-16 20:29:21 +00:00
|
|
|
struct _CoglMutiTexturedRect *rects;
|
2009-03-23 12:29:15 +00:00
|
|
|
int i;
|
|
|
|
|
2010-02-11 15:33:01 +00:00
|
|
|
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
|
|
|
|
* _CoglMutiTexturedRect rectangles and pass these on to our work horse;
|
|
|
|
* _cogl_rectangles_with_multitexture_coords.
|
|
|
|
*/
|
|
|
|
|
2009-06-16 20:29:21 +00:00
|
|
|
rects = g_alloca (n_rects * sizeof (struct _CoglMutiTexturedRect));
|
|
|
|
|
2009-03-23 12:29:15 +00:00
|
|
|
for (i = 0; i < n_rects; i++)
|
|
|
|
{
|
2010-02-11 15:33:01 +00:00
|
|
|
rects[i].position = &verts[i * 4];
|
2009-03-23 12:29:15 +00:00
|
|
|
rects[i].tex_coords = NULL;
|
|
|
|
rects[i].tex_coords_len = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
_cogl_rectangles_with_multitexture_coords (rects, n_rects);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
cogl_rectangles_with_texture_coords (const float *verts,
|
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-10 01:57:32 +00:00
|
|
|
unsigned int n_rects)
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
2009-06-16 20:29:21 +00:00
|
|
|
struct _CoglMutiTexturedRect *rects;
|
2009-03-23 12:29:15 +00:00
|
|
|
int i;
|
|
|
|
|
2010-02-11 15:33:01 +00:00
|
|
|
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
|
|
|
|
* _CoglMutiTexturedRect rectangles and pass these on to our work horse;
|
|
|
|
* _cogl_rectangles_with_multitexture_coords.
|
|
|
|
*/
|
|
|
|
|
2009-06-16 20:29:21 +00:00
|
|
|
rects = g_alloca (n_rects * sizeof (struct _CoglMutiTexturedRect));
|
|
|
|
|
2009-03-23 12:29:15 +00:00
|
|
|
for (i = 0; i < n_rects; i++)
|
|
|
|
{
|
2010-02-11 15:33:01 +00:00
|
|
|
rects[i].position = &verts[i * 8];
|
2009-03-23 12:29:15 +00:00
|
|
|
rects[i].tex_coords = &verts[i * 8 + 4];
|
|
|
|
rects[i].tex_coords_len = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
_cogl_rectangles_with_multitexture_coords (rects, n_rects);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
cogl_rectangle_with_texture_coords (float x_1,
|
|
|
|
float y_1,
|
|
|
|
float x_2,
|
|
|
|
float y_2,
|
|
|
|
float tx_1,
|
|
|
|
float ty_1,
|
|
|
|
float tx_2,
|
|
|
|
float ty_2)
|
|
|
|
{
|
2010-02-11 15:33:01 +00:00
|
|
|
const float position[4] = {x_1, y_1, x_2, y_2};
|
|
|
|
const float tex_coords[4] = {tx_1, ty_1, tx_2, ty_2};
|
|
|
|
struct _CoglMutiTexturedRect rect;
|
|
|
|
|
|
|
|
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
|
|
|
|
* _CoglMutiTexturedRect rectangles and pass these on to our work horse;
|
|
|
|
* _cogl_rectangles_with_multitexture_coords.
|
|
|
|
*/
|
|
|
|
|
|
|
|
rect.position = position;
|
|
|
|
rect.tex_coords = tex_coords;
|
|
|
|
rect.tex_coords_len = 4;
|
|
|
|
|
|
|
|
_cogl_rectangles_with_multitexture_coords (&rect, 1);
|
2009-03-23 12:29:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
cogl_rectangle_with_multitexture_coords (float x_1,
|
|
|
|
float y_1,
|
|
|
|
float x_2,
|
|
|
|
float y_2,
|
|
|
|
const float *user_tex_coords,
|
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-10 01:57:32 +00:00
|
|
|
int user_tex_coords_len)
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
2010-02-11 15:33:01 +00:00
|
|
|
const float position[4] = {x_1, y_1, x_2, y_2};
|
2009-03-23 12:29:15 +00:00
|
|
|
struct _CoglMutiTexturedRect rect;
|
|
|
|
|
2010-02-11 15:33:01 +00:00
|
|
|
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
|
|
|
|
* _CoglMutiTexturedRect rectangles and pass these on to our work horse;
|
|
|
|
* _cogl_rectangles_with_multitexture_coords.
|
|
|
|
*/
|
|
|
|
|
|
|
|
rect.position = position;
|
2009-03-23 12:29:15 +00:00
|
|
|
rect.tex_coords = user_tex_coords;
|
|
|
|
rect.tex_coords_len = user_tex_coords_len;
|
|
|
|
|
|
|
|
_cogl_rectangles_with_multitexture_coords (&rect, 1);
|
|
|
|
}
|
|
|
|
|
2008-05-05 12:01:19 +00:00
|
|
|
void
|
2009-01-29 13:31:11 +00:00
|
|
|
cogl_rectangle (float x_1,
|
|
|
|
float y_1,
|
|
|
|
float x_2,
|
|
|
|
float y_2)
|
2008-05-05 12:01:19 +00:00
|
|
|
{
|
2010-02-11 15:33:01 +00:00
|
|
|
const float position[4] = {x_1, y_1, x_2, y_2};
|
|
|
|
struct _CoglMutiTexturedRect rect;
|
|
|
|
|
|
|
|
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
|
|
|
|
* _CoglMutiTexturedRect rectangles and pass these on to our work horse;
|
|
|
|
* _cogl_rectangles_with_multitexture_coords.
|
|
|
|
*/
|
|
|
|
|
|
|
|
rect.position = position;
|
|
|
|
rect.tex_coords = NULL;
|
|
|
|
rect.tex_coords_len = 0;
|
|
|
|
|
|
|
|
_cogl_rectangles_with_multitexture_coords (&rect, 1);
|
2008-05-05 12:01:19 +00:00
|
|
|
}
|
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
typedef struct _AppendTexCoordsState
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
2010-10-18 16:17:22 +00:00
|
|
|
const CoglTextureVertex *vertices_in;
|
|
|
|
int vertex;
|
|
|
|
int layer;
|
|
|
|
float *vertices_out;
|
|
|
|
} AppendTexCoordsState;
|
|
|
|
|
|
|
|
gboolean
|
2010-10-27 17:54:57 +00:00
|
|
|
append_tex_coord_attributes_cb (CoglPipeline *pipeline,
|
2010-10-18 16:17:22 +00:00
|
|
|
int layer_index,
|
|
|
|
void *user_data)
|
|
|
|
{
|
|
|
|
AppendTexCoordsState *state = user_data;
|
|
|
|
CoglHandle tex_handle;
|
|
|
|
float tx, ty;
|
|
|
|
float *t;
|
2009-09-16 10:56:17 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
tx = state->vertices_in[state->vertex].tx;
|
|
|
|
ty = state->vertices_in[state->vertex].ty;
|
2009-09-16 10:56:17 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
/* COGL_INVALID_HANDLE textures will be handled in
|
2010-10-27 17:54:57 +00:00
|
|
|
* _cogl_pipeline_flush_layers_gl_state but there is no need to worry
|
2010-10-18 16:17:22 +00:00
|
|
|
* about scaling texture coordinates in this case */
|
2010-10-27 17:54:57 +00:00
|
|
|
tex_handle = _cogl_pipeline_get_layer_texture (pipeline, layer_index);
|
2010-10-18 16:17:22 +00:00
|
|
|
if (tex_handle != COGL_INVALID_HANDLE)
|
|
|
|
_cogl_texture_transform_coords_to_gl (tex_handle, &tx, &ty);
|
2009-09-16 10:56:17 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
/* NB: [X,Y,Z,TX,TY...,R,G,B,A,...] */
|
|
|
|
t = state->vertices_out + 3 + 2 * state->layer;
|
|
|
|
t[0] = tx;
|
|
|
|
t[1] = ty;
|
2010-10-25 12:25:21 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
state->layer++;
|
2010-05-18 21:42:49 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
2010-05-18 21:42:49 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
typedef struct _ValidateState
|
|
|
|
{
|
2010-10-27 17:54:57 +00:00
|
|
|
CoglPipeline *original_pipeline;
|
|
|
|
CoglPipeline *pipeline;
|
2010-10-18 16:17:22 +00:00
|
|
|
} ValidateState;
|
2009-09-16 10:56:17 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
gboolean
|
2010-10-27 17:54:57 +00:00
|
|
|
validate_layer_cb (CoglPipeline *pipeline,
|
2010-10-18 16:17:22 +00:00
|
|
|
int layer_index,
|
|
|
|
void *user_data)
|
|
|
|
{
|
|
|
|
ValidateState *state = user_data;
|
2010-04-01 10:31:33 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
/* By default COGL_PIPELINE_WRAP_MODE_AUTOMATIC becomes
|
2010-10-18 16:17:22 +00:00
|
|
|
* GL_CLAMP_TO_EDGE but we want the polygon API to use GL_REPEAT to
|
|
|
|
* maintain compatibility with previous releases
|
|
|
|
*/
|
2010-04-01 10:31:33 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
if (cogl_pipeline_get_layer_wrap_mode_s (pipeline, layer_index) ==
|
|
|
|
COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
|
2010-04-26 09:01:43 +00:00
|
|
|
{
|
2010-10-27 17:54:57 +00:00
|
|
|
if (state->original_pipeline == state->pipeline)
|
|
|
|
state->pipeline = cogl_pipeline_copy (pipeline);
|
2010-04-26 09:01:43 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
cogl_pipeline_set_layer_wrap_mode_s (state->pipeline, layer_index,
|
|
|
|
COGL_PIPELINE_WRAP_MODE_REPEAT);
|
2010-10-18 16:17:22 +00:00
|
|
|
}
|
2010-05-18 21:42:49 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
if (cogl_pipeline_get_layer_wrap_mode_t (pipeline, layer_index) ==
|
|
|
|
COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
|
2010-10-18 16:17:22 +00:00
|
|
|
{
|
2010-10-27 17:54:57 +00:00
|
|
|
if (state->original_pipeline == state->pipeline)
|
|
|
|
state->pipeline = cogl_pipeline_copy (pipeline);
|
2009-09-16 10:56:17 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
cogl_pipeline_set_layer_wrap_mode_t (state->pipeline, layer_index,
|
|
|
|
COGL_PIPELINE_WRAP_MODE_REPEAT);
|
2010-10-18 16:17:22 +00:00
|
|
|
}
|
2010-04-26 09:01:43 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
return TRUE;
|
2009-09-16 10:56:17 +00:00
|
|
|
}
|
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
void
|
|
|
|
cogl_polygon (const CoglTextureVertex *vertices,
|
|
|
|
unsigned int n_vertices,
|
|
|
|
gboolean use_color)
|
2009-09-16 10:56:17 +00:00
|
|
|
{
|
2010-10-27 17:54:57 +00:00
|
|
|
CoglPipeline *pipeline;
|
2010-10-18 16:17:22 +00:00
|
|
|
ValidateState validate_state;
|
|
|
|
int n_layers;
|
|
|
|
int n_attributes;
|
|
|
|
CoglVertexAttribute **attributes;
|
|
|
|
int i;
|
|
|
|
unsigned int stride;
|
|
|
|
gsize stride_bytes;
|
|
|
|
CoglVertexArray *vertex_array;
|
|
|
|
float *v;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
pipeline = cogl_get_source ();
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
validate_state.original_pipeline = pipeline;
|
|
|
|
validate_state.pipeline = pipeline;
|
|
|
|
cogl_pipeline_foreach_layer (pipeline,
|
2010-10-18 16:17:22 +00:00
|
|
|
validate_layer_cb,
|
|
|
|
&validate_state);
|
2010-10-27 17:54:57 +00:00
|
|
|
pipeline = validate_state.pipeline;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
n_layers = cogl_pipeline_get_n_layers (pipeline);
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
n_attributes = 1 + n_layers + (use_color ? 1 : 0);
|
|
|
|
attributes = g_alloca (sizeof (CoglVertexAttribute *) * (n_attributes + 1));
|
|
|
|
attributes[n_attributes] = NULL;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
/* Our data is arranged like:
|
|
|
|
* [X, Y, Z, TX0, TY0, TX1, TY1..., R, G, B, A,...] */
|
|
|
|
stride = 3 + (2 * n_layers) + (use_color ? 1 : 0);
|
|
|
|
stride_bytes = stride * sizeof (float);
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
/* Make sure there is enough space in the global vertex array. This
|
|
|
|
* is used so we can render the polygon with a single call to OpenGL
|
|
|
|
* but still support any number of vertices */
|
|
|
|
g_array_set_size (ctx->polygon_vertices, n_vertices * stride);
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
vertex_array = cogl_vertex_array_new (n_vertices * stride_bytes);
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
attributes[0] =
|
|
|
|
cogl_vertex_attribute_new (vertex_array,
|
|
|
|
"cogl_position_in",
|
|
|
|
stride_bytes,
|
|
|
|
0,
|
|
|
|
3,
|
|
|
|
COGL_VERTEX_ATTRIBUTE_TYPE_FLOAT);
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
for (i = 0; i < n_layers; i++)
|
|
|
|
{
|
|
|
|
const char *names[] = {
|
|
|
|
"cogl_tex_coord0_in",
|
|
|
|
"cogl_tex_coord1_in",
|
|
|
|
"cogl_tex_coord2_in",
|
|
|
|
"cogl_tex_coord3_in",
|
|
|
|
"cogl_tex_coord4_in",
|
|
|
|
"cogl_tex_coord5_in",
|
|
|
|
"cogl_tex_coord6_in",
|
|
|
|
"cogl_tex_coord7_in"
|
|
|
|
};
|
|
|
|
char *name = i < 8 ? (char *)names[i] :
|
|
|
|
g_strdup_printf ("cogl_tex_coord%d_in", i);
|
|
|
|
|
|
|
|
attributes[i + 1] =
|
|
|
|
cogl_vertex_attribute_new (vertex_array,
|
|
|
|
name,
|
|
|
|
stride_bytes,
|
|
|
|
/* NB: [X,Y,Z,TX,TY...,R,G,B,A,...] */
|
|
|
|
12 + 8 * i,
|
|
|
|
2,
|
|
|
|
COGL_VERTEX_ATTRIBUTE_TYPE_FLOAT);
|
|
|
|
}
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
if (use_color)
|
|
|
|
{
|
|
|
|
attributes[n_attributes - 1] =
|
|
|
|
cogl_vertex_attribute_new (vertex_array,
|
|
|
|
"cogl_color_in",
|
|
|
|
stride_bytes,
|
|
|
|
/* NB: [X,Y,Z,TX,TY...,R,G,B,A,...] */
|
|
|
|
12 + 8 * n_layers,
|
|
|
|
4,
|
|
|
|
COGL_VERTEX_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
|
|
|
|
}
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
/* Convert the vertices into an array of float vertex attributes */
|
|
|
|
v = (float *)ctx->polygon_vertices->data;
|
|
|
|
for (i = 0; i < n_vertices; i++)
|
2009-03-23 12:29:15 +00:00
|
|
|
{
|
2010-10-18 16:17:22 +00:00
|
|
|
AppendTexCoordsState append_tex_coords_state;
|
2009-06-16 21:48:21 +00:00
|
|
|
guint8 *c;
|
2009-03-23 12:29:15 +00:00
|
|
|
|
|
|
|
/* NB: [X,Y,Z,TX,TY...,R,G,B,A,...] */
|
|
|
|
v[0] = vertices[i].x;
|
|
|
|
v[1] = vertices[i].y;
|
|
|
|
v[2] = vertices[i].z;
|
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
append_tex_coords_state.vertices_in = vertices;
|
|
|
|
append_tex_coords_state.vertex = i;
|
|
|
|
append_tex_coords_state.layer = 0;
|
|
|
|
append_tex_coords_state.vertices_out = v;
|
2010-10-27 17:54:57 +00:00
|
|
|
cogl_pipeline_foreach_layer (pipeline,
|
2010-10-18 16:17:22 +00:00
|
|
|
append_tex_coord_attributes_cb,
|
|
|
|
&append_tex_coords_state);
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2009-06-16 21:48:21 +00:00
|
|
|
if (use_color)
|
|
|
|
{
|
|
|
|
/* NB: [X,Y,Z,TX,TY...,R,G,B,A,...] */
|
|
|
|
c = (guint8 *) (v + 3 + 2 * n_layers);
|
|
|
|
c[0] = cogl_color_get_red_byte (&vertices[i].color);
|
|
|
|
c[1] = cogl_color_get_green_byte (&vertices[i].color);
|
|
|
|
c[2] = cogl_color_get_blue_byte (&vertices[i].color);
|
|
|
|
c[3] = cogl_color_get_alpha_byte (&vertices[i].color);
|
|
|
|
}
|
2010-04-26 09:01:43 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
v += stride;
|
2009-03-23 12:29:15 +00:00
|
|
|
}
|
2010-01-04 11:43:00 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
v = (float *)ctx->polygon_vertices->data;
|
|
|
|
cogl_buffer_set_data (COGL_BUFFER (vertex_array),
|
|
|
|
0,
|
|
|
|
(const guint8 *)v,
|
|
|
|
ctx->polygon_vertices->len * sizeof (float));
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-27 17:54:57 +00:00
|
|
|
cogl_push_source (pipeline);
|
2010-10-25 12:25:21 +00:00
|
|
|
|
2010-10-18 16:17:22 +00:00
|
|
|
cogl_draw_vertex_attributes_array (COGL_VERTICES_MODE_TRIANGLE_FAN,
|
|
|
|
0, n_vertices,
|
|
|
|
attributes);
|
2009-03-23 12:29:15 +00:00
|
|
|
|
2010-10-25 12:25:21 +00:00
|
|
|
cogl_pop_source ();
|
2009-03-23 12:29:15 +00:00
|
|
|
}
|
|
|
|
|