[Cogl] [PATCH] Adds cogl_framebuffer_draw_[*_]rectangle functions
Robert Bragg
robert at sixbynine.org
Mon Mar 19 14:09:36 PDT 2012
From: Robert Bragg <robert at linux.intel.com>
This adds experimental 2.0 api replacements for the cogl_rectangle[_*]
functions that don't depend on having a current pipeline set on the
context via cogl_{set,push}_source() or having a current framebuffer set
on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch
away from having a statefull context that affects drawing to having
framebuffer drawing apis that are explicitly passed a framebuffer and
pipeline.
---
cogl/cogl-framebuffer.c | 149 ++++++++++++
cogl/cogl-framebuffer.h | 312 ++++++++++++++++++++++++-
cogl/cogl-journal.c | 28 ++--
cogl/cogl-primitives-private.h | 15 ++
cogl/cogl-primitives.c | 109 +++++----
tests/conform/test-atlas-migration.c | 2 +-
tests/conform/test-backface-culling.c | 123 +++++-----
tests/conform/test-bitmask.c | 3 +-
tests/conform/test-blend-strings.c | 38 ++--
tests/conform/test-color-mask.c | 34 ++--
tests/conform/test-conform-main.c | 108 ++++-----
tests/conform/test-custom-attributes.c | 95 ++++----
tests/conform/test-depth-test.c | 79 ++++---
tests/conform/test-fixed.c | 2 +-
tests/conform/test-fixtures.c | 2 +-
tests/conform/test-just-vertex-shader.c | 45 ++--
tests/conform/test-materials.c | 2 +-
tests/conform/test-multitexture.c | 2 +-
tests/conform/test-npot-texture.c | 2 +-
tests/conform/test-object.c | 2 +-
tests/conform/test-offscreen.c | 38 ++--
tests/conform/test-path.c | 35 ++--
tests/conform/test-pipeline-uniforms.c | 35 +--
tests/conform/test-pipeline-user-matrix.c | 47 ++--
tests/conform/test-pixel-buffer.c | 38 ++--
tests/conform/test-point-size.c | 20 +-
tests/conform/test-point-sprite.c | 38 ++--
tests/conform/test-premult.c | 2 +-
tests/conform/test-primitive.c | 39 ++--
tests/conform/test-read-texture-formats.c | 6 +-
tests/conform/test-readpixels.c | 2 +-
tests/conform/test-snippets.c | 209 +++++++----------
tests/conform/test-sparse-pipeline.c | 26 +--
tests/conform/test-sub-texture.c | 77 ++++---
tests/conform/test-texture-3d.c | 52 ++---
tests/conform/test-texture-get-set-data.c | 2 +-
tests/conform/test-texture-mipmaps.c | 2 +-
tests/conform/test-texture-pixmap-x11.c | 2 +-
tests/conform/test-texture-rectangle.c | 2 +-
tests/conform/test-utils.c | 76 ++++---
tests/conform/test-utils.h | 43 ++--
tests/conform/test-vertex-buffer-contiguous.c | 2 +-
tests/conform/test-vertex-buffer-interleved.c | 2 +-
tests/conform/test-vertex-buffer-mutability.c | 2 +-
tests/conform/test-viewport.c | 2 +-
tests/conform/test-wrap-modes.c | 85 ++++----
tests/conform/test-write-texture-formats.c | 6 +-
47 files changed, 1243 insertions(+), 799 deletions(-)
diff --git a/cogl/cogl-framebuffer.c b/cogl/cogl-framebuffer.c
index 8cbee1d..2beea86 100644
--- a/cogl/cogl-framebuffer.c
+++ b/cogl/cogl-framebuffer.c
@@ -46,6 +46,7 @@
#include "cogl-offscreen.h"
#include "cogl1-context.h"
#include "cogl-private.h"
+#include "cogl-primitives-private.h"
#ifndef GL_FRAMEBUFFER
#define GL_FRAMEBUFFER 0x8D40
@@ -3244,3 +3245,151 @@ cogl_framebuffer_draw_primitive (CoglFramebuffer *framebuffer,
_cogl_framebuffer_draw_primitive (framebuffer, pipeline, primitive,
COGL_DRAW_SKIP_LEGACY_STATE);
}
+
+void
+cogl_framebuffer_draw_rectangle (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ float x_1,
+ float y_1,
+ float x_2,
+ float y_2)
+{
+ const float position[4] = {x_1, y_1, x_2, y_2};
+ CoglMultiTexturedRect rect;
+
+ /* XXX: All the _*_rectangle* APIs normalize their input into an array of
+ * _CoglMultiTexturedRect rectangles and pass these on to our work horse;
+ * _cogl_framebuffer_draw_multitextued_rectangles.
+ */
+
+ rect.position = position;
+ rect.tex_coords = NULL;
+ rect.tex_coords_len = 0;
+
+ _cogl_framebuffer_draw_multitextued_rectangles (framebuffer,
+ pipeline,
+ &rect,
+ 1,
+ TRUE);
+}
+
+void
+cogl_framebuffer_draw_textured_rectangle (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ float x_1,
+ float y_1,
+ float x_2,
+ float y_2,
+ float s_1,
+ float t_1,
+ float s_2,
+ float t_2)
+{
+ const float position[4] = {x_1, y_1, x_2, y_2};
+ const float tex_coords[4] = {s_1, t_1, s_2, t_2};
+ CoglMultiTexturedRect rect;
+
+ /* XXX: All the _*_rectangle* APIs normalize their input into an array of
+ * CoglMultiTexturedRect rectangles and pass these on to our work horse;
+ * _cogl_framebuffer_draw_multitextued_rectangles.
+ */
+
+ rect.position = position;
+ rect.tex_coords = tex_coords;
+ rect.tex_coords_len = 4;
+
+ _cogl_framebuffer_draw_multitextued_rectangles (framebuffer,
+ pipeline,
+ &rect,
+ 1,
+ TRUE);
+}
+
+void
+cogl_framebuffer_draw_multitextured_rectangle (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ float x_1,
+ float y_1,
+ float x_2,
+ float y_2,
+ const float *tex_coords,
+ int tex_coords_len)
+{
+ const float position[4] = {x_1, y_1, x_2, y_2};
+ CoglMultiTexturedRect rect;
+
+ /* XXX: All the _*_rectangle* APIs normalize their input into an array of
+ * CoglMultiTexturedRect rectangles and pass these on to our work horse;
+ * _cogl_framebuffer_draw_multitextued_rectangles.
+ */
+
+ rect.position = position;
+ rect.tex_coords = tex_coords;
+ rect.tex_coords_len = tex_coords_len;
+
+ _cogl_framebuffer_draw_multitextued_rectangles (framebuffer,
+ pipeline,
+ &rect,
+ 1,
+ TRUE);
+}
+
+void
+cogl_framebuffer_draw_rectangles (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ const float *coordinates,
+ unsigned int n_rectangles)
+{
+ CoglMultiTexturedRect *rects;
+ int i;
+
+ /* XXX: All the _*_rectangle* APIs normalize their input into an array of
+ * CoglMultiTexturedRect rectangles and pass these on to our work horse;
+ * _cogl_framebuffer_draw_multitextued_rectangles.
+ */
+
+ rects = g_alloca (n_rectangles * sizeof (CoglMultiTexturedRect));
+
+ for (i = 0; i < n_rectangles; i++)
+ {
+ rects[i].position = &coordinates[i * 4];
+ rects[i].tex_coords = NULL;
+ rects[i].tex_coords_len = 0;
+ }
+
+ _cogl_framebuffer_draw_multitextued_rectangles (framebuffer,
+ pipeline,
+ rects,
+ n_rectangles,
+ TRUE);
+}
+
+void
+cogl_framebuffer_draw_textured_rectangles (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ const float *coordinates,
+ unsigned int n_rectangles)
+{
+ CoglMultiTexturedRect *rects;
+ int i;
+
+ /* XXX: All the _*_rectangle* APIs normalize their input into an array of
+ * _CoglMultiTexturedRect rectangles and pass these on to our work horse;
+ * _cogl_framebuffer_draw_multitextued_rectangles.
+ */
+
+ rects = g_alloca (n_rectangles * sizeof (CoglMultiTexturedRect));
+
+ for (i = 0; i < n_rectangles; i++)
+ {
+ rects[i].position = &coordinates[i * 8];
+ rects[i].tex_coords = &coordinates[i * 8 + 4];
+ rects[i].tex_coords_len = 4;
+ }
+
+ _cogl_framebuffer_draw_multitextued_rectangles (framebuffer,
+ pipeline,
+ rects,
+ n_rectangles,
+ TRUE);
+}
diff --git a/cogl/cogl-framebuffer.h b/cogl/cogl-framebuffer.h
index 29ae356..a1e5ea3 100644
--- a/cogl/cogl-framebuffer.h
+++ b/cogl/cogl-framebuffer.h
@@ -990,7 +990,13 @@ cogl_framebuffer_clear4f (CoglFramebuffer *framebuffer,
* @primitive: A #CoglPrimitive geometry object
*
* Draws the given @primitive geometry to the specified destination
- * @framebuffer using the graphics processing pipeline described by @pipeline.
+ * @framebuffer using the graphics processing state described by @pipeline.
+ *
+ * This drawing api doesn't support high-level meta texture types such
+ * as #CoglTexture2DSliced so it is the user's responsability to
+ * ensure that only low-level textures that can be directly sampled by
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
+ * are associated with layers of the given @pipeline.
*
* <note>This api doesn't support any of the legacy global state options such
* as cogl_set_depth_test_enabled(), cogl_set_backface_culling_enabled() or
@@ -1025,6 +1031,12 @@ cogl_framebuffer_draw_primitive (CoglFramebuffer *framebuffer,
* be drawn, such as positions, colors and normals and should be %NULL
* terminated.
*
+ * This drawing api doesn't support high-level meta texture types such
+ * as #CoglTexture2DSliced so it is the user's responsability to
+ * ensure that only low-level textures that can be directly sampled by
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
+ * are associated with layers of the given @pipeline.
+ *
* Stability: unstable
* Since: 1.10
*/
@@ -1059,6 +1071,12 @@ cogl_framebuffer_vdraw_attributes (CoglFramebuffer *framebuffer,
* be drawn, such as positions, colors and normals and the number of attributes
* is given as @n_attributes.
*
+ * This drawing api doesn't support high-level meta texture types such
+ * as #CoglTexture2DSliced so it is the user's responsability to
+ * ensure that only low-level textures that can be directly sampled by
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
+ * are associated with layers of the given @pipeline.
+ *
* <note>This api doesn't support any of the legacy global state options such
* as cogl_set_depth_test_enabled(), cogl_set_backface_culling_enabled() or
* cogl_program_use()</note>
@@ -1107,8 +1125,8 @@ cogl_framebuffer_draw_attributes (CoglFramebuffer *framebuffer,
* multiple entries in the index array can refer back to a single
* shared vertex.
*
- * <note>The @indices array must at least be as long @first_vertex +
- * @n_vertices otherwise the GPU will overrun the indices array when
+ * <note>The @indices array must be at least as long as @first_vertex
+ * + @n_vertices otherwise the GPU will overrun the indices array when
* looking up vertex data.</note>
*
* Since it's very common to want to draw a run of rectangles using
@@ -1116,6 +1134,12 @@ cogl_framebuffer_draw_attributes (CoglFramebuffer *framebuffer,
* cogl_get_rectangle_indices() to get a set of indices that can be
* shared.
*
+ * This drawing api doesn't support high-level meta texture types such
+ * as #CoglTexture2DSliced so it is the user's responsability to
+ * ensure that only low-level textures that can be directly sampled by
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or
+ * #CoglTexture3D are associated with layers of the given @pipeline.
+ *
* <note>This api doesn't support any of the legacy global state
* options such as cogl_set_depth_test_enabled(),
* cogl_set_backface_culling_enabled() or cogl_program_use()</note>
@@ -1166,8 +1190,8 @@ cogl_framebuffer_vdraw_indexed_attributes (CoglFramebuffer *framebuffer,
* multiple entries in the index array can refer back to a single
* shared vertex.
*
- * <note>The @indices array must at least be as long @first_vertex +
- * @n_vertices otherwise the GPU will overrun the indices array when
+ * <note>The @indices array must be at least as long as @first_vertex
+ * + @n_vertices otherwise the GPU will overrun the indices array when
* looking up vertex data.</note>
*
* Since it's very common to want to draw a run of rectangles using
@@ -1175,6 +1199,12 @@ cogl_framebuffer_vdraw_indexed_attributes (CoglFramebuffer *framebuffer,
* cogl_get_rectangle_indices() to get a set of indices that can be
* shared.
*
+ * This drawing api doesn't support high-level meta texture types such
+ * as #CoglTexture2DSliced so it is the user's responsability to
+ * ensure that only low-level textures that can be directly sampled by
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or
+ * #CoglTexture3D are associated with layers of the given @pipeline.
+ *
* <note>This api doesn't support any of the legacy global state
* options such as cogl_set_depth_test_enabled(),
* cogl_set_backface_culling_enabled() or cogl_program_use()</note>
@@ -1192,6 +1222,278 @@ cogl_framebuffer_draw_indexed_attributes (CoglFramebuffer *framebuffer,
CoglAttribute **attributes,
int n_attributes);
+/**
+ * cogl_framebuffer_draw_rectangle:
+ * @framebuffer: A destination #CoglFramebuffer
+ * @pipeline: A #CoglPipeline state object
+ * @x_1: X coordinate of the top-left corner
+ * @y_1: Y coordinate of the top-left corner
+ * @x_2: X coordinate of the bottom-right corner
+ * @y_2: Y coordinate of the bottom-right corner
+ *
+ * Draws a rectangle to @framebuffer with the given @pipeline state
+ * and with the top left corner positioned at (@x_1, @y_1) and the
+ * bottom right corner positioned at (@x_2, @y_2).
+ *
+ * <note>The position is the position before the rectangle has been
+ * transformed by the model-view matrix and the projection
+ * matrix.</note>
+ *
+ * <note>If you want to describe a rectangle with a texture mapped on
+ * it then you can use
+ * cogl_framebuffer_draw_textured_rectangle().<note>
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+void
+cogl_framebuffer_draw_rectangle (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ float x_1,
+ float y_1,
+ float x_2,
+ float y_2);
+
+/**
+ * cogl_framebuffer_draw_textured_rectangle:
+ * @framebuffer: A destination #CoglFramebuffer
+ * @pipeline: A #CoglPipeline state object
+ * @x_1: x coordinate upper left on screen.
+ * @y_1: y coordinate upper left on screen.
+ * @x_2: x coordinate lower right on screen.
+ * @y_2: y coordinate lower right on screen.
+ * @s_1: S texture coordinate of the top-left coorner
+ * @t_1: T texture coordinate of the top-left coorner
+ * @s_2: S texture coordinate of the bottom-right coorner
+ * @t_2: T texture coordinate of the bottom-right coorner
+ *
+ * Draws a textured rectangle to @framebuffer using the given
+ * @pipeline state with the top left corner positioned at (@x_1, @y_1)
+ * and the bottom right corner positioned at (@x_2, @y_2). The top
+ * left corner will have texture coordinates of (@s_1, @t_1) and the
+ * bottom right corner will have texture coordinates of (@s_2, @t_2).
+ *
+ * <note>The position is the position before the rectangle has been
+ * transformed by the model-view matrix and the projection
+ * matrix.</note>
+ *
+ * This is a high level drawing api that can handle any kind of
+ * #CoglMetaTexture texture such as #CoglTexture2DSliced textures
+ * which may internally be comprised of multiple low-level textures.
+ * This is unlike low-level drawing apis such as
+ * cogl_framebuffer_draw_primitive() or
+ * cogl_framebuffer_draw_attributes() which only support low level
+ * texture types that are directly supported by GPUs such as
+ * #CoglTexture2D.
+ *
+ * <note>The given texture coordinates will only be used for the first
+ * texture layer of the pipeline and if your pipeline has more than
+ * one layer then all other layers will have default texture
+ * coordinates of @s_1=0.0 @t_1=0.0 @s_2=1.0 @t_2=1.0 </note>
+ *
+ * The given texture coordinates should always be normalized such that
+ * (0, 0) corresponds to the top left and (1, 1) corresponds to the
+ * bottom right. To map an entire texture accross the rectangle pass
+ * in @s_1=%0, @t_1=%0, @s_2=%1, @t_2=%1.
+ *
+ * <note>Even if you have associated a #CoglTextureRectangle texture
+ * with one of your @pipeline layers which normally implies working
+ * with non-normalized texture coordinates this api should still be
+ * passed normalized texture coordinates.</note>
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+void
+cogl_framebuffer_draw_textured_rectangle (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ float x_1,
+ float y_1,
+ float x_2,
+ float y_2,
+ float s_1,
+ float t_1,
+ float s_2,
+ float t_2);
+
+/**
+ * cogl_framebuffer_draw_multitextured_rectangle:
+ * @framebuffer: A destination #CoglFramebuffer
+ * @pipeline: A #CoglPipeline state object
+ * @x_1: x coordinate upper left on screen.
+ * @y_1: y coordinate upper left on screen.
+ * @x_2: x coordinate lower right on screen.
+ * @y_2: y coordinate lower right on screen.
+ * @tex_coords: (in) (array) (transfer none): An array containing groups of
+ * 4 float values: [s_1, t_1, s_2, t_2] that are interpreted as two texture
+ * coordinates; one for the top left texel, and one for the bottom right
+ * texel. Each value should be between 0.0 and 1.0, where the coordinate
+ * (0.0, 0.0) represents the top left of the texture, and (1.0, 1.0) the
+ * bottom right.
+ * @tex_coords_len: The length of the @tex_coords array. (For one layer
+ * and one group of texture coordinates, this would be 4)
+ *
+ * Draws a textured rectangle to @framebuffer with the given @pipeline
+ * state with the top left corner positioned at (@x_1, @y_1) and the
+ * bottom right corner positioned at (@x_2, @y_2). As a pipeline may
+ * contain multiple texture layers this interface lets you supply
+ * texture coordinates for each layer of the pipeline.
+ *
+ * <note>The position is the position before the rectangle has been
+ * transformed by the model-view matrix and the projection
+ * matrix.</note>
+ *
+ * This is a high level drawing api that can handle any kind of
+ * #CoglMetaTexture texture for the first layer such as
+ * #CoglTexture2DSliced textures which may internally be comprised of
+ * multiple low-level textures. This is unlike low-level drawing apis
+ * such as cogl_framebuffer_draw_primitive() or
+ * cogl_framebuffer_draw_attributes() which only support low level
+ * texture types that are directly supported by GPUs such as
+ * #CoglTexture2D.
+ *
+ * <note>This api can not currently handle multiple high-level meta
+ * texture layers. The first layer may be a high level meta texture
+ * such as #CoglTexture2DSliced but all other layers much be low
+ * level textures such as #CoglTexture2D and additionally they
+ * should be textures that can be sampled using normalized coordinates
+ * (so not #CoglTextureRectangle textures).</note>
+ *
+ * The top left texture coordinate for layer 0 of any pipeline will be
+ * (tex_coords[0], tex_coords[1]) and the bottom right coordinate will
+ * be (tex_coords[2], tex_coords[3]). The coordinates for layer 1
+ * would be (tex_coords[4], tex_coords[5]) (tex_coords[6],
+ * tex_coords[7]) and so on...
+ *
+ * The given texture coordinates should always be normalized such that
+ * (0, 0) corresponds to the top left and (1, 1) corresponds to the
+ * bottom right. To map an entire texture accross the rectangle pass
+ * in tex_coords[0]=%0, tex_coords[1]=%0, tex_coords[2]=%1,
+ * tex_coords[3]=%1.
+ *
+ * <note>Even if you have associated a #CoglTextureRectangle texture
+ * which normally implies working with non-normalized texture
+ * coordinates this api should still be passed normalized texture
+ * coordinates.</note>
+ *
+ * The first pair of coordinates are for the first layer (with the
+ * smallest layer index) and if you supply less texture coordinates
+ * than there are layers in the current source material then default
+ * texture coordinates (0.0, 0.0, 1.0, 1.0) are generated.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+void
+cogl_framebuffer_draw_multitextured_rectangle (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ float x_1,
+ float y_1,
+ float x_2,
+ float y_2,
+ const float *tex_coords,
+ int tex_coords_len);
+
+/**
+ * cogl_framebuffer_draw_rectangles:
+ * @framebuffer: A destination #CoglFramebuffer
+ * @pipeline: A #CoglPipeline state object
+ * @coordinates: (in) (array) (transfer none): an array of coordinates
+ * containing groups of 4 float values: [x_1, y_1, x_2, y_2] that are
+ * interpreted as two position coordinates; one for the top left of
+ * the rectangle (x1, y1), and one for the bottom right of the
+ * rectangle (x2, y2).
+ * @n_rectangles: number of rectangles defined in @coordinates.
+ *
+ * Draws a series of rectangles to @framebuffer with the given
+ * @pipeline state in the same way that
+ * cogl_framebuffer_draw_rectangle() does.
+ *
+ * The top left corner of the first rectangle is positioned at
+ * (coordinates[0], coordinates[1]) and the bottom right corner is
+ * positioned at (coordinates[2], coordinates[3]). The positions for
+ * the second rectangle are (coordinates[4], coordinates[5]) and
+ * (coordinates[6], coordinates[7]) and so on...
+ *
+ * <note>The position is the position before the rectangle has been
+ * transformed by the model-view matrix and the projection
+ * matrix.</note>
+ *
+ * As a general rule for better performance its recommended to use
+ * this this API instead of calling
+ * cogl_framebuffer_draw_textured_rectangle() separately for multiple
+ * rectangles if all of the rectangles will be drawn together with the
+ * same @pipeline state.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+void
+cogl_framebuffer_draw_rectangles (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ const float *verts,
+ unsigned int n_rects);
+
+/**
+ * cogl_framebuffer_draw_textured_rectangles:
+ * @framebuffer: A destination #CoglFramebuffer
+ * @pipeline: A #CoglPipeline state object
+ * @coordinates: (in) (array) (transfer none): an array containing
+ * groups of 8 float values: [x_1, y_1, x_2, y_2, s_1, t_1, s_2, t_2]
+ * that have the same meaning as the arguments for
+ * cogl_framebuffer_draw_textured_rectangle().
+ * @n_rectangles: number of rectangles to @coordinates to draw
+ *
+ * Draws a series of rectangles to @framebuffer with the given
+ * @pipeline state in the same way that
+ * cogl_framebuffer_draw_textured_rectangle() does.
+ *
+ * <note>The position is the position before the rectangle has been
+ * transformed by the model-view matrix and the projection
+ * matrix.</note>
+ *
+ * This is a high level drawing api that can handle any kind of
+ * #CoglMetaTexture texture such as #CoglTexture2DSliced textures
+ * which may internally be comprised of multiple low-level textures.
+ * This is unlike low-level drawing apis such as
+ * cogl_framebuffer_draw_primitive() or
+ * cogl_framebuffer_draw_attributes() which only support low level
+ * texture types that are directly supported by GPUs such as
+ * #CoglTexture2D.
+ *
+ * The top left corner of the first rectangle is positioned at
+ * (coordinates[0], coordinates[1]) and the bottom right corner is
+ * positioned at (coordinates[2], coordinates[3]). The top left
+ * texture coordinate is (coordinates[4], coordinates[5]) and the
+ * bottom right texture coordinate is (coordinates[6],
+ * coordinates[7]). The coordinates for subsequent rectangles
+ * are defined similarly by the subsequent coordinates.
+ *
+ * As a general rule for better performance its recommended to use
+ * this this API instead of calling
+ * cogl_framebuffer_draw_textured_rectangle() separately for multiple
+ * rectangles if all of the rectangles will be drawn together with the
+ * same @pipeline state.
+ *
+ * The given texture coordinates should always be normalized such that
+ * (0, 0) corresponds to the top left and (1, 1) corresponds to the
+ * bottom right. To map an entire texture accross the rectangle pass
+ * in tex_coords[0]=%0, tex_coords[1]=%0, tex_coords[2]=%1,
+ * tex_coords[3]=%1.
+ *
+ * <note>Even if you have associated a #CoglTextureRectangle texture
+ * which normally implies working with non-normalized texture
+ * coordinates this api should still be passed normalized texture
+ * coordinates.</note>
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+void
+cogl_framebuffer_draw_textured_rectangles (CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ const float *coordinates,
+ unsigned int n_rectangles);
/* XXX: Should we take an n_buffers + buffer id array instead of using
* the CoglBufferBits type which doesn't seem future proof? */
diff --git a/cogl/cogl-journal.c b/cogl/cogl-journal.c
index 8670471..7b7a3e9 100644
--- a/cogl/cogl-journal.c
+++ b/cogl/cogl-journal.c
@@ -1491,15 +1491,16 @@ _cogl_journal_log_quad (CoglJournal *journal,
const float *tex_coords,
unsigned int tex_coords_len)
{
- gsize stride;
- int next_vert;
- float *v;
- int i;
- int next_entry;
- guint32 disable_layers;
+ CoglFramebuffer *framebuffer = journal->framebuffer;
+ gsize stride;
+ int next_vert;
+ float *v;
+ int i;
+ int next_entry;
+ guint32 disable_layers;
CoglJournalEntry *entry;
- CoglPipeline *final_pipeline;
- CoglClipStack *clip_stack;
+ CoglPipeline *final_pipeline;
+ CoglClipStack *clip_stack;
CoglPipelineFlushOptions flush_options;
COGL_STATIC_TIMER (log_timer,
"Mainloop", /* parent */
@@ -1507,15 +1508,13 @@ _cogl_journal_log_quad (CoglJournal *journal,
"The time spent logging in the Cogl journal",
0 /* no application private data */);
- _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
COGL_TIMER_START (_cogl_uprof_context, log_timer);
/* If the framebuffer was previously empty then we'll take a
reference to the current framebuffer. This reference will be
removed when the journal is flushed */
if (journal->vertices->len == 0)
- cogl_object_ref (journal->framebuffer);
+ cogl_object_ref (framebuffer);
/* The vertex data is logged into a separate array. The data needs
to be copied into a vertex array before it's given to GL so we
@@ -1594,17 +1593,18 @@ _cogl_journal_log_quad (CoglJournal *journal,
entry->pipeline = _cogl_pipeline_journal_ref (final_pipeline);
- clip_stack = _cogl_framebuffer_get_clip_stack (journal->framebuffer);
+ clip_stack = _cogl_framebuffer_get_clip_stack (framebuffer);
entry->clip_stack = _cogl_clip_stack_ref (clip_stack);
if (G_UNLIKELY (final_pipeline != pipeline))
cogl_handle_unref (final_pipeline);
- cogl_get_modelview_matrix (&entry->model_view);
+ cogl_framebuffer_get_modelview_matrix (framebuffer,
+ &entry->model_view);
_cogl_pipeline_foreach_layer_internal (pipeline,
add_framebuffer_deps_cb,
- journal->framebuffer);
+ framebuffer);
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_BATCHING)))
_cogl_journal_flush (journal);
diff --git a/cogl/cogl-primitives-private.h b/cogl/cogl-primitives-private.h
index 4933396..2f09da5 100644
--- a/cogl/cogl-primitives-private.h
+++ b/cogl/cogl-primitives-private.h
@@ -40,6 +40,21 @@ _cogl_rectangle_immediate (CoglFramebuffer *framebuffer,
float x_2,
float y_2);
+typedef struct _CoglMultiTexturedRect
+{
+ 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? */
+} CoglMultiTexturedRect;
+
+void
+_cogl_framebuffer_draw_multitextued_rectangles (
+ CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ CoglMultiTexturedRect *rects,
+ int n_rects,
+ gboolean disable_legacy_state);
+
G_END_DECLS
#endif /* __COGL_PRIMITIVES_PRIVATE_H */
diff --git a/cogl/cogl-primitives.c b/cogl/cogl-primitives.c
index d17051d..903efbd 100644
--- a/cogl/cogl-primitives.c
+++ b/cogl/cogl-primitives.c
@@ -48,6 +48,7 @@
typedef struct _TextureSlicedQuadState
{
+ CoglFramebuffer *framebuffer;
CoglPipeline *pipeline;
CoglTexture *main_texture;
float tex_virtual_origin_x;
@@ -77,7 +78,7 @@ log_quad_sub_textures_cb (CoglTexture *texture,
void *user_data)
{
TextureSlicedQuadState *state = user_data;
- CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
+ CoglFramebuffer *framebuffer = state->framebuffer;
CoglTexture *texture_override;
float quad_coords[4];
@@ -189,8 +190,9 @@ validate_first_layer_cb (CoglPipeline *pipeline,
*/
/* TODO: support multitexturing */
static void
-_cogl_texture_quad_multiple_primitives (CoglTexture *texture,
+_cogl_texture_quad_multiple_primitives (CoglFramebuffer *framebuffer,
CoglPipeline *pipeline,
+ CoglTexture *texture,
int layer_index,
const float *position,
float tx_1,
@@ -206,8 +208,6 @@ _cogl_texture_quad_multiple_primitives (CoglTexture *texture,
ValidateFirstLayerState validate_first_layer_state;
CoglPipelineWrapMode wrap_s, wrap_t;
- _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
wrap_s = cogl_pipeline_get_layer_wrap_mode_s (pipeline, layer_index);
wrap_t = cogl_pipeline_get_layer_wrap_mode_t (pipeline, layer_index);
@@ -216,6 +216,7 @@ _cogl_texture_quad_multiple_primitives (CoglTexture *texture,
validate_first_layer_cb,
&validate_first_layer_state);
+ state.framebuffer = framebuffer;
state.main_texture = texture;
if (validate_first_layer_state.override_pipeline)
@@ -431,17 +432,15 @@ validate_tex_coords_cb (CoglPipeline *pipeline,
* require repeating.
*/
static gboolean
-_cogl_multitexture_quad_single_primitive (const float *position,
+_cogl_multitexture_quad_single_primitive (CoglFramebuffer *framebuffer,
CoglPipeline *pipeline,
+ const float *position,
const float *user_tex_coords,
- int user_tex_coords_len)
+ int user_tex_coords_len)
{
int n_layers = cogl_pipeline_get_n_layers (pipeline);
ValidateTexCoordsState state;
float *final_tex_coords = alloca (sizeof (float) * 4 * n_layers);
- CoglFramebuffer *framebuffer;
-
- _COGL_GET_CONTEXT (ctx, FALSE);
state.i = -1;
state.n_layers = n_layers;
@@ -461,7 +460,6 @@ _cogl_multitexture_quad_single_primitive (const float *position,
if (state.override_pipeline)
pipeline = state.override_pipeline;
- framebuffer = cogl_get_draw_framebuffer ();
_cogl_journal_log_quad (framebuffer->journal,
position,
pipeline,
@@ -478,6 +476,7 @@ _cogl_multitexture_quad_single_primitive (const float *position,
typedef struct _ValidateLayerState
{
+ CoglContext *ctx;
int i;
int first_layer;
CoglPipeline *override_source;
@@ -585,8 +584,6 @@ _cogl_rectangles_validate_layer_cb (CoglPipeline *pipeline,
static gboolean warning_seen = FALSE;
CoglTexture2D *tex_2d;
- _COGL_GET_CONTEXT (ctx, FALSE);
-
if (!warning_seen)
g_warning ("Skipping layer %d of your pipeline consisting of "
"a sliced texture (unsuported for multi texturing)",
@@ -594,7 +591,7 @@ _cogl_rectangles_validate_layer_cb (CoglPipeline *pipeline,
warning_seen = TRUE;
/* Note: currently only 2D textures can be sliced. */
- tex_2d = ctx->default_gl_texture_2d_tex;
+ tex_2d = state->ctx->default_gl_texture_2d_tex;
cogl_pipeline_set_layer_texture (pipeline, layer_index,
COGL_TEXTURE (tex_2d));
return TRUE;
@@ -629,29 +626,25 @@ _cogl_rectangles_validate_layer_cb (CoglPipeline *pipeline,
return TRUE;
}
-struct _CoglMutiTexturedRect
-{
- 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? */
-};
-
-static void
-_cogl_rectangles_with_multitexture_coords (
- struct _CoglMutiTexturedRect *rects,
- int n_rects)
+void
+_cogl_framebuffer_draw_multitextued_rectangles (
+ CoglFramebuffer *framebuffer,
+ CoglPipeline *pipeline,
+ CoglMultiTexturedRect *rects,
+ int n_rects,
+ gboolean disable_legacy_state)
{
- CoglPipeline *original_pipeline, *pipeline;
+ CoglContext *ctx = framebuffer->context;
+ CoglPipeline *original_pipeline;
ValidateLayerState state;
int i;
- _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
- pipeline = original_pipeline = cogl_get_source ();
+ original_pipeline = pipeline;
/*
* Validate all the layers of the current source pipeline...
*/
+ state.ctx = ctx;
state.i = -1;
state.first_layer = 0;
state.override_source = NULL;
@@ -663,13 +656,16 @@ _cogl_rectangles_with_multitexture_coords (
if (state.override_source)
pipeline = state.override_source;
- if (G_UNLIKELY (ctx->legacy_state_set) &&
- _cogl_get_enable_legacy_state ())
+ if (!disable_legacy_state)
{
- /* If we haven't already made a pipeline copy */
- if (pipeline == original_pipeline)
- pipeline = cogl_pipeline_copy (pipeline);
- _cogl_pipeline_apply_legacy_state (pipeline);
+ if (G_UNLIKELY (ctx->legacy_state_set) &&
+ _cogl_get_enable_legacy_state ())
+ {
+ /* If we haven't already made a pipeline copy */
+ if (pipeline == original_pipeline)
+ pipeline = cogl_pipeline_copy (pipeline);
+ _cogl_pipeline_apply_legacy_state (pipeline);
+ }
}
/*
@@ -685,8 +681,9 @@ _cogl_rectangles_with_multitexture_coords (
if (!state.all_use_sliced_quad_fallback)
{
gboolean success =
- _cogl_multitexture_quad_single_primitive (rects[i].position,
+ _cogl_multitexture_quad_single_primitive (framebuffer,
pipeline,
+ rects[i].position,
rects[i].tex_coords,
rects[i].tex_coords_len);
@@ -710,8 +707,9 @@ _cogl_rectangles_with_multitexture_coords (
COGL_NOTE (DRAW, "Drawing Tex Quad (Multi-Prim Mode)");
- _cogl_texture_quad_multiple_primitives (texture,
+ _cogl_texture_quad_multiple_primitives (framebuffer,
pipeline,
+ texture,
state.first_layer,
rects[i].position,
tex_coords[0],
@@ -724,19 +722,31 @@ _cogl_rectangles_with_multitexture_coords (
cogl_object_unref (pipeline);
}
+static void
+_cogl_rectangles_with_multitexture_coords (
+ CoglMultiTexturedRect *rects,
+ int n_rects)
+{
+ _cogl_framebuffer_draw_multitextued_rectangles (cogl_get_draw_framebuffer (),
+ cogl_get_source (),
+ rects,
+ n_rects,
+ FALSE);
+}
+
void
cogl_rectangles (const float *verts,
unsigned int n_rects)
{
- struct _CoglMutiTexturedRect *rects;
+ CoglMultiTexturedRect *rects;
int i;
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
- * _CoglMutiTexturedRect rectangles and pass these on to our work horse;
+ * CoglMultiTexturedRect rectangles and pass these on to our work horse;
* _cogl_rectangles_with_multitexture_coords.
*/
- rects = g_alloca (n_rects * sizeof (struct _CoglMutiTexturedRect));
+ rects = g_alloca (n_rects * sizeof (CoglMultiTexturedRect));
for (i = 0; i < n_rects; i++)
{
@@ -752,15 +762,15 @@ void
cogl_rectangles_with_texture_coords (const float *verts,
unsigned int n_rects)
{
- struct _CoglMutiTexturedRect *rects;
+ CoglMultiTexturedRect *rects;
int i;
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
- * _CoglMutiTexturedRect rectangles and pass these on to our work horse;
+ * CoglMultiTexturedRect rectangles and pass these on to our work horse;
* _cogl_rectangles_with_multitexture_coords.
*/
- rects = g_alloca (n_rects * sizeof (struct _CoglMutiTexturedRect));
+ rects = g_alloca (n_rects * sizeof (CoglMultiTexturedRect));
for (i = 0; i < n_rects; i++)
{
@@ -784,10 +794,10 @@ cogl_rectangle_with_texture_coords (float x_1,
{
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;
+ CoglMultiTexturedRect rect;
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
- * _CoglMutiTexturedRect rectangles and pass these on to our work horse;
+ * CoglMultiTexturedRect rectangles and pass these on to our work horse;
* _cogl_rectangles_with_multitexture_coords.
*/
@@ -807,10 +817,10 @@ cogl_rectangle_with_multitexture_coords (float x_1,
int user_tex_coords_len)
{
const float position[4] = {x_1, y_1, x_2, y_2};
- struct _CoglMutiTexturedRect rect;
+ CoglMultiTexturedRect rect;
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
- * _CoglMutiTexturedRect rectangles and pass these on to our work horse;
+ * CoglMultiTexturedRect rectangles and pass these on to our work horse;
* _cogl_rectangles_with_multitexture_coords.
*/
@@ -828,10 +838,10 @@ cogl_rectangle (float x_1,
float y_2)
{
const float position[4] = {x_1, y_1, x_2, y_2};
- struct _CoglMutiTexturedRect rect;
+ CoglMultiTexturedRect rect;
/* XXX: All the cogl_rectangle* APIs normalize their input into an array of
- * _CoglMutiTexturedRect rectangles and pass these on to our work horse;
+ * CoglMultiTexturedRect rectangles and pass these on to our work horse;
* _cogl_rectangles_with_multitexture_coords.
*/
@@ -854,6 +864,7 @@ _cogl_rectangle_immediate (CoglFramebuffer *framebuffer,
through the journal. This should only be used in cases where the
code might be called while the journal is already being flushed
such as when flushing the clip state */
+ CoglContext *ctx = framebuffer->context;
float vertices[8] =
{
x_1, y_1,
@@ -864,8 +875,6 @@ _cogl_rectangle_immediate (CoglFramebuffer *framebuffer,
CoglAttributeBuffer *attribute_buffer;
CoglAttribute *attributes[1];
- _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
attribute_buffer =
cogl_attribute_buffer_new (ctx, sizeof (vertices), vertices);
attributes[0] = cogl_attribute_new (attribute_buffer,
diff --git a/tests/conform/test-atlas-migration.c b/tests/conform/test-atlas-migration.c
index 18fc8ff..2e18b96 100644
--- a/tests/conform/test-atlas-migration.c
+++ b/tests/conform/test-atlas-migration.c
@@ -99,7 +99,7 @@ verify_texture (CoglHandle texture, int size)
}
void
-test_cogl_atlas_migration (TestUtilsGTestFixture *fixture,
+test_atlas_migration (TestUtilsGTestFixture *fixture,
void *data)
{
CoglHandle textures[N_TEXTURES];
diff --git a/tests/conform/test-backface-culling.c b/tests/conform/test-backface-culling.c
index 0fc0d4d..fe1eda5 100644
--- a/tests/conform/test-backface-culling.c
+++ b/tests/conform/test-backface-culling.c
@@ -17,18 +17,18 @@
typedef struct _TestState
{
- CoglContext *ctx;
- CoglFramebuffer *fb;
- CoglHandle texture;
+ CoglTexture *texture;
CoglFramebuffer *offscreen;
- CoglHandle offscreen_tex;
+ CoglTexture *offscreen_tex;
int width, height;
} TestState;
static void
-validate_part (int xnum, int ynum, gboolean shown)
+validate_part (CoglFramebuffer *framebuffer,
+ int xnum, int ynum, gboolean shown)
{
- test_utils_check_region (xnum * TEXTURE_RENDER_SIZE + TEST_INSET,
+ test_utils_check_region (framebuffer,
+ xnum * TEXTURE_RENDER_SIZE + TEST_INSET,
ynum * TEXTURE_RENDER_SIZE + TEST_INSET,
TEXTURE_RENDER_SIZE - TEST_INSET * 2,
TEXTURE_RENDER_SIZE - TEST_INSET * 2,
@@ -44,18 +44,22 @@ validate_part (int xnum, int ynum, gboolean shown)
#define CULL_FACE_MODE(draw_num) (((draw_num) & 0x0c) >> 2)
static void
-paint_test_backface_culling (TestState *state)
+paint_test_backface_culling (TestState *state,
+ CoglFramebuffer *framebuffer)
{
int draw_num;
- CoglPipeline *base_pipeline = cogl_pipeline_new (state->ctx);
- CoglColor clear_color;
+ CoglPipeline *base_pipeline = cogl_pipeline_new (ctx);
- cogl_ortho (0, state->width, /* left, right */
- state->height, 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ cogl_framebuffer_orthographic (framebuffer,
+ 0, 0,
+ state->width,
+ state->height,
+ -1,
+ 100);
- cogl_color_init_from_4ub (&clear_color, 0x00, 0x00, 0x00, 0xff);
- cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_STENCIL);
+ cogl_framebuffer_clear4f (framebuffer,
+ COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_STENCIL,
+ 0, 0, 0, 1);
cogl_pipeline_set_layer_texture (base_pipeline, 0, state->texture);
@@ -63,6 +67,8 @@ paint_test_backface_culling (TestState *state)
COGL_PIPELINE_FILTER_NEAREST,
COGL_PIPELINE_FILTER_NEAREST);
+ cogl_push_framebuffer (framebuffer);
+
/* Render the scene sixteen times to test all of the combinations of
cull face mode, legacy state and winding orders */
for (draw_num = 0; draw_num < 16; draw_num++)
@@ -144,11 +150,13 @@ paint_test_backface_culling (TestState *state)
cogl_object_unref (pipeline);
}
+ cogl_pop_framebuffer ();
+
cogl_object_unref (base_pipeline);
}
static void
-validate_result (int y_offset)
+validate_result (CoglFramebuffer *framebuffer, int y_offset)
{
int draw_num;
@@ -193,26 +201,29 @@ validate_result (int y_offset)
}
/* Front-facing texture */
- validate_part (0, y_offset + draw_num, !cull_front);
+ validate_part (framebuffer,
+ 0, y_offset + draw_num, !cull_front);
/* Front-facing texture with flipped tex coords */
- validate_part (1, y_offset + draw_num, !cull_front);
+ validate_part (framebuffer,
+ 1, y_offset + draw_num, !cull_front);
/* Back-facing texture */
- validate_part (2, y_offset + draw_num, !cull_back);
+ validate_part (framebuffer,
+ 2, y_offset + draw_num, !cull_back);
/* Front-facing texture polygon */
- validate_part (3, y_offset + draw_num, !cull_front);
+ validate_part (framebuffer,
+ 3, y_offset + draw_num, !cull_front);
/* Back-facing texture polygon */
- validate_part (4, y_offset + draw_num, !cull_back);
+ validate_part (framebuffer,
+ 4, y_offset + draw_num, !cull_back);
}
}
static void
paint (TestState *state)
{
- float stage_viewport[4];
- CoglMatrix stage_projection;
- CoglMatrix stage_modelview;
+ CoglPipeline *pipeline;
- paint_test_backface_culling (state);
+ paint_test_backface_culling (state, fb);
/*
* Now repeat the test but rendered to an offscreen
@@ -220,40 +231,28 @@ paint (TestState *state)
* always run to an offscreen buffer but we might as well have this
* check anyway in case it is being run with COGL_TEST_ONSCREEN=1
*/
-
- cogl_get_viewport (stage_viewport);
- cogl_get_projection_matrix (&stage_projection);
- cogl_get_modelview_matrix (&stage_modelview);
-
- cogl_push_framebuffer (state->offscreen);
-
- cogl_set_viewport (stage_viewport[0],
- stage_viewport[1],
- stage_viewport[2],
- stage_viewport[3]);
- cogl_set_projection_matrix (&stage_projection);
- cogl_set_modelview_matrix (&stage_modelview);
-
- paint_test_backface_culling (state);
-
- cogl_pop_framebuffer ();
-
- /* Incase we want feedback of what was drawn offscreen we draw it
- * to the stage... */
- cogl_set_source_texture (state->offscreen_tex);
- cogl_rectangle (0, TEXTURE_RENDER_SIZE * 16,
- stage_viewport[2],
- stage_viewport[3] + TEXTURE_RENDER_SIZE * 16);
-
- validate_result (0);
- validate_result (16);
+ paint_test_backface_culling (state, state->offscreen);
+
+ /* Copy the result of the offscreen rendering for validation and
+ * also so we can have visual feedback. */
+ pipeline = cogl_pipeline_new (ctx);
+ cogl_pipeline_set_layer_texture (pipeline, 0, state->offscreen_tex);
+ cogl_framebuffer_draw_rectangle (fb,
+ pipeline,
+ 0, TEXTURE_RENDER_SIZE * 16,
+ state->width,
+ state->height + TEXTURE_RENDER_SIZE * 16);
+ cogl_object_unref (pipeline);
+
+ validate_result (fb, 0);
+ validate_result (fb, 16);
}
-static CoglHandle
+static CoglTexture *
make_texture (void)
{
guchar *tex_data, *p;
- CoglHandle tex;
+ CoglTexture *tex;
tex_data = g_malloc (TEXTURE_SIZE * TEXTURE_SIZE * 4);
@@ -279,19 +278,15 @@ make_texture (void)
}
void
-test_cogl_backface_culling (TestUtilsGTestFixture *fixture,
- void *data)
+test_backface_culling (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- CoglHandle tex;
+ CoglTexture *tex;
- state.ctx = shared_state->ctx;
- state.fb = shared_state->fb;
- state.width = cogl_framebuffer_get_width (shared_state->fb);
- state.height = cogl_framebuffer_get_height (shared_state->fb);
+ state.width = cogl_framebuffer_get_width (fb);
+ state.height = cogl_framebuffer_get_height (fb);
- state.offscreen = COGL_INVALID_HANDLE;
+ state.offscreen = NULL;
state.texture = make_texture ();
@@ -304,8 +299,8 @@ test_cogl_backface_culling (TestUtilsGTestFixture *fixture,
paint (&state);
cogl_object_unref (state.offscreen);
- cogl_handle_unref (state.offscreen_tex);
- cogl_handle_unref (state.texture);
+ cogl_object_unref (state.offscreen_tex);
+ cogl_object_unref (state.texture);
if (cogl_test_verbose ())
g_print ("OK\n");
diff --git a/tests/conform/test-bitmask.c b/tests/conform/test-bitmask.c
index 2ac55a9..3e5e173 100644
--- a/tests/conform/test-bitmask.c
+++ b/tests/conform/test-bitmask.c
@@ -91,8 +91,7 @@ verify_bits (const CoglBitmask *bitmask,
}
void
-test_cogl_bitmask (TestUtilsGTestFixture *fixture,
- void *data)
+test_bitmask (void)
{
CoglBitmask bitmask;
CoglBitmask other_bitmask;
diff --git a/tests/conform/test-blend-strings.c b/tests/conform/test-blend-strings.c
index 05f8535..4fcf85f 100644
--- a/tests/conform/test-blend-strings.c
+++ b/tests/conform/test-blend-strings.c
@@ -60,7 +60,7 @@ test_blend (TestState *state,
int x_off;
/* First write out the destination color without any blending... */
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4ub (pipeline, Dr, Dg, Db, Da);
cogl_pipeline_set_blend (pipeline, "RGBA = ADD (SRC_COLOR, 0)", NULL);
cogl_set_source (pipeline);
@@ -74,7 +74,7 @@ test_blend (TestState *state,
* Now blend a rectangle over our well defined destination:
*/
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4ub (pipeline, Sr, Sg, Sb, Sa);
status = cogl_pipeline_set_blend (pipeline, blend_string, &error);
@@ -118,7 +118,7 @@ test_blend (TestState *state,
g_print (" blend constant = UNUSED\n");
}
- test_utils_check_pixel (x_off, y_off, expected_result);
+ test_utils_check_pixel (fb, x_off, y_off, expected_result);
/*
@@ -171,10 +171,10 @@ test_blend (TestState *state,
/* See what we got... */
- test_utils_check_pixel (x_off, y_off, expected_result);
+ test_utils_check_pixel (fb, x_off, y_off, expected_result);
}
-static CoglHandle
+static CoglTexture *
make_texture (guint32 color)
{
guchar *tex_data, *p;
@@ -182,7 +182,7 @@ make_texture (guint32 color)
guint8 g = MASK_GREEN (color);
guint8 b = MASK_BLUE (color);
guint8 a = MASK_ALPHA (color);
- CoglHandle tex;
+ CoglTexture *tex;
tex_data = g_malloc (QUAD_WIDTH * QUAD_WIDTH * 4);
@@ -219,7 +219,7 @@ test_tex_combine (TestState *state,
const char *combine_string,
guint32 expected_result)
{
- CoglHandle tex0, tex1;
+ CoglTexture *tex0, *tex1;
/* combine constant - when applicable */
guint8 Cr = MASK_RED (combine_constant);
@@ -268,8 +268,8 @@ test_tex_combine (TestState *state,
y * QUAD_WIDTH + QUAD_WIDTH);
cogl_handle_unref (material);
- cogl_handle_unref (tex0);
- cogl_handle_unref (tex1);
+ cogl_object_unref (tex0);
+ cogl_object_unref (tex1);
/* See what we got... */
@@ -288,7 +288,7 @@ test_tex_combine (TestState *state,
g_print (" combine constant = UNUSED\n");
}
- test_utils_check_pixel (x_off, y_off, expected_result);
+ test_utils_check_pixel (fb, x_off, y_off, expected_result);
}
static void
@@ -408,19 +408,21 @@ paint (TestState *state)
}
void
-test_cogl_blend_strings (TestUtilsGTestFixture *fixture,
- void *data)
+test_blend_strings (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- state.ctx = shared_state->ctx;
-
- cogl_ortho (0, cogl_framebuffer_get_width (shared_state->fb), /* left, right */
- cogl_framebuffer_get_height (shared_state->fb), 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ cogl_framebuffer_orthographic (fb, 0, 0,
+ cogl_framebuffer_get_width (fb),
+ cogl_framebuffer_get_height (fb),
+ -1,
+ 100);
+ /* XXX: we have to push/pop a framebuffer since this test currently
+ * uses the legacy cogl_rectangle() api. */
+ cogl_push_framebuffer (fb);
paint (&state);
+ cogl_pop_framebuffer ();
if (cogl_test_verbose ())
g_print ("OK\n");
diff --git a/tests/conform/test-color-mask.c b/tests/conform/test-color-mask.c
index 6222927..1e22cbc 100644
--- a/tests/conform/test-color-mask.c
+++ b/tests/conform/test-color-mask.c
@@ -11,7 +11,7 @@ typedef struct _TestState
int width;
int height;
- CoglHandle tex[NUM_FBOS];
+ CoglTexture *tex[NUM_FBOS];
CoglFramebuffer *fbo[NUM_FBOS];
} TestState;
@@ -45,9 +45,12 @@ paint (TestState *state)
/* Render all of the textures to the screen */
for (i = 0; i < NUM_FBOS; i++)
{
- cogl_set_source_texture (state->tex[i]);
- cogl_rectangle (2.0f / NUM_FBOS * i - 1.0f, -1.0f,
- 2.0f / NUM_FBOS * (i + 1) - 1.0f, 1.0f);
+ CoglPipeline *pipeline = cogl_pipeline_new (ctx);
+ cogl_pipeline_set_layer_texture (pipeline, 0, state->tex[i]);
+ cogl_framebuffer_draw_rectangle (fb, pipeline,
+ 2.0f / NUM_FBOS * i - 1.0f, -1.0f,
+ 2.0f / NUM_FBOS * (i + 1) - 1.0f, 1.0f);
+ cogl_object_unref (pipeline);
}
/* Verify all of the fbos drew the right color */
@@ -58,7 +61,8 @@ paint (TestState *state)
{ 0x00, 0xff, 0x00, 0xff },
{ 0x00, 0x00, 0xff, 0xff } };
- test_utils_check_pixel_rgb (state->width * (i + 0.5f) / NUM_FBOS,
+ test_utils_check_pixel_rgb (fb,
+ state->width * (i + 0.5f) / NUM_FBOS,
state->height / 2,
expected_colors[i][0],
expected_colors[i][1],
@@ -67,18 +71,13 @@ paint (TestState *state)
}
void
-test_cogl_color_mask (TestUtilsGTestFixture *fixture,
- void *data)
+test_color_mask (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- CoglColor bg;
int i;
- state.width = cogl_framebuffer_get_width (shared_state->fb);
- state.height = cogl_framebuffer_get_height (shared_state->fb);
-
- cogl_color_init_from_4ub (&bg, 0, 0, 0, 255);
+ state.width = cogl_framebuffer_get_width (fb);
+ state.height = cogl_framebuffer_get_height (fb);
for (i = 0; i < NUM_FBOS; i++)
{
@@ -91,9 +90,8 @@ test_cogl_color_mask (TestUtilsGTestFixture *fixture,
cogl_offscreen_new_to_texture (state.tex[i]));
/* Clear the texture color bits */
- cogl_push_framebuffer (state.fbo[i]);
- cogl_clear (&bg, COGL_BUFFER_BIT_COLOR);
- cogl_pop_framebuffer ();
+ cogl_framebuffer_clear4f (state.fbo[i],
+ COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
cogl_framebuffer_set_color_mask (state.fbo[i],
i == 0 ? COGL_COLOR_MASK_RED :
@@ -101,7 +99,11 @@ test_cogl_color_mask (TestUtilsGTestFixture *fixture,
COGL_COLOR_MASK_BLUE);
}
+ /* XXX: we have to push/pop a framebuffer since this test currently
+ * uses the legacy cogl_rectangle() api. */
+ cogl_push_framebuffer (fb);
paint (&state);
+ cogl_pop_framebuffer ();
if (cogl_test_verbose ())
g_print ("OK\n");
diff --git a/tests/conform/test-conform-main.c b/tests/conform/test-conform-main.c
index 74f1ff0..ed5a652 100644
--- a/tests/conform/test-conform-main.c
+++ b/tests/conform/test-conform-main.c
@@ -9,16 +9,14 @@
#include "test-utils.h"
-static TestUtilsSharedState *shared_state = NULL;
-
/* A bit of sugar for adding new conformance tests */
#define ADD_TEST(FUNC, REQUIREMENTS) G_STMT_START { \
- extern void FUNC (TestUtilsGTestFixture *, void *); \
+ extern void FUNC (void); \
if (strcmp (#FUNC, argv[1]) == 0) \
{ \
- test_utils_init (shared_state, REQUIREMENTS); \
- FUNC (NULL, shared_state); \
- test_utils_fini (shared_state); \
+ test_utils_init (REQUIREMENTS); \
+ FUNC (); \
+ test_utils_fini (); \
exit (0); \
} \
} G_STMT_END
@@ -45,65 +43,59 @@ main (int argc, char **argv)
argv[1][i] = '_';
}
- /* Initialise the state you need to share with everything.
- */
- shared_state = g_new0 (TestUtilsSharedState, 1);
- shared_state->argc_addr = &argc;
- shared_state->argv_addr = &argv;
-
/* This file is run through a sed script during the make step so the
* lines containing the tests need to be formatted on a single line
* each.
*/
- UNPORTED_TEST (test_cogl_object);
- UNPORTED_TEST (test_cogl_fixed);
- UNPORTED_TEST (test_cogl_materials);
- ADD_TEST (test_cogl_pipeline_user_matrix, 0);
- ADD_TEST (test_cogl_blend_strings, 0);
- UNPORTED_TEST (test_cogl_premult);
- UNPORTED_TEST (test_cogl_readpixels);
- ADD_TEST (test_cogl_path, 0);
- ADD_TEST (test_cogl_depth_test, 0);
- ADD_TEST (test_cogl_color_mask, 0);
- ADD_TEST (test_cogl_backface_culling, TEST_REQUIREMENT_NPOT);
-
- ADD_TEST (test_cogl_sparse_pipeline, 0);
-
- UNPORTED_TEST (test_cogl_npot_texture);
- UNPORTED_TEST (test_cogl_multitexture);
- UNPORTED_TEST (test_cogl_texture_mipmaps);
- ADD_TEST (test_cogl_sub_texture, 0);
- ADD_TEST (test_cogl_pixel_buffer, 0);
- UNPORTED_TEST (test_cogl_texture_rectangle);
- ADD_TEST (test_cogl_texture_3d, 0);
- ADD_TEST (test_cogl_wrap_modes, 0);
- UNPORTED_TEST (test_cogl_texture_pixmap_x11);
- UNPORTED_TEST (test_cogl_texture_get_set_data);
- UNPORTED_TEST (test_cogl_atlas_migration);
- ADD_TEST (test_cogl_read_texture_formats, 0);
- ADD_TEST (test_cogl_write_texture_formats, 0);
-
- UNPORTED_TEST (test_cogl_vertex_buffer_contiguous);
- UNPORTED_TEST (test_cogl_vertex_buffer_interleved);
- UNPORTED_TEST (test_cogl_vertex_buffer_mutability);
-
- ADD_TEST (test_cogl_primitive, 0);
-
- ADD_TEST (test_cogl_just_vertex_shader, 0);
- ADD_TEST (test_cogl_pipeline_uniforms, 0);
- ADD_TEST (test_cogl_snippets, 0);
- ADD_TEST (test_cogl_custom_attributes, 0);
-
- ADD_TEST (test_cogl_bitmask, 0);
-
- ADD_TEST (test_cogl_offscreen, 0);
-
- ADD_TEST (test_cogl_point_size, 0);
- ADD_TEST (test_cogl_point_sprite,
+ UNPORTED_TEST (test_object);
+ UNPORTED_TEST (test_fixed);
+ UNPORTED_TEST (test_materials);
+ ADD_TEST (test_pipeline_user_matrix, 0);
+ ADD_TEST (test_blend_strings, 0);
+ UNPORTED_TEST (test_premult);
+ UNPORTED_TEST (test_readpixels);
+ ADD_TEST (test_path, 0);
+ ADD_TEST (test_depth_test, 0);
+ ADD_TEST (test_color_mask, 0);
+ ADD_TEST (test_backface_culling, TEST_REQUIREMENT_NPOT);
+
+ ADD_TEST (test_sparse_pipeline, 0);
+
+ UNPORTED_TEST (test_npot_texture);
+ UNPORTED_TEST (test_multitexture);
+ UNPORTED_TEST (test_texture_mipmaps);
+ ADD_TEST (test_sub_texture, 0);
+ ADD_TEST (test_pixel_buffer, 0);
+ UNPORTED_TEST (test_texture_rectangle);
+ ADD_TEST (test_texture_3d, 0);
+ ADD_TEST (test_wrap_modes, 0);
+ UNPORTED_TEST (test_texture_pixmap_x11);
+ UNPORTED_TEST (test_texture_get_set_data);
+ UNPORTED_TEST (test_atlas_migration);
+ ADD_TEST (test_read_texture_formats, 0);
+ ADD_TEST (test_write_texture_formats, 0);
+
+ UNPORTED_TEST (test_vertex_buffer_contiguous);
+ UNPORTED_TEST (test_vertex_buffer_interleved);
+ UNPORTED_TEST (test_vertex_buffer_mutability);
+
+ ADD_TEST (test_primitive, 0);
+
+ ADD_TEST (test_just_vertex_shader, 0);
+ ADD_TEST (test_pipeline_uniforms, 0);
+ ADD_TEST (test_snippets, 0);
+ ADD_TEST (test_custom_attributes, 0);
+
+ ADD_TEST (test_bitmask, 0);
+
+ ADD_TEST (test_offscreen, 0);
+
+ ADD_TEST (test_point_size, 0);
+ ADD_TEST (test_point_sprite,
TEST_KNOWN_FAILURE | TEST_REQUIREMENT_POINT_SPRITE);
- UNPORTED_TEST (test_cogl_viewport);
+ UNPORTED_TEST (test_viewport);
g_printerr ("Unknown test name \"%s\"\n", argv[1]);
diff --git a/tests/conform/test-custom-attributes.c b/tests/conform/test-custom-attributes.c
index d9ceaac..6af4fa2 100644
--- a/tests/conform/test-custom-attributes.c
+++ b/tests/conform/test-custom-attributes.c
@@ -6,8 +6,6 @@
typedef struct _TestState
{
- CoglContext *ctx;
- CoglFramebuffer *fb;
CoglPipeline *pipeline;
} TestState;
@@ -45,7 +43,7 @@ test_float_verts (TestState *state, int offset_x, int offset_y)
{ 15, 0, /**/ 0, 1, 0, 1 }
};
- buffer = cogl_attribute_buffer_new (state->ctx,
+ buffer = cogl_attribute_buffer_new (ctx,
sizeof (float_verts), float_verts);
attributes[0] = cogl_attribute_new (buffer,
"cogl_position_in",
@@ -60,10 +58,10 @@ test_float_verts (TestState *state, int offset_x, int offset_y)
4, /* n_components */
COGL_ATTRIBUTE_TYPE_FLOAT);
- cogl_push_matrix ();
- cogl_translate (offset_x, offset_y, 0.0f);
+ cogl_framebuffer_push_matrix (fb);
+ cogl_framebuffer_translate (fb, offset_x, offset_y, 0.0f);
- cogl_framebuffer_draw_attributes (state->fb,
+ cogl_framebuffer_draw_attributes (fb,
state->pipeline,
COGL_VERTICES_MODE_TRIANGLES,
0, /* first_vertex */
@@ -71,14 +69,14 @@ test_float_verts (TestState *state, int offset_x, int offset_y)
attributes,
2 /* n_attributes */);
- cogl_pop_matrix ();
+ cogl_framebuffer_pop_matrix (fb);
cogl_object_unref (attributes[1]);
cogl_object_unref (attributes[0]);
cogl_object_unref (buffer);
- test_utils_check_pixel (offset_x + 5, offset_y + 5, 0xff0000ff);
- test_utils_check_pixel (offset_x + 15, offset_y + 5, 0x00ff00ff);
+ test_utils_check_pixel (fb, offset_x + 5, offset_y + 5, 0xff0000ff);
+ test_utils_check_pixel (fb, offset_x + 15, offset_y + 5, 0x00ff00ff);
}
static void
@@ -105,7 +103,7 @@ test_byte_verts (TestState *state, int offset_x, int offset_y)
{ 0, 0, /**/ 0, 0, 1, 1 },
};
- buffer = cogl_attribute_buffer_new (state->ctx,
+ buffer = cogl_attribute_buffer_new (ctx,
sizeof (norm_verts), norm_verts);
attributes[0] = cogl_attribute_new (buffer,
"cogl_position_in",
@@ -121,10 +119,10 @@ test_byte_verts (TestState *state, int offset_x, int offset_y)
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
cogl_attribute_set_normalized (attributes[1], TRUE);
- cogl_push_matrix ();
- cogl_translate (offset_x, offset_y, 0.0f);
+ cogl_framebuffer_push_matrix (fb);
+ cogl_framebuffer_translate (fb, offset_x, offset_y, 0.0f);
- cogl_framebuffer_draw_attributes (state->fb,
+ cogl_framebuffer_draw_attributes (fb,
state->pipeline,
COGL_VERTICES_MODE_TRIANGLES,
0, /* first_vertex */
@@ -135,7 +133,7 @@ test_byte_verts (TestState *state, int offset_x, int offset_y)
cogl_object_unref (attributes[1]);
/* Test again with unnormalized attributes */
- unnorm_buffer = cogl_attribute_buffer_new (state->ctx,
+ unnorm_buffer = cogl_attribute_buffer_new (ctx,
sizeof (unnorm_verts),
unnorm_verts);
attributes[1] = cogl_attribute_new (unnorm_buffer,
@@ -145,9 +143,9 @@ test_byte_verts (TestState *state, int offset_x, int offset_y)
4, /* n_components */
COGL_ATTRIBUTE_TYPE_BYTE);
- cogl_translate (20, 0, 0);
+ cogl_framebuffer_translate (fb, 20, 0, 0);
- cogl_framebuffer_draw_attributes (state->fb,
+ cogl_framebuffer_draw_attributes (fb,
state->pipeline,
COGL_VERTICES_MODE_TRIANGLES,
0, /* first_vertex */
@@ -155,16 +153,16 @@ test_byte_verts (TestState *state, int offset_x, int offset_y)
attributes,
2 /* n_attributes */);
- cogl_pop_matrix ();
+ cogl_framebuffer_pop_matrix (fb);
cogl_object_unref (attributes[0]);
cogl_object_unref (attributes[1]);
cogl_object_unref (buffer);
cogl_object_unref (unnorm_buffer);
- test_utils_check_pixel (offset_x + 5, offset_y + 5, 0xff0000ff);
- test_utils_check_pixel (offset_x + 15, offset_y + 5, 0x00ff00ff);
- test_utils_check_pixel (offset_x + 25, offset_y + 5, 0x0000ffff);
+ test_utils_check_pixel (fb, offset_x + 5, offset_y + 5, 0xff0000ff);
+ test_utils_check_pixel (fb, offset_x + 15, offset_y + 5, 0x00ff00ff);
+ test_utils_check_pixel (fb, offset_x + 25, offset_y + 5, 0x0000ffff);
}
static void
@@ -182,7 +180,7 @@ test_short_verts (TestState *state, int offset_x, int offset_y)
{ -5, -1 }
};
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
snippet = cogl_snippet_new (COGL_SNIPPET_HOOK_VERTEX_TRANSFORM,
"attribute vec2 pos;",
NULL);
@@ -195,7 +193,7 @@ test_short_verts (TestState *state, int offset_x, int offset_y)
cogl_pipeline_set_color4ub (pipeline, 255, 0, 0, 255);
- buffer = cogl_attribute_buffer_new (state->ctx,
+ buffer = cogl_attribute_buffer_new (ctx,
sizeof (short_verts), short_verts);
attributes[0] = cogl_attribute_new (buffer,
"pos",
@@ -204,10 +202,13 @@ test_short_verts (TestState *state, int offset_x, int offset_y)
2, /* n_components */
COGL_ATTRIBUTE_TYPE_SHORT);
- cogl_push_matrix ();
- cogl_translate (offset_x + 10.0f, offset_y + 10.0f, 0.0f);
+ cogl_framebuffer_push_matrix (fb);
+ cogl_framebuffer_translate (fb,
+ offset_x + 10.0f,
+ offset_y + 10.0f,
+ 0.0f);
- cogl_framebuffer_draw_attributes (state->fb,
+ cogl_framebuffer_draw_attributes (fb,
pipeline,
COGL_VERTICES_MODE_TRIANGLES,
0, /* first_vertex */
@@ -215,7 +216,7 @@ test_short_verts (TestState *state, int offset_x, int offset_y)
attributes,
1 /* n_attributes */);
- cogl_pop_matrix ();
+ cogl_framebuffer_pop_matrix (fb);
cogl_object_unref (attributes[0]);
@@ -230,10 +231,13 @@ test_short_verts (TestState *state, int offset_x, int offset_y)
pipeline2 = cogl_pipeline_copy (pipeline);
cogl_pipeline_set_color4ub (pipeline2, 0, 255, 0, 255);
- cogl_push_matrix ();
- cogl_translate (offset_x + 10.0f - 65525.0f, offset_y - 65525, 0.0f);
+ cogl_framebuffer_push_matrix (fb);
+ cogl_framebuffer_translate (fb,
+ offset_x + 10.0f - 65525.0f,
+ offset_y - 65525,
+ 0.0f);
- cogl_framebuffer_draw_attributes (state->fb,
+ cogl_framebuffer_draw_attributes (fb,
pipeline2,
COGL_VERTICES_MODE_TRIANGLES,
0, /* first_vertex */
@@ -241,7 +245,7 @@ test_short_verts (TestState *state, int offset_x, int offset_y)
attributes,
1 /* n_attributes */);
- cogl_pop_matrix ();
+ cogl_framebuffer_pop_matrix (fb);
cogl_object_unref (attributes[0]);
@@ -249,17 +253,14 @@ test_short_verts (TestState *state, int offset_x, int offset_y)
cogl_object_unref (pipeline);
cogl_object_unref (buffer);
- test_utils_check_pixel (offset_x + 5, offset_y + 5, 0xff0000ff);
- test_utils_check_pixel (offset_x + 15, offset_y + 5, 0x00ff00ff);
+ test_utils_check_pixel (fb, offset_x + 5, offset_y + 5, 0xff0000ff);
+ test_utils_check_pixel (fb, offset_x + 15, offset_y + 5, 0x00ff00ff);
}
static void
paint (TestState *state)
{
- CoglColor color;
-
- cogl_color_init_from_4ub (&color, 0, 0, 0, 255);
- cogl_clear (&color, COGL_BUFFER_BIT_COLOR);
+ cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
test_float_verts (state, 0, 0);
test_byte_verts (state, 0, 10);
@@ -267,28 +268,22 @@ paint (TestState *state)
}
void
-test_cogl_custom_attributes (TestUtilsGTestFixture *fixture,
- void *user_data)
+test_custom_attributes (void)
{
- TestUtilsSharedState *shared_state = user_data;
-
/* If shaders aren't supported then we can't run the test */
if (cogl_features_available (COGL_FEATURE_SHADERS_GLSL))
{
CoglSnippet *snippet;
TestState state;
- state.fb = shared_state->fb;
-
- state.ctx = shared_state->ctx;
- cogl_ortho (/* left, right */
- 0, cogl_framebuffer_get_width (shared_state->fb),
- /* bottom, top */
- cogl_framebuffer_get_height (shared_state->fb), 0,
- /* z near, far */
- -1, 100);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ cogl_framebuffer_get_width (fb),
+ cogl_framebuffer_get_height (fb),
+ -1,
+ 100);
- state.pipeline = cogl_pipeline_new (state.ctx);
+ state.pipeline = cogl_pipeline_new (ctx);
snippet = cogl_snippet_new (COGL_SNIPPET_HOOK_VERTEX,
"attribute vec4 color;",
"cogl_color_out = color;");
diff --git a/tests/conform/test-depth-test.c b/tests/conform/test-depth-test.c
index 301c2a2..76891db 100644
--- a/tests/conform/test-depth-test.c
+++ b/tests/conform/test-depth-test.c
@@ -18,7 +18,7 @@
typedef struct _TestState
{
- CoglContext *ctx;
+ int padding;
} TestState;
typedef struct
@@ -36,13 +36,14 @@ static gboolean
draw_rectangle (TestState *state,
int x,
int y,
- TestDepthState *rect_state)
+ TestDepthState *rect_state,
+ gboolean legacy_mode)
{
guint8 Cr = MASK_RED (rect_state->color);
guint8 Cg = MASK_GREEN (rect_state->color);
guint8 Cb = MASK_BLUE (rect_state->color);
guint8 Ca = MASK_ALPHA (rect_state->color);
- CoglHandle pipeline;
+ CoglPipeline *pipeline;
CoglDepthState depth_state;
cogl_depth_state_init (&depth_state);
@@ -53,24 +54,40 @@ draw_rectangle (TestState *state,
rect_state->range_near,
rect_state->range_far);
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
if (!cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL))
{
cogl_object_unref (pipeline);
return FALSE;
}
- cogl_pipeline_set_color4ub (pipeline, Cr, Cg, Cb, Ca);
-
- cogl_set_source (pipeline);
-
- cogl_push_matrix ();
- cogl_translate (0, 0, rect_state->depth);
- cogl_rectangle (x * QUAD_WIDTH,
- y * QUAD_WIDTH,
- x * QUAD_WIDTH + QUAD_WIDTH,
- y * QUAD_WIDTH + QUAD_WIDTH);
- cogl_pop_matrix ();
+ if (!legacy_mode)
+ {
+ cogl_pipeline_set_color4ub (pipeline, Cr, Cg, Cb, Ca);
+
+ cogl_framebuffer_push_matrix (fb);
+ cogl_framebuffer_translate (fb, 0, 0, rect_state->depth);
+ cogl_framebuffer_draw_rectangle (fb,
+ pipeline,
+ x * QUAD_WIDTH,
+ y * QUAD_WIDTH,
+ x * QUAD_WIDTH + QUAD_WIDTH,
+ y * QUAD_WIDTH + QUAD_WIDTH);
+ cogl_framebuffer_pop_matrix (fb);
+ }
+ else
+ {
+ cogl_push_framebuffer (fb);
+ cogl_push_matrix ();
+ cogl_set_source_color4ub (Cr, Cg, Cb, Ca);
+ cogl_translate (0, 0, rect_state->depth);
+ cogl_rectangle (x * QUAD_WIDTH,
+ y * QUAD_WIDTH,
+ x * QUAD_WIDTH + QUAD_WIDTH,
+ y * QUAD_WIDTH + QUAD_WIDTH);
+ cogl_pop_matrix ();
+ cogl_pop_framebuffer ();
+ }
cogl_object_unref (pipeline);
@@ -84,23 +101,25 @@ test_depth (TestState *state,
TestDepthState *rect0_state,
TestDepthState *rect1_state,
TestDepthState *rect2_state,
+ gboolean legacy_mode,
guint32 expected_result)
{
gboolean missing_feature = FALSE;
if (rect0_state)
- missing_feature |= !draw_rectangle (state, x, y, rect0_state);
+ missing_feature |= !draw_rectangle (state, x, y, rect0_state, legacy_mode);
if (rect1_state)
- missing_feature |= !draw_rectangle (state, x, y, rect1_state);
+ missing_feature |= !draw_rectangle (state, x, y, rect1_state, legacy_mode);
if (rect2_state)
- missing_feature |= !draw_rectangle (state, x, y, rect2_state);
+ missing_feature |= !draw_rectangle (state, x, y, rect2_state, legacy_mode);
/* We don't consider it an error that we can't test something
* the driver doesn't support. */
if (missing_feature)
return;
- test_utils_check_pixel (x * QUAD_WIDTH + (QUAD_WIDTH / 2),
+ test_utils_check_pixel (fb,
+ x * QUAD_WIDTH + (QUAD_WIDTH / 2),
y * QUAD_WIDTH + (QUAD_WIDTH / 2),
expected_result);
}
@@ -142,27 +161,32 @@ paint (TestState *state)
test_depth (state, 0, 0, /* position */
&rect0_state, &rect1_state, &rect2_state,
+ FALSE, /* legacy mode */
0x00ff00ff); /* expected */
rect2_state.test_function = COGL_DEPTH_TEST_FUNCTION_ALWAYS;
test_depth (state, 1, 0, /* position */
&rect0_state, &rect1_state, &rect2_state,
+ FALSE, /* legacy mode */
0x0000ffff); /* expected */
rect2_state.test_function = COGL_DEPTH_TEST_FUNCTION_LESS;
test_depth (state, 2, 0, /* position */
&rect0_state, &rect1_state, &rect2_state,
+ FALSE, /* legacy mode */
0x0000ffff); /* expected */
rect2_state.test_function = COGL_DEPTH_TEST_FUNCTION_GREATER;
test_depth (state, 3, 0, /* position */
&rect0_state, &rect1_state, &rect2_state,
+ FALSE, /* legacy mode */
0x00ff00ff); /* expected */
rect0_state.test_enable = TRUE;
rect1_state.write_enable = FALSE;
test_depth (state, 4, 0, /* position */
&rect0_state, &rect1_state, &rect2_state,
+ FALSE, /* legacy mode */
0x0000ffff); /* expected */
}
@@ -191,6 +215,7 @@ paint (TestState *state)
test_depth (state, 0, 1, /* position */
&rect0_state, &rect1_state, NULL,
+ FALSE, /* legacy mode */
0xff0000ff); /* expected */
}
@@ -220,26 +245,26 @@ paint (TestState *state)
cogl_set_depth_test_enabled (TRUE);
test_depth (state, 0, 2, /* position */
&rect0_state, &rect1_state, NULL,
+ TRUE, /* legacy mode */
0xff0000ff); /* expected */
cogl_set_depth_test_enabled (FALSE);
test_depth (state, 1, 2, /* position */
&rect0_state, &rect1_state, NULL,
+ TRUE, /* legacy mode */
0x00ff00ff); /* expected */
}
}
void
-test_cogl_depth_test (TestUtilsGTestFixture *fixture,
- void *data)
+test_depth_test (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- state.ctx = shared_state->ctx;
-
- cogl_ortho (0, cogl_framebuffer_get_width (shared_state->fb), /* left, right */
- cogl_framebuffer_get_height (shared_state->fb), 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ cogl_framebuffer_orthographic (fb, 0, 0,
+ cogl_framebuffer_get_width (fb),
+ cogl_framebuffer_get_height (fb),
+ -1,
+ 100);
paint (&state);
diff --git a/tests/conform/test-fixed.c b/tests/conform/test-fixed.c
index 78c3445..175b2d1 100644
--- a/tests/conform/test-fixed.c
+++ b/tests/conform/test-fixed.c
@@ -4,7 +4,7 @@
#include "test-conform-common.h"
void
-test_cogl_fixed (TestUtilsGTestFixture *fixture,
+test_fixed (TestUtilsGTestFixture *fixture,
void *data)
{
g_assert_cmpint (COGL_FIXED_1, ==, COGL_FIXED_FROM_FLOAT (1.0));
diff --git a/tests/conform/test-fixtures.c b/tests/conform/test-fixtures.c
index 24178d2..dfc2043 100644
--- a/tests/conform/test-fixtures.c
+++ b/tests/conform/test-fixtures.c
@@ -3,7 +3,7 @@
#include <cogl/cogl.h>
void
-test_cogl_simple_rig (void)
+test_simple_rig (void)
{
ClutterColor stage_color = { 0x0, 0x0, 0x0, 0xff };
stage = clutter_stage_get_default ();
diff --git a/tests/conform/test-just-vertex-shader.c b/tests/conform/test-just-vertex-shader.c
index ef0ecc2..2e05480 100644
--- a/tests/conform/test-just-vertex-shader.c
+++ b/tests/conform/test-just-vertex-shader.c
@@ -6,10 +6,10 @@
typedef struct _TestState
{
- CoglContext *ctx;
+ int paddiing;
} TestState;
-static CoglHandle
+static CoglTexture *
create_dummy_texture (void)
{
/* Create a dummy 1x1 green texture to replace the color from the
@@ -28,7 +28,7 @@ static void
paint_legacy (TestState *state)
{
CoglHandle material = cogl_material_new ();
- CoglHandle tex;
+ CoglTexture *tex;
CoglColor color;
GError *error = NULL;
CoglHandle shader, program;
@@ -44,7 +44,7 @@ paint_legacy (TestState *state)
constant green color provided by a texture */
tex = create_dummy_texture ();
cogl_material_set_layer (material, 0, tex);
- cogl_handle_unref (tex);
+ cogl_object_unref (tex);
if (!cogl_material_set_layer_combine (material, 0,
"RGBA=REPLACE(TEXTURE)",
&error))
@@ -97,8 +97,8 @@ paint_legacy (TestState *state)
static void
paint (TestState *state)
{
- CoglPipeline *pipeline = cogl_pipeline_new (state->ctx);
- CoglHandle tex;
+ CoglPipeline *pipeline = cogl_pipeline_new (ctx);
+ CoglTexture *tex;
CoglColor color;
GError *error = NULL;
CoglHandle shader, program;
@@ -114,7 +114,7 @@ paint (TestState *state)
constant green color provided by a texture */
tex = create_dummy_texture ();
cogl_pipeline_set_layer_texture (pipeline, 0, tex);
- cogl_handle_unref (tex);
+ cogl_object_unref (tex);
if (!cogl_pipeline_set_layer_combine (pipeline, 0,
"RGBA=REPLACE(TEXTURE)",
&error))
@@ -166,35 +166,40 @@ paint (TestState *state)
}
static void
-validate_result (void)
+validate_result (CoglFramebuffer *framebuffer)
{
/* Non-shader version */
- test_utils_check_pixel (25, 25, 0x00ff0000);
+ test_utils_check_pixel (framebuffer, 25, 25, 0x00ff0000);
/* Shader version */
- test_utils_check_pixel (75, 25, 0x00ff0000);
+ test_utils_check_pixel (framebuffer, 75, 25, 0x00ff0000);
}
void
-test_cogl_just_vertex_shader (TestUtilsGTestFixture *fixture,
- void *data)
+test_just_vertex_shader (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- state.ctx = shared_state->ctx;
-
- cogl_ortho (0, cogl_framebuffer_get_width (shared_state->fb), /* left, right */
- cogl_framebuffer_get_height (shared_state->fb), 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ cogl_framebuffer_get_width (fb),
+ cogl_framebuffer_get_height (fb),
+ -1,
+ 100);
/* If shaders aren't supported then we can't run the test */
if (cogl_features_available (COGL_FEATURE_SHADERS_GLSL))
{
+ /* XXX: we have to push/pop a framebuffer since this test currently
+ * uses the legacy cogl_rectangle() api. */
+ cogl_push_framebuffer (fb);
+
paint_legacy (&state);
- validate_result ();
+ validate_result (fb);
paint (&state);
- validate_result ();
+ validate_result (fb);
+
+ cogl_pop_framebuffer ();
if (cogl_test_verbose ())
g_print ("OK\n");
diff --git a/tests/conform/test-materials.c b/tests/conform/test-materials.c
index cb4f208..84b1444 100644
--- a/tests/conform/test-materials.c
+++ b/tests/conform/test-materials.c
@@ -218,7 +218,7 @@ queue_redraw (gpointer stage)
}
void
-test_cogl_materials (TestUtilsGTestFixture *fixture,
+test_materials (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
diff --git a/tests/conform/test-multitexture.c b/tests/conform/test-multitexture.c
index 4de5f97..c0aa9c2 100644
--- a/tests/conform/test-multitexture.c
+++ b/tests/conform/test-multitexture.c
@@ -173,7 +173,7 @@ queue_redraw (gpointer stage)
}
void
-test_cogl_multitexture (TestUtilsGTestFixture *fixture,
+test_multitexture (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
diff --git a/tests/conform/test-npot-texture.c b/tests/conform/test-npot-texture.c
index c755139..8687d63 100644
--- a/tests/conform/test-npot-texture.c
+++ b/tests/conform/test-npot-texture.c
@@ -188,7 +188,7 @@ make_texture (void)
}
void
-test_cogl_npot_texture (TestUtilsGTestFixture *fixture,
+test_npot_texture (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
diff --git a/tests/conform/test-object.c b/tests/conform/test-object.c
index b1493cc..0a6dcab 100644
--- a/tests/conform/test-object.c
+++ b/tests/conform/test-object.c
@@ -39,7 +39,7 @@ destroy2_cb (void *user_data)
}
void
-test_cogl_object (TestUtilsGTestFixture *fixture,
+test_object (TestUtilsGTestFixture *fixture,
void *data)
{
CoglPath *path;
diff --git a/tests/conform/test-offscreen.c b/tests/conform/test-offscreen.c
index 2a07880..0683a8a 100644
--- a/tests/conform/test-offscreen.c
+++ b/tests/conform/test-offscreen.c
@@ -8,7 +8,6 @@
typedef struct _TestState
{
- CoglContext *context;
int fb_width;
int fb_height;
} TestState;
@@ -33,7 +32,7 @@ check_quadrant (TestState *state,
width -= 4;
height -= 4;
- test_utils_check_region (x, y, width, height, expected_rgba);
+ test_utils_check_region (fb, x, y, width, height, expected_rgba);
}
static void
@@ -41,9 +40,9 @@ test_paint (TestState *state)
{
CoglTexture2D *tex_2d;
CoglTexture *tex;
- CoglHandle offscreen;
+ CoglOffscreen *offscreen;
- tex_2d = cogl_texture_2d_new_with_size (state->context,
+ tex_2d = cogl_texture_2d_new_with_size (ctx,
state->fb_width,
state->fb_height,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
@@ -66,11 +65,11 @@ test_paint (TestState *state)
cogl_translate (0.5, 0.5, 0);
cogl_scale (-0.5, 0.5, 1);
- cogl_push_framebuffer (offscreen);
+ cogl_push_framebuffer (COGL_FRAMEBUFFER (offscreen));
/* Cogl should release the last reference when we call cogl_pop_framebuffer()
*/
- cogl_handle_unref (offscreen);
+ cogl_object_unref (offscreen);
/* Setup something other than the identity matrix for the modelview so we can
* verify it gets restored when we call cogl_pop_framebuffer () */
@@ -116,7 +115,7 @@ test_flush (TestState *state)
{
CoglTexture2D *tex_2d;
CoglTexture *tex;
- CoglHandle offscreen;
+ CoglOffscreen *offscreen;
CoglColor clear_color;
int i;
@@ -126,7 +125,7 @@ test_flush (TestState *state)
the contents of the texture will automatically flush the
journal */
- tex_2d = cogl_texture_2d_new_with_size (state->context,
+ tex_2d = cogl_texture_2d_new_with_size (ctx,
16, 16, /* width/height */
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
NULL);
@@ -134,7 +133,7 @@ test_flush (TestState *state)
offscreen = cogl_offscreen_new_to_texture (tex);
- cogl_push_framebuffer (offscreen);
+ cogl_push_framebuffer (COGL_FRAMEBUFFER (offscreen));
cogl_color_init_from_4ub (&clear_color, 0, 0, 0, 255);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR);
@@ -144,7 +143,8 @@ test_flush (TestState *state)
if (i == 0)
/* First time check using read pixels on the offscreen */
- test_utils_check_region (1, 1, 15, 15, 0xff0000ff);
+ test_utils_check_region (COGL_FRAMEBUFFER (offscreen),
+ 1, 1, 15, 15, 0xff0000ff);
else if (i == 1)
{
guint8 data[16 * 4 * 16];
@@ -169,30 +169,32 @@ test_flush (TestState *state)
/* Third time try drawing the texture to the screen */
cogl_set_source_texture (tex);
cogl_rectangle (-1, -1, 1, 1);
- test_utils_check_region (2, 2, /* x/y */
+ test_utils_check_region (fb,
+ 2, 2, /* x/y */
state->fb_width - 4,
state->fb_height - 4,
0xff0000ff);
}
cogl_object_unref (tex_2d);
- cogl_handle_unref (offscreen);
+ cogl_object_unref (offscreen);
}
}
void
-test_cogl_offscreen (TestUtilsGTestFixture *fixture,
- void *data)
+test_offscreen (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- state.context = shared_state->ctx;
- state.fb_width = cogl_framebuffer_get_width (shared_state->fb);
- state.fb_height = cogl_framebuffer_get_height (shared_state->fb);
+ state.fb_width = cogl_framebuffer_get_width (fb);
+ state.fb_height = cogl_framebuffer_get_height (fb);
+ /* XXX: we have to push/pop a framebuffer since this test currently
+ * uses the legacy cogl_rectangle() api. */
+ cogl_push_framebuffer (fb);
test_paint (&state);
test_flush (&state);
+ cogl_pop_framebuffer ();
if (cogl_test_verbose ())
g_print ("OK\n");
diff --git a/tests/conform/test-path.c b/tests/conform/test-path.c
index 0310fd7..a7a6f3c 100644
--- a/tests/conform/test-path.c
+++ b/tests/conform/test-path.c
@@ -17,10 +17,10 @@ typedef struct _TestState
static void
draw_path_at (int x, int y)
{
- cogl_push_matrix ();
- cogl_translate (x * BLOCK_SIZE, y * BLOCK_SIZE, 0.0f);
+ cogl_framebuffer_push_matrix (fb);
+ cogl_framebuffer_translate (fb, x * BLOCK_SIZE, y * BLOCK_SIZE, 0.0f);
cogl_path_fill ();
- cogl_pop_matrix ();
+ cogl_framebuffer_pop_matrix (fb);
}
static void
@@ -33,12 +33,12 @@ check_block (int block_x, int block_y, int block_mask)
filled. The bits from 0->3 represent the top left, top right,
bottom left and bottom right respectively */
- cogl_read_pixels (block_x * BLOCK_SIZE,
- block_y * BLOCK_SIZE,
- BLOCK_SIZE, BLOCK_SIZE,
- COGL_READ_PIXELS_COLOR_BUFFER,
- COGL_PIXEL_FORMAT_RGBA_8888_PRE,
- (guint8 *)data);
+ cogl_framebuffer_read_pixels (fb,
+ block_x * BLOCK_SIZE,
+ block_y * BLOCK_SIZE,
+ BLOCK_SIZE, BLOCK_SIZE,
+ COGL_PIXEL_FORMAT_RGBA_8888_PRE,
+ (guint8 *)data);
for (qy = 0; qy < 2; qy++)
for (qx = 0; qx < 2; qx++)
@@ -188,17 +188,22 @@ validate_result ()
}
void
-test_cogl_path (TestUtilsGTestFixture *fixture,
- void *data)
+test_path (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- cogl_ortho (0, cogl_framebuffer_get_width (shared_state->fb), /* left, right */
- cogl_framebuffer_get_height (shared_state->fb), 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ cogl_framebuffer_get_width (fb),
+ cogl_framebuffer_get_height (fb),
+ -1,
+ 100);
+ /* XXX: we have to push/pop a framebuffer since this test currently
+ * uses the legacy cogl_rectangle() api. */
+ cogl_push_framebuffer (fb);
paint (&state);
+ cogl_pop_framebuffer ();
validate_result ();
if (cogl_test_verbose ())
diff --git a/tests/conform/test-pipeline-uniforms.c b/tests/conform/test-pipeline-uniforms.c
index cfc62fb..da7b86b 100644
--- a/tests/conform/test-pipeline-uniforms.c
+++ b/tests/conform/test-pipeline-uniforms.c
@@ -8,8 +8,6 @@
typedef struct _TestState
{
- CoglContext *ctx;
-
CoglPipeline *pipeline_red;
CoglPipeline *pipeline_green;
CoglPipeline *pipeline_blue;
@@ -92,7 +90,7 @@ create_pipeline_for_shader (TestState *state, const char *shader_source)
CoglHandle shader;
CoglHandle program;
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT);
cogl_shader_source (shader, shader_source);
@@ -179,9 +177,8 @@ destroy_state (TestState *state)
static void
paint_pipeline (CoglPipeline *pipeline, int pos)
{
- cogl_push_source (pipeline);
- cogl_rectangle (pos * 10, 0, pos * 10 + 10, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline,
+ pos * 10, 0, pos * 10 + 10, 10);
}
static void
@@ -343,10 +340,7 @@ paint_long_pipeline (TestState *state)
static void
paint (TestState *state)
{
- CoglColor color;
-
- cogl_color_init_from_4ub (&color, 0, 0, 0, 255);
- cogl_clear (&color, COGL_BUFFER_BIT_COLOR);
+ cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
paint_color_pipelines (state);
paint_matrix_pipeline (state->matrix_pipeline);
@@ -357,7 +351,7 @@ paint (TestState *state)
static void
check_pos (int pos, guint32 color)
{
- test_utils_check_pixel (pos * 10 + 5, 5, color);
+ test_utils_check_pixel (fb, pos * 10 + 5, 5, color);
}
static void
@@ -387,26 +381,21 @@ validate_long_pipeline_result (void)
}
void
-test_cogl_pipeline_uniforms (TestUtilsGTestFixture *fixture,
- void *user_data)
+test_pipeline_uniforms (void)
{
- TestUtilsSharedState *shared_state = user_data;
-
/* If shaders aren't supported then we can't run the test */
if (cogl_features_available (COGL_FEATURE_SHADERS_GLSL))
{
TestState state;
- state.ctx = shared_state->ctx;
-
init_state (&state);
- cogl_ortho (/* left, right */
- 0, cogl_framebuffer_get_width (shared_state->fb),
- /* bottom, top */
- cogl_framebuffer_get_height (shared_state->fb), 0,
- /* z near, far */
- -1, 100);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ cogl_framebuffer_get_width (fb),
+ cogl_framebuffer_get_height (fb),
+ -1,
+ 100);
paint (&state);
validate_result ();
diff --git a/tests/conform/test-pipeline-user-matrix.c b/tests/conform/test-pipeline-user-matrix.c
index fa6e6dc..6f1b34a 100644
--- a/tests/conform/test-pipeline-user-matrix.c
+++ b/tests/conform/test-pipeline-user-matrix.c
@@ -6,7 +6,6 @@
typedef struct _TestState
{
- CoglContext *ctx;
int width;
int height;
} TestState;
@@ -23,10 +22,9 @@ validate_result (TestState *state)
verify this by reading back the entire stage */
pixels = g_malloc (state->width * state->height * 4);
- cogl_read_pixels (0, 0, state->width, state->height,
- COGL_READ_PIXELS_COLOR_BUFFER,
- COGL_PIXEL_FORMAT_RGBA_8888_PRE,
- (guint8 *)pixels);
+ cogl_framebuffer_read_pixels (fb, 0, 0, state->width, state->height,
+ COGL_PIXEL_FORMAT_RGBA_8888_PRE,
+ (guint8 *)pixels);
for (p = pixels; p < pixels + state->width * state->height; p++)
{
@@ -53,21 +51,22 @@ paint (TestState *state)
0xff, 0x00, 0xff, /* magenta -> becomes bottom right */
0x00, 0xff, 0xff /* cyan -> becomes bottom left */
};
- CoglColor bg;
- CoglHandle tex0, tex1;
+ CoglTexture *tex0, *tex1;
CoglPipeline *pipeline;
CoglMatrix matrix;
GError *error = NULL;
- cogl_ortho (0, state->width, /* left, right */
- state->height, 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ state->width,
+ state->height,
+ -1,
+ 100);
- cogl_color_init_from_4ub (&bg, 0, 0, 0, 255);
- cogl_clear (&bg, COGL_BUFFER_BIT_COLOR);
+ cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
cogl_matrix_init_identity (&matrix);
- cogl_set_modelview_matrix (&matrix);
+ cogl_framebuffer_set_modelview_matrix (fb, &matrix);
tex0 = cogl_texture_new_from_data (2, 2,
COGL_TEXTURE_NO_ATLAS,
@@ -82,7 +81,7 @@ paint (TestState *state)
6,
data1);
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
/* Set the two textures as layers */
cogl_pipeline_set_layer_texture (pipeline, 0, tex0);
@@ -115,25 +114,23 @@ paint (TestState *state)
cogl_matrix_scale (&matrix, -1.0f, 1.0f, 1.0f);
cogl_pipeline_set_layer_matrix (pipeline, 1, &matrix);
- cogl_set_source (pipeline);
- cogl_rectangle (0, 0, state->width, state->height);
+ cogl_framebuffer_draw_rectangle (fb,
+ pipeline,
+ 0, 0,
+ state->width, state->height);
- cogl_handle_unref (tex1);
- cogl_handle_unref (tex0);
+ cogl_object_unref (tex1);
+ cogl_object_unref (tex0);
cogl_object_unref (pipeline);
}
void
-test_cogl_pipeline_user_matrix (TestUtilsGTestFixture *fixture,
- void *data)
+test_pipeline_user_matrix (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- state.ctx = shared_state->ctx;
-
- state.width = cogl_framebuffer_get_width (shared_state->fb);
- state.height = cogl_framebuffer_get_height (shared_state->fb);
+ state.width = cogl_framebuffer_get_width (fb);
+ state.height = cogl_framebuffer_get_height (fb);
paint (&state);
validate_result (&state);
diff --git a/tests/conform/test-pixel-buffer.c b/tests/conform/test-pixel-buffer.c
index 5368feb..393f40a 100644
--- a/tests/conform/test-pixel-buffer.c
+++ b/tests/conform/test-pixel-buffer.c
@@ -188,11 +188,15 @@ draw_frame (TestState *state)
/* Paint the textures */
for (i = 0; i < NB_TILES; i++)
{
- cogl_set_source_texture (state->tiles[i].texture);
- cogl_rectangle (state->tiles[i].x,
- state->tiles[i].y,
- state->tiles[i].x + TILE_SIZE,
- state->tiles[i].y + TILE_SIZE);
+ CoglPipeline *pipeline = cogl_pipeline_new (ctx);
+ cogl_pipeline_set_layer_texture (pipeline, 0, state->tiles[i].texture);
+ cogl_framebuffer_draw_rectangle (fb,
+ pipeline,
+ state->tiles[i].x,
+ state->tiles[i].y,
+ state->tiles[i].x + TILE_SIZE,
+ state->tiles[i].y + TILE_SIZE);
+ cogl_object_unref (pipeline);
}
}
@@ -201,7 +205,8 @@ static void
validate_tile (TestState *state,
TestTile *tile)
{
- test_utils_check_region (tile->x, tile->y,
+ test_utils_check_region (fb,
+ tile->x, tile->y,
TILE_SIZE, TILE_SIZE,
(tile->color[0] << 24) |
(tile->color[1] << 16) |
@@ -219,10 +224,8 @@ validate_result (TestState *state)
}
void
-test_cogl_pixel_buffer (TestUtilsGTestFixture *fixture,
- void *data)
+test_pixel_buffer (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
int i;
static TestTile tiles[NB_TILES] =
@@ -239,17 +242,20 @@ test_cogl_pixel_buffer (TestUtilsGTestFixture *fixture,
{ { 0x7e, 0xff, 0x7e, 0xff }, 0.0f, TILE_SIZE, NULL, NULL }
};
- state.width = cogl_framebuffer_get_width (shared_state->fb);
- state.height = cogl_framebuffer_get_height (shared_state->fb);
- cogl_ortho (0, state.width, /* left, right */
- state.height, 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ state.width = cogl_framebuffer_get_width (fb);
+ state.height = cogl_framebuffer_get_height (fb);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ state.width,
+ state.height,
+ -1,
+ 100);
- create_map_tile (shared_state->ctx, &tiles[TILE_MAP]);
+ create_map_tile (ctx, &tiles[TILE_MAP]);
#if 0
create_set_region_tile (shared_state->ctx, &tiles[TILE_SET_REGION]);
#endif
- create_set_data_tile (shared_state->ctx, &tiles[TILE_SET_DATA]);
+ create_set_data_tile (ctx, &tiles[TILE_SET_DATA]);
state.tiles = tiles;
diff --git a/tests/conform/test-point-size.c b/tests/conform/test-point-size.c
index 41861a4..6f114d3 100644
--- a/tests/conform/test-point-size.c
+++ b/tests/conform/test-point-size.c
@@ -37,30 +37,28 @@ verify_point_size (CoglFramebuffer *fb,
gboolean in_point = x >= 1 && x <= 2 && y >= 1 && y <= 2;
guint32 expected_pixel = in_point ? 0x00ff00ff : 0xff0000ff;
- test_utils_check_pixel (calc_coord_offset (x_pos, x, point_size),
+ test_utils_check_pixel (fb,
+ calc_coord_offset (x_pos, x, point_size),
calc_coord_offset (y_pos, y, point_size),
expected_pixel);
}
}
void
-test_cogl_point_size (TestUtilsGTestFixture *fixture,
- void *data)
+test_point_size (void)
{
- TestUtilsSharedState *shared_state = data;
- CoglContext *ctx = shared_state->ctx;
- int fb_width = cogl_framebuffer_get_width (shared_state->fb);
- int fb_height = cogl_framebuffer_get_height (shared_state->fb);
+ int fb_width = cogl_framebuffer_get_width (fb);
+ int fb_height = cogl_framebuffer_get_height (fb);
int point_size;
int x_pos;
- cogl_framebuffer_orthographic (shared_state->fb,
+ cogl_framebuffer_orthographic (fb,
0, 0, /* x_1, y_1 */
fb_width, /* x_2 */
fb_height /* y_2 */,
-1, 100 /* near/far */);
- cogl_framebuffer_clear4f (shared_state->fb,
+ cogl_framebuffer_clear4f (fb,
COGL_BUFFER_BIT_COLOR,
1.0f, 0.0f, 0.0f, 1.0f);
@@ -81,7 +79,7 @@ test_cogl_point_size (TestUtilsGTestFixture *fixture,
cogl_pipeline_set_point_size (pipeline, point_size);
cogl_pipeline_set_color4ub (pipeline, 0, 255, 0, 255);
- cogl_framebuffer_draw_primitive (shared_state->fb,
+ cogl_framebuffer_draw_primitive (fb,
pipeline,
prim);
@@ -93,7 +91,7 @@ test_cogl_point_size (TestUtilsGTestFixture *fixture,
for (x_pos = 0, point_size = MAX_POINT_SIZE;
point_size >= 4;
x_pos += POINT_BOX_SIZE, point_size /= 2)
- verify_point_size (shared_state->fb,
+ verify_point_size (fb,
x_pos + POINT_BOX_SIZE / 2,
POINT_BOX_SIZE / 2,
point_size);
diff --git a/tests/conform/test-point-sprite.c b/tests/conform/test-point-sprite.c
index dc23e8a..d8c450e 100644
--- a/tests/conform/test-point-sprite.c
+++ b/tests/conform/test-point-sprite.c
@@ -19,26 +19,23 @@ tex_data[3 * 2 * 2] =
};
void
-test_cogl_point_sprite (TestUtilsGTestFixture *fixture,
- void *data)
+test_point_sprite (void)
{
- TestUtilsSharedState *shared_state = data;
- CoglContext *ctx = shared_state->ctx;
- int fb_width = cogl_framebuffer_get_width (shared_state->fb);
- int fb_height = cogl_framebuffer_get_height (shared_state->fb);
+ int fb_width = cogl_framebuffer_get_width (fb);
+ int fb_height = cogl_framebuffer_get_height (fb);
CoglPrimitive *prim;
GError *error = NULL;
CoglTexture2D *tex_2d;
CoglPipeline *pipeline, *solid_pipeline;
gboolean res;
- cogl_framebuffer_orthographic (shared_state->fb,
+ cogl_framebuffer_orthographic (fb,
0, 0, /* x_1, y_1 */
fb_width, /* x_2 */
fb_height /* y_2 */,
-1, 100 /* near/far */);
- cogl_framebuffer_clear4f (shared_state->fb,
+ cogl_framebuffer_clear4f (fb,
COGL_BUFFER_BIT_COLOR,
1.0f, 1.0f, 1.0f, 1.0f);
@@ -75,7 +72,7 @@ test_cogl_point_sprite (TestUtilsGTestFixture *fixture,
1, /* n_vertices */
&point);
- cogl_framebuffer_draw_primitive (shared_state->fb,
+ cogl_framebuffer_draw_primitive (fb,
pipeline,
prim);
@@ -88,38 +85,43 @@ test_cogl_point_sprite (TestUtilsGTestFixture *fixture,
/* enable */
FALSE,
&error);
- cogl_framebuffer_push_matrix (shared_state->fb);
- cogl_framebuffer_translate (shared_state->fb,
+ cogl_framebuffer_push_matrix (fb);
+ cogl_framebuffer_translate (fb,
POINT_SIZE * 2, /* x */
0.0f, /* y */
0.0f /* z */);
- cogl_framebuffer_draw_primitive (shared_state->fb,
+ cogl_framebuffer_draw_primitive (fb,
solid_pipeline,
prim);
- cogl_framebuffer_pop_matrix (shared_state->fb);
+ cogl_framebuffer_pop_matrix (fb);
cogl_object_unref (prim);
cogl_object_unref (solid_pipeline);
cogl_object_unref (pipeline);
cogl_object_unref (tex_2d);
- test_utils_check_pixel (POINT_SIZE - POINT_SIZE / 4,
+ test_utils_check_pixel (fb,
+ POINT_SIZE - POINT_SIZE / 4,
POINT_SIZE - POINT_SIZE / 4,
0x0000ffff);
- test_utils_check_pixel (POINT_SIZE + POINT_SIZE / 4,
+ test_utils_check_pixel (fb,
+ POINT_SIZE + POINT_SIZE / 4,
POINT_SIZE - POINT_SIZE / 4,
0x00ff00ff);
- test_utils_check_pixel (POINT_SIZE - POINT_SIZE / 4,
+ test_utils_check_pixel (fb,
+ POINT_SIZE - POINT_SIZE / 4,
POINT_SIZE + POINT_SIZE / 4,
0x00ffffff);
- test_utils_check_pixel (POINT_SIZE + POINT_SIZE / 4,
+ test_utils_check_pixel (fb,
+ POINT_SIZE + POINT_SIZE / 4,
POINT_SIZE + POINT_SIZE / 4,
0xff0000ff);
/* When rendering without the point sprites all of the texture
coordinates should be 0,0 so it should get the top-left texel
which is blue */
- test_utils_check_region (POINT_SIZE * 3 - POINT_SIZE / 2 + 1,
+ test_utils_check_region (fb,
+ POINT_SIZE * 3 - POINT_SIZE / 2 + 1,
POINT_SIZE - POINT_SIZE / 2 + 1,
POINT_SIZE - 2, POINT_SIZE - 2,
0x0000ffff);
diff --git a/tests/conform/test-premult.c b/tests/conform/test-premult.c
index 8ea1168..0326ce6 100644
--- a/tests/conform/test-premult.c
+++ b/tests/conform/test-premult.c
@@ -287,7 +287,7 @@ queue_redraw (gpointer stage)
}
void
-test_cogl_premult (TestUtilsGTestFixture *fixture,
+test_premult (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
diff --git a/tests/conform/test-primitive.c b/tests/conform/test-primitive.c
index 1118d9d..3dc5820 100644
--- a/tests/conform/test-primitive.c
+++ b/tests/conform/test-primitive.c
@@ -6,10 +6,8 @@
typedef struct _TestState
{
- CoglContext *ctx;
int fb_width;
int fb_height;
- CoglFramebuffer *fb;
} TestState;
#define PRIM_COLOR 0xff00ffff
@@ -178,7 +176,7 @@ test_paint (TestState *state)
COGL_PIXEL_FORMAT_ANY,
6, /* rowstride */
tex_data);
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4ub (pipeline,
(PRIM_COLOR >> 24) & 0xff,
(PRIM_COLOR >> 16) & 0xff,
@@ -192,14 +190,14 @@ test_paint (TestState *state)
CoglPrimitive *prim;
guint32 expected_color = PRIM_COLOR;
- prim = test_prim_funcs[i] (state->ctx, &expected_color);
+ prim = test_prim_funcs[i] (ctx, &expected_color);
- cogl_push_matrix ();
- cogl_translate (i * 10, 0, 0);
- cogl_framebuffer_draw_primitive (state->fb, pipeline, prim);
- cogl_pop_matrix ();
+ cogl_framebuffer_push_matrix (fb);
+ cogl_framebuffer_translate (fb, i * 10, 0, 0);
+ cogl_framebuffer_draw_primitive (fb, pipeline, prim);
+ cogl_framebuffer_pop_matrix (fb);
- test_utils_check_pixel (i * 10 + 2, 2, expected_color);
+ test_utils_check_pixel (fb, i * 10 + 2, 2, expected_color);
cogl_object_unref (prim);
}
@@ -236,7 +234,7 @@ test_copy (TestState *state)
{
static const guint16 indices_data[2] = { 1, 2 };
CoglAttributeBuffer *buffer =
- cogl_attribute_buffer_new (state->ctx, 100, NULL);
+ cogl_attribute_buffer_new (ctx, 100, NULL);
CoglAttribute *attributes[N_ATTRIBS];
CoglAttribute *attributes_a[N_ATTRIBS], *attributes_b[N_ATTRIBS];
CoglAttribute **p;
@@ -261,7 +259,7 @@ test_copy (TestState *state)
attributes,
N_ATTRIBS);
- indices = cogl_indices_new (state->ctx,
+ indices = cogl_indices_new (ctx,
COGL_INDICES_TYPE_UNSIGNED_SHORT,
indices_data,
2 /* n_indices */);
@@ -314,20 +312,19 @@ test_copy (TestState *state)
}
void
-test_cogl_primitive (TestUtilsGTestFixture *fixture,
- void *data)
+test_primitive (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- state.ctx = shared_state->ctx;
- state.fb_width = cogl_framebuffer_get_width (shared_state->fb);
- state.fb_height = cogl_framebuffer_get_height (shared_state->fb);
- state.fb = shared_state->fb;
+ state.fb_width = cogl_framebuffer_get_width (fb);
+ state.fb_height = cogl_framebuffer_get_height (fb);
- cogl_ortho (0, state.fb_width, /* left, right */
- state.fb_height, 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ state.fb_width,
+ state.fb_height,
+ -1,
+ 100);
test_paint (&state);
test_copy (&state);
diff --git a/tests/conform/test-read-texture-formats.c b/tests/conform/test-read-texture-formats.c
index fe7c262..7161d0f 100644
--- a/tests/conform/test-read-texture-formats.c
+++ b/tests/conform/test-read-texture-formats.c
@@ -142,13 +142,11 @@ test_read_int (CoglTexture2D *tex_2d,
}
void
-test_cogl_read_texture_formats (TestUtilsGTestFixture *fixture,
- void *data)
+test_read_texture_formats (void)
{
- TestUtilsSharedState *shared_state = data;
CoglTexture2D *tex_2d;
- tex_2d = cogl_texture_2d_new_from_data (shared_state->ctx,
+ tex_2d = cogl_texture_2d_new_from_data (ctx,
1, 1, /* width / height */
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
diff --git a/tests/conform/test-readpixels.c b/tests/conform/test-readpixels.c
index eeb7499..c690a35 100644
--- a/tests/conform/test-readpixels.c
+++ b/tests/conform/test-readpixels.c
@@ -147,7 +147,7 @@ queue_redraw (gpointer stage)
}
void
-test_cogl_readpixels (TestUtilsGTestFixture *fixture,
+test_readpixels (TestUtilsGTestFixture *fixture,
void *data)
{
unsigned int idle_source;
diff --git a/tests/conform/test-snippets.c b/tests/conform/test-snippets.c
index 041e2cc..cf6d778 100644
--- a/tests/conform/test-snippets.c
+++ b/tests/conform/test-snippets.c
@@ -6,8 +6,7 @@
typedef struct _TestState
{
- CoglContext *ctx;
- CoglFramebuffer *fb;
+ int padding;
} TestState;
typedef void (* SnippetTestFunc) (TestState *state);
@@ -16,7 +15,7 @@ static CoglPipeline *
create_texture_pipeline (TestState *state)
{
CoglPipeline *pipeline;
- CoglHandle tex;
+ CoglTexture *tex;
static const guint8 tex_data[] =
{
0xff, 0x00, 0x00, 0xff, /* red */ 0x00, 0xff, 0x00, 0xff, /* green */
@@ -30,7 +29,7 @@ create_texture_pipeline (TestState *state)
8, /* rowstride */
tex_data);
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_layer_texture (pipeline, 0, tex);
@@ -38,7 +37,7 @@ create_texture_pipeline (TestState *state)
COGL_PIPELINE_FILTER_NEAREST,
COGL_PIPELINE_FILTER_NEAREST);
- cogl_handle_unref (tex);
+ cogl_object_unref (tex);
return pipeline;
}
@@ -50,7 +49,7 @@ simple_fragment_snippet (TestState *state)
CoglSnippet *snippet;
/* Simple fragment snippet */
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4ub (pipeline, 255, 0, 0, 255);
@@ -60,13 +59,11 @@ simple_fragment_snippet (TestState *state)
cogl_pipeline_add_snippet (pipeline, snippet);
cogl_object_unref (snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (0, 0, 10, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 0, 0, 10, 10);
cogl_object_unref (pipeline);
- test_utils_check_pixel (5, 5, 0xffff00ff);
+ test_utils_check_pixel (fb, 5, 5, 0xffff00ff);
}
static void
@@ -76,7 +73,7 @@ simple_vertex_snippet (TestState *state)
CoglSnippet *snippet;
/* Simple vertex snippet */
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4ub (pipeline, 255, 0, 0, 255);
@@ -86,13 +83,11 @@ simple_vertex_snippet (TestState *state)
cogl_pipeline_add_snippet (pipeline, snippet);
cogl_object_unref (snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (10, 0, 20, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 10, 0, 20, 10);
cogl_object_unref (pipeline);
- test_utils_check_pixel (15, 5, 0xff00ffff);
+ test_utils_check_pixel (fb, 15, 5, 0xff00ffff);
}
static void
@@ -104,7 +99,7 @@ shared_uniform (TestState *state)
/* Snippets sharing a uniform across the vertex and fragment
hooks */
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
location = cogl_pipeline_get_uniform_location (pipeline, "a_value");
cogl_pipeline_set_uniform_1f (pipeline, location, 0.25f);
@@ -122,13 +117,13 @@ shared_uniform (TestState *state)
cogl_pipeline_add_snippet (pipeline, snippet);
cogl_object_unref (snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (20, 0, 30, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb,
+ pipeline,
+ 20, 0, 30, 10);
cogl_object_unref (pipeline);
- test_utils_check_pixel (25, 5, 0xff0080ff);
+ test_utils_check_pixel (fb, 25, 5, 0xff0080ff);
}
static void
@@ -140,7 +135,7 @@ lots_snippets (TestState *state)
int i;
/* Lots of snippets on one pipeline */
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4ub (pipeline, 0, 0, 0, 255);
@@ -168,13 +163,11 @@ lots_snippets (TestState *state)
g_free (declarations);
}
- cogl_push_source (pipeline);
- cogl_rectangle (30, 0, 40, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 30, 0, 40, 10);
cogl_object_unref (pipeline);
- test_utils_check_pixel (35, 5, 0x19334cff);
+ test_utils_check_pixel (fb, 35, 5, 0x19334cff);
}
static void
@@ -185,7 +178,7 @@ shared_variable_pre_post (TestState *state)
/* Test that the pre string can declare variables used by the post
string */
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4ub (pipeline, 255, 255, 255, 255);
@@ -196,13 +189,11 @@ shared_variable_pre_post (TestState *state)
cogl_pipeline_add_snippet (pipeline, snippet);
cogl_object_unref (snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (40, 0, 50, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 40, 0, 50, 10);
cogl_object_unref (pipeline);
- test_utils_check_pixel (45, 5, 0xff0000ff);
+ test_utils_check_pixel (fb, 45, 5, 0xff0000ff);
}
static void
@@ -223,24 +214,20 @@ test_pipeline_caching (TestState *state)
" unrelated pipelines */",
"cogl_color_out = vec4 (0.0, 1.0, 0.0, 1.0);\n");
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_add_snippet (pipeline, snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (50, 0, 60, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 50, 0, 60, 10);
cogl_object_unref (pipeline);
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_add_snippet (pipeline, snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (60, 0, 70, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 60, 0, 70, 10);
cogl_object_unref (pipeline);
cogl_object_unref (snippet);
- test_utils_check_pixel (55, 5, 0x00ff00ff);
- test_utils_check_pixel (65, 5, 0x00ff00ff);
+ test_utils_check_pixel (fb, 55, 5, 0x00ff00ff);
+ test_utils_check_pixel (fb, 65, 5, 0x00ff00ff);
}
static void
@@ -260,16 +247,14 @@ test_replace_string (TestState *state)
cogl_snippet_set_post (snippet,
"cogl_color_out += vec4 (0.5, 0.0, 0.0, 1.0);");
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_add_snippet (pipeline, snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (70, 0, 80, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 70, 0, 80, 10);
cogl_object_unref (pipeline);
cogl_object_unref (snippet);
- test_utils_check_pixel (75, 5, 0x808000ff);
+ test_utils_check_pixel (fb, 75, 5, 0x808000ff);
}
static void
@@ -288,15 +273,15 @@ test_texture_lookup_hook (TestState *state)
pipeline = create_texture_pipeline (state);
cogl_pipeline_add_layer_snippet (pipeline, 0, snippet);
- cogl_push_source (pipeline);
- cogl_rectangle_with_texture_coords (80, 0, 90, 10,
- 0, 0, 0, 0);
- cogl_pop_source ();
+ cogl_framebuffer_draw_textured_rectangle (fb,
+ pipeline,
+ 80, 0, 90, 10,
+ 0, 0, 0, 0);
cogl_object_unref (pipeline);
cogl_object_unref (snippet);
- test_utils_check_pixel (85, 5, 0x00ffffff);
+ test_utils_check_pixel (fb, 85, 5, 0x00ffffff);
}
static void
@@ -317,14 +302,12 @@ test_multiple_samples (TestState *state)
pipeline = create_texture_pipeline (state);
cogl_pipeline_add_layer_snippet (pipeline, 0, snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (0, 0, 10, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 0, 0, 10, 10);
cogl_object_unref (pipeline);
cogl_object_unref (snippet);
- test_utils_check_pixel (5, 5, 0xffff00ff);
+ test_utils_check_pixel (fb, 5, 5, 0xffff00ff);
}
static void
@@ -339,15 +322,15 @@ test_replace_lookup_hook (TestState *state)
pipeline = create_texture_pipeline (state);
cogl_pipeline_add_layer_snippet (pipeline, 0, snippet);
- cogl_push_source (pipeline);
- cogl_rectangle_with_texture_coords (90, 0, 100, 10,
- 0, 0, 0, 0);
- cogl_pop_source ();
+ cogl_framebuffer_draw_textured_rectangle (fb,
+ pipeline,
+ 90, 0, 100, 10,
+ 0, 0, 0, 0);
cogl_object_unref (pipeline);
cogl_object_unref (snippet);
- test_utils_check_pixel (95, 5, 0x0000ffff);
+ test_utils_check_pixel (fb, 95, 5, 0x0000ffff);
}
static void
@@ -372,13 +355,13 @@ test_replace_snippet (TestState *state)
cogl_pipeline_add_snippet (pipeline, snippet);
cogl_object_unref (snippet);
- cogl_push_source (pipeline);
- cogl_rectangle_with_texture_coords (100, 0, 110, 10,
- 0, 0, 0, 0);
- cogl_pop_source ();
+ cogl_framebuffer_draw_textured_rectangle (fb,
+ pipeline,
+ 100, 0, 110, 10,
+ 0, 0, 0, 0);
cogl_object_unref (pipeline);
- test_utils_check_pixel (105, 5, 0xff0000ff);
+ test_utils_check_pixel (fb, 105, 5, 0xff0000ff);
}
static void
@@ -404,13 +387,13 @@ test_replace_fragment_layer (TestState *state)
"A = REPLACE(PREVIOUS)",
NULL);
- cogl_push_source (pipeline);
- cogl_rectangle_with_texture_coords (110, 0, 120, 10,
- 0, 0, 0, 0);
- cogl_pop_source ();
+ cogl_framebuffer_draw_textured_rectangle (fb,
+ pipeline,
+ 110, 0, 120, 10,
+ 0, 0, 0, 0);
cogl_object_unref (pipeline);
- test_utils_check_pixel (115, 5, 0xff00ffff);
+ test_utils_check_pixel (fb, 115, 5, 0xff00ffff);
}
static void
@@ -420,7 +403,7 @@ test_modify_fragment_layer (TestState *state)
CoglSnippet *snippet;
/* Test modifying the fragment layer code */
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_uniform_1f (pipeline,
cogl_pipeline_get_uniform_location (pipeline,
@@ -433,13 +416,13 @@ test_modify_fragment_layer (TestState *state)
cogl_pipeline_add_layer_snippet (pipeline, 0, snippet);
cogl_object_unref (snippet);
- cogl_push_source (pipeline);
- cogl_rectangle_with_texture_coords (120, 0, 130, 10,
- 0, 0, 0, 0);
- cogl_pop_source ();
+ cogl_framebuffer_draw_textured_rectangle (fb,
+ pipeline,
+ 120, 0, 130, 10,
+ 0, 0, 0, 0);
cogl_object_unref (pipeline);
- test_utils_check_pixel (125, 5, 0xff80ffff);
+ test_utils_check_pixel (fb, 125, 5, 0xff80ffff);
}
static void
@@ -462,13 +445,13 @@ test_modify_vertex_layer (TestState *state)
cogl_pipeline_add_layer_snippet (pipeline, 0, snippet);
cogl_object_unref (snippet);
- cogl_push_source (pipeline);
- cogl_rectangle_with_texture_coords (130, 0, 140, 10,
- 0, 0, 0, 0);
- cogl_pop_source ();
+ cogl_framebuffer_draw_textured_rectangle (fb,
+ pipeline,
+ 130, 0, 140, 10,
+ 0, 0, 0, 0);
cogl_object_unref (pipeline);
- test_utils_check_pixel (135, 5, 0xffff00ff);
+ test_utils_check_pixel (fb, 135, 5, 0xffff00ff);
}
static void
@@ -492,13 +475,13 @@ test_replace_vertex_layer (TestState *state)
cogl_pipeline_add_layer_snippet (pipeline, 0, snippet);
cogl_object_unref (snippet);
- cogl_push_source (pipeline);
- cogl_rectangle_with_texture_coords (140, 0, 150, 10,
- 0, 0, 0, 0);
- cogl_pop_source ();
+ cogl_framebuffer_draw_textured_rectangle (fb,
+ pipeline,
+ 140, 0, 150, 10,
+ 0, 0, 0, 0);
cogl_object_unref (pipeline);
- test_utils_check_pixel (145, 5, 0x00ff00ff);
+ test_utils_check_pixel (fb, 145, 5, 0x00ff00ff);
}
static void
@@ -514,7 +497,7 @@ test_vertex_transform_hook (TestState *state)
cogl_matrix_init_identity (&identity_matrix);
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4ub (pipeline, 255, 0, 255, 255);
@@ -527,7 +510,7 @@ test_vertex_transform_hook (TestState *state)
cogl_object_unref (snippet);
/* Copy the current projection matrix to a uniform */
- cogl_get_projection_matrix (&matrix);
+ cogl_framebuffer_get_projection_matrix (fb, &matrix);
location = cogl_pipeline_get_uniform_location (pipeline, "pmat");
cogl_pipeline_set_uniform_matrix (pipeline,
location,
@@ -538,17 +521,15 @@ test_vertex_transform_hook (TestState *state)
/* Replace the real projection matrix with the identity. This should
mess up the drawing unless the snippet replacement is working */
- cogl_set_projection_matrix (&identity_matrix);
+ cogl_framebuffer_set_projection_matrix (fb, &identity_matrix);
- cogl_push_source (pipeline);
- cogl_rectangle (150, 0, 160, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 150, 0, 160, 10);
cogl_object_unref (pipeline);
/* Restore the projection matrix */
- cogl_set_projection_matrix (&matrix);
+ cogl_framebuffer_set_projection_matrix (fb, &matrix);
- test_utils_check_pixel (155, 5, 0xff00ffff);
+ test_utils_check_pixel (fb, 155, 5, 0xff00ffff);
}
static void
@@ -564,7 +545,7 @@ test_snippet_order (TestState *state)
sections in the same order as they were added. Therefore the r
component should be taken from the the second snippet and the g
component from the first */
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4ub (pipeline, 0, 0, 0, 255);
@@ -583,12 +564,10 @@ test_snippet_order (TestState *state)
cogl_pipeline_add_snippet (pipeline, snippet);
cogl_object_unref (snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (160, 0, 170, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 160, 0, 170, 10);
cogl_object_unref (pipeline);
- test_utils_check_pixel (165, 5, 0x80ff00ff);
+ test_utils_check_pixel (fb, 165, 5, 0x80ff00ff);
}
static void
@@ -609,26 +588,24 @@ test_naming_texture_units (TestState *state)
"texture2D (cogl_sampler100, vec2 (0.0, 0.0)) + "
"texture2D (cogl_sampler200, vec2 (0.0, 0.0));");
- tex1 = test_utils_create_color_texture (state->ctx, 0xff0000ff);
- tex2 = test_utils_create_color_texture (state->ctx, 0x00ff00ff);
+ tex1 = test_utils_create_color_texture (ctx, 0xff0000ff);
+ tex2 = test_utils_create_color_texture (ctx, 0x00ff00ff);
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_layer_texture (pipeline, 100, tex1);
cogl_pipeline_set_layer_texture (pipeline, 200, tex2);
cogl_pipeline_add_snippet (pipeline, snippet);
- cogl_push_source (pipeline);
- cogl_rectangle (0, 0, 10, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 0, 0, 10, 10);
cogl_object_unref (pipeline);
cogl_object_unref (snippet);
cogl_object_unref (tex1);
cogl_object_unref (tex2);
- test_utils_check_pixel (5, 5, 0xffff00ff);
+ test_utils_check_pixel (fb, 5, 5, 0xffff00ff);
}
static void
@@ -703,7 +680,7 @@ run_tests (TestState *state)
for (i = 0; i < G_N_ELEMENTS (tests); i++)
{
- cogl_framebuffer_clear4f (state->fb,
+ cogl_framebuffer_clear4f (fb,
COGL_BUFFER_BIT_COLOR,
0, 0, 0, 1);
@@ -712,25 +689,19 @@ run_tests (TestState *state)
}
void
-test_cogl_snippets (TestUtilsGTestFixture *fixture,
- void *user_data)
+test_snippets (void)
{
- TestUtilsSharedState *shared_state = user_data;
-
/* If shaders aren't supported then we can't run the test */
if (cogl_features_available (COGL_FEATURE_SHADERS_GLSL))
{
TestState state;
- state.ctx = shared_state->ctx;
- state.fb = shared_state->fb;
-
- cogl_ortho (/* left, right */
- 0, cogl_framebuffer_get_width (shared_state->fb),
- /* bottom, top */
- cogl_framebuffer_get_height (shared_state->fb), 0,
- /* z near, far */
- -1, 100);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ cogl_framebuffer_get_width (fb),
+ cogl_framebuffer_get_height (fb),
+ -1,
+ 100);
run_tests (&state);
diff --git a/tests/conform/test-sparse-pipeline.c b/tests/conform/test-sparse-pipeline.c
index b6848b4..a88f50b 100644
--- a/tests/conform/test-sparse-pipeline.c
+++ b/tests/conform/test-sparse-pipeline.c
@@ -5,10 +5,8 @@
typedef struct _TestState
{
- CoglContext *ctx;
int fb_width;
int fb_height;
- CoglFramebuffer *fb;
} TestState;
static void
@@ -17,17 +15,17 @@ test_sparse_layer_combine (TestState *state)
CoglPipeline *pipeline;
CoglTexture *tex1, *tex2;
- cogl_framebuffer_clear4f (state->fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
+ cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
/* This tests that the TEXTURE_* numbers used in the layer combine
string refer to the layer number rather than the unit numbers by
creating a pipeline with very large layer numbers. This should
end up being mapped to much smaller unit numbers */
- tex1 = test_utils_create_color_texture (state->ctx, 0xff0000ff);
- tex2 = test_utils_create_color_texture (state->ctx, 0x00ff00ff);
+ tex1 = test_utils_create_color_texture (ctx, 0xff0000ff);
+ tex2 = test_utils_create_color_texture (ctx, 0x00ff00ff);
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_layer_texture (pipeline, 50, tex1);
cogl_pipeline_set_layer_texture (pipeline, 100, tex2);
@@ -35,11 +33,9 @@ test_sparse_layer_combine (TestState *state)
"RGBA = ADD(TEXTURE_50, TEXTURE_100)",
NULL);
- cogl_push_source (pipeline);
- cogl_rectangle (-1, -1, 1, 1);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, -1, -1, 1, 1);
- test_utils_check_pixel (2, 2, 0xffff00ff);
+ test_utils_check_pixel (fb, 2, 2, 0xffff00ff);
cogl_object_unref (pipeline);
cogl_object_unref (tex1);
@@ -47,16 +43,12 @@ test_sparse_layer_combine (TestState *state)
}
void
-test_cogl_sparse_pipeline (TestUtilsGTestFixture *fixture,
- void *data)
+test_sparse_pipeline (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- state.ctx = shared_state->ctx;
- state.fb_width = cogl_framebuffer_get_width (shared_state->fb);
- state.fb_height = cogl_framebuffer_get_height (shared_state->fb);
- state.fb = shared_state->fb;
+ state.fb_width = cogl_framebuffer_get_width (fb);
+ state.fb_height = cogl_framebuffer_get_height (fb);
test_sparse_layer_combine (&state);
diff --git a/tests/conform/test-sub-texture.c b/tests/conform/test-sub-texture.c
index 5bb23e2..261f4d7 100644
--- a/tests/conform/test-sub-texture.c
+++ b/tests/conform/test-sub-texture.c
@@ -22,7 +22,6 @@ corner_colors[SOURCE_DIVISIONS_X * SOURCE_DIVISIONS_Y] =
typedef struct _TestState
{
- CoglContext *ctx;
CoglTexture2D *tex;
} TestState;
@@ -56,7 +55,7 @@ create_source (TestState *state)
}
}
- tex = cogl_texture_2d_new_from_data (state->ctx,
+ tex = cogl_texture_2d_new_from_data (ctx,
SOURCE_SIZE, SOURCE_SIZE,
COGL_PIXEL_FORMAT_RGBA_8888,
COGL_PIXEL_FORMAT_ANY,
@@ -88,7 +87,7 @@ create_test_texture (TestState *state)
*(p++) = 255;
}
- tex = cogl_texture_2d_new_from_data (state->ctx,
+ tex = cogl_texture_2d_new_from_data (ctx,
256, 256,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
COGL_PIXEL_FORMAT_ANY,
@@ -107,9 +106,10 @@ paint (TestState *state)
{
CoglTexture2D *full_texture;
CoglSubTexture *sub_texture, *sub_sub_texture;
+ CoglPipeline *pipeline = cogl_pipeline_new (ctx);
/* Create a sub texture of the bottom right quarter of the texture */
- sub_texture = cogl_sub_texture_new (state->ctx,
+ sub_texture = cogl_sub_texture_new (ctx,
COGL_TEXTURE (state->tex),
DIVISION_WIDTH,
DIVISION_HEIGHT,
@@ -117,40 +117,47 @@ paint (TestState *state)
DIVISION_HEIGHT);
/* Paint it */
- cogl_set_source_texture (COGL_TEXTURE (sub_texture));
- cogl_rectangle (0.0f, 0.0f, DIVISION_WIDTH, DIVISION_HEIGHT);
-
+ cogl_pipeline_set_layer_texture (pipeline, 0, COGL_TEXTURE (sub_texture));
cogl_object_unref (sub_texture);
+ cogl_framebuffer_draw_rectangle (fb, pipeline,
+ 0.0f, 0.0f, DIVISION_WIDTH, DIVISION_HEIGHT);
+
/* Repeat a sub texture of the top half of the full texture. This is
documented to be undefined so it doesn't technically have to work
but it will with the current implementation */
- sub_texture = cogl_sub_texture_new (state->ctx,
+ sub_texture = cogl_sub_texture_new (ctx,
COGL_TEXTURE (state->tex),
0, 0,
SOURCE_SIZE,
DIVISION_HEIGHT);
- cogl_set_source_texture (COGL_TEXTURE (sub_texture));
- cogl_rectangle_with_texture_coords (0.0f, SOURCE_SIZE,
- SOURCE_SIZE * 2.0f, SOURCE_SIZE * 1.5f,
- 0.0f, 0.0f,
- 2.0f, 1.0f);
+ cogl_pipeline_set_layer_texture (pipeline, 0, COGL_TEXTURE (sub_texture));
cogl_object_unref (sub_texture);
+ cogl_framebuffer_draw_textured_rectangle (fb, pipeline,
+ 0.0f,
+ SOURCE_SIZE,
+ SOURCE_SIZE * 2.0f,
+ SOURCE_SIZE * 1.5f,
+ 0.0f, 0.0f,
+ 2.0f, 1.0f);
/* Create a sub texture of a sub texture */
full_texture = create_test_texture (state);
- sub_texture = cogl_sub_texture_new (state->ctx,
+ sub_texture = cogl_sub_texture_new (ctx,
COGL_TEXTURE (full_texture),
20, 10, 30, 20);
- sub_sub_texture = cogl_sub_texture_new (state->ctx,
+ cogl_object_unref (full_texture);
+ sub_sub_texture = cogl_sub_texture_new (ctx,
COGL_TEXTURE (sub_texture),
20, 10, 10, 10);
- cogl_set_source_texture (COGL_TEXTURE (sub_sub_texture));
- cogl_rectangle (0.0f, SOURCE_SIZE * 2.0f,
- 10.0f, SOURCE_SIZE * 2.0f + 10.0f);
- cogl_object_unref (sub_sub_texture);
cogl_object_unref (sub_texture);
- cogl_object_unref (full_texture);
+ cogl_pipeline_set_layer_texture (pipeline, 0, COGL_TEXTURE (sub_sub_texture));
+ cogl_object_unref (sub_sub_texture);
+ cogl_framebuffer_draw_rectangle (fb, pipeline,
+ 0.0f, SOURCE_SIZE * 2.0f,
+ 10.0f, SOURCE_SIZE * 2.0f + 10.0f);
+
+ cogl_object_unref (pipeline);
}
static void
@@ -158,7 +165,8 @@ validate_part (int xpos, int ypos,
int width, int height,
guint32 color)
{
- test_utils_check_region (xpos + TEST_INSET,
+ test_utils_check_region (fb,
+ xpos + TEST_INSET,
ypos + TEST_INSET,
width - TEST_INSET - 2,
height - TEST_INSET - 2,
@@ -212,10 +220,11 @@ validate_result (TestState *state)
/* Sub sub texture */
p = texture_data = g_malloc (10 * 10 * 4);
- cogl_read_pixels (0, SOURCE_SIZE * 2, 10, 10,
- COGL_READ_PIXELS_COLOR_BUFFER,
- COGL_PIXEL_FORMAT_RGBA_8888,
- p);
+ cogl_flush ();
+ cogl_framebuffer_read_pixels (fb,
+ 0, SOURCE_SIZE * 2, 10, 10,
+ COGL_PIXEL_FORMAT_RGBA_8888,
+ p);
for (y = 0; y < 10; y++)
for (x = 0; x < 10; x++)
{
@@ -226,7 +235,7 @@ validate_result (TestState *state)
g_free (texture_data);
/* Try reading back the texture data */
- sub_texture = cogl_sub_texture_new (state->ctx,
+ sub_texture = cogl_sub_texture_new (ctx,
COGL_TEXTURE (state->tex),
SOURCE_SIZE / 4,
SOURCE_SIZE / 4,
@@ -257,7 +266,7 @@ validate_result (TestState *state)
/* Create a 256x256 test texture */
test_tex = create_test_texture (state);
/* Create a sub texture the views the center half of the texture */
- sub_texture = cogl_sub_texture_new (state->ctx,
+ sub_texture = cogl_sub_texture_new (ctx,
COGL_TEXTURE (test_tex),
64, 64, 128, 128);
/* Update the center half of the sub texture */
@@ -299,18 +308,18 @@ validate_result (TestState *state)
}
void
-test_cogl_sub_texture (TestUtilsGTestFixture *fixture,
- void *data)
+test_sub_texture (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- state.ctx = shared_state->ctx;
state.tex = create_source (&state);
- cogl_ortho (0, cogl_framebuffer_get_width (shared_state->fb), /* left, right */
- cogl_framebuffer_get_height (shared_state->fb), 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ cogl_framebuffer_get_width (fb),
+ cogl_framebuffer_get_height (fb),
+ -1,
+ 100);
paint (&state);
validate_result (&state);
diff --git a/tests/conform/test-texture-3d.c b/tests/conform/test-texture-3d.c
index 5eab3b0..777d023 100644
--- a/tests/conform/test-texture-3d.c
+++ b/tests/conform/test-texture-3d.c
@@ -13,10 +13,8 @@
typedef struct _TestState
{
- CoglContext *ctx;
int fb_width;
int fb_height;
- CoglFramebuffer *fb;
} TestState;
static CoglTexture3D *
@@ -75,8 +73,8 @@ create_texture_3d (CoglContext *context)
static void
draw_frame (TestState *state)
{
- CoglTexture *tex = COGL_TEXTURE (create_texture_3d (state->ctx));
- CoglPipeline *pipeline = cogl_pipeline_new (state->ctx);
+ CoglTexture *tex = COGL_TEXTURE (create_texture_3d (ctx));
+ CoglPipeline *pipeline = cogl_pipeline_new (ctx);
typedef struct { float x, y, s, t, r; } Vert;
CoglPrimitive *primitive;
CoglAttributeBuffer *attribute_buffer;
@@ -89,15 +87,13 @@ draw_frame (TestState *state)
cogl_pipeline_set_layer_filters (pipeline, 0,
COGL_PIPELINE_FILTER_NEAREST,
COGL_PIPELINE_FILTER_NEAREST);
- cogl_push_source (pipeline);
/* Render the texture repeated horizontally twice using a regular
cogl rectangle. This should end up with the r texture coordinates
as zero */
- cogl_rectangle_with_texture_coords (0.0f, 0.0f, TEX_WIDTH * 2, TEX_HEIGHT,
- 0.0f, 0.0f, 2.0f, 1.0f);
-
- cogl_pop_source ();
+ cogl_framebuffer_draw_textured_rectangle (fb, pipeline,
+ 0.0f, 0.0f, TEX_WIDTH * 2, TEX_HEIGHT,
+ 0.0f, 0.0f, 2.0f, 1.0f);
/* Render all of the images in the texture using coordinates from a
CoglPrimitive */
@@ -135,7 +131,7 @@ draw_frame (TestState *state)
v++;
}
- attribute_buffer = cogl_attribute_buffer_new (state->ctx,
+ attribute_buffer = cogl_attribute_buffer_new (ctx,
4 * TEX_DEPTH * sizeof (Vert),
verts);
attributes[0] = cogl_attribute_new (attribute_buffer,
@@ -156,11 +152,11 @@ draw_frame (TestState *state)
2 /* n_attributes */);
cogl_primitive_set_indices (primitive,
- cogl_get_rectangle_indices (state->ctx,
+ cogl_get_rectangle_indices (ctx,
TEX_DEPTH),
6 * TEX_DEPTH);
- cogl_framebuffer_draw_primitive (state->fb, pipeline, primitive);
+ cogl_framebuffer_draw_primitive (fb, pipeline, primitive);
g_free (verts);
@@ -178,7 +174,8 @@ validate_block (int block_x, int block_y, int z)
for (y = 0; y < TEX_HEIGHT; y++)
for (x = 0; x < TEX_WIDTH; x++)
- test_utils_check_pixel_rgb (block_x * TEX_WIDTH + x,
+ test_utils_check_pixel_rgb (fb,
+ block_x * TEX_WIDTH + x,
block_y * TEX_HEIGHT + y,
255 - x * 8,
y * 8,
@@ -204,20 +201,20 @@ test_multi_texture (TestState *state)
CoglTexture2D *tex_2d;
guint8 tex_data[4];
- cogl_framebuffer_clear4f (state->fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
+ cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
/* Tests a pipeline that is using multi-texturing to combine a 3D
texture with a 2D texture. The texture from another layer is
sampled with TEXTURE_? just to pick up a specific bug that was
happening with the ARBfp fragend */
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
tex_data[0] = 0xff;
tex_data[1] = 0x00;
tex_data[2] = 0x00;
tex_data[3] = 0xff;
- tex_2d = cogl_texture_2d_new_from_data (state->ctx,
+ tex_2d = cogl_texture_2d_new_from_data (ctx,
1, 1, /* width/height */
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
@@ -230,7 +227,7 @@ test_multi_texture (TestState *state)
tex_data[1] = 0xff;
tex_data[2] = 0x00;
tex_data[3] = 0xff;
- tex_3d = cogl_texture_3d_new_from_data (state->ctx,
+ tex_3d = cogl_texture_3d_new_from_data (ctx,
1, 1, 1, /* width/height/depth */
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
@@ -247,11 +244,9 @@ test_multi_texture (TestState *state)
"RGBA = ADD(TEXTURE_0, TEXTURE_1)",
NULL);
- cogl_push_source (pipeline);
- cogl_rectangle (0, 0, 10, 10);
- cogl_pop_source ();
+ cogl_framebuffer_draw_rectangle (fb, pipeline, 0, 0, 10, 10);
- test_utils_check_pixel (5, 5, 0xffff00ff);
+ test_utils_check_pixel (fb, 5, 5, 0xffff00ff);
cogl_object_unref (tex_2d);
cogl_object_unref (tex_3d);
@@ -259,23 +254,18 @@ test_multi_texture (TestState *state)
}
void
-test_cogl_texture_3d (TestUtilsGTestFixture *fixture,
- void *data)
+test_texture_3d (void)
{
- TestUtilsSharedState *shared_state = data;
-
/* Check whether GL supports the rectangle extension. If not we'll
just assume the test passes */
- if (cogl_has_feature (shared_state->ctx, COGL_FEATURE_ID_TEXTURE_3D))
+ if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_3D))
{
TestState state;
- state.ctx = shared_state->ctx;
- state.fb_width = cogl_framebuffer_get_width (shared_state->fb);
- state.fb_height = cogl_framebuffer_get_height (shared_state->fb);
- state.fb = shared_state->fb;
+ state.fb_width = cogl_framebuffer_get_width (fb);
+ state.fb_height = cogl_framebuffer_get_height (fb);
- cogl_framebuffer_orthographic (shared_state->fb,
+ cogl_framebuffer_orthographic (fb,
0, 0, /* x_1, y_1 */
state.fb_width, /* x_2 */
state.fb_height /* y_2 */,
diff --git a/tests/conform/test-texture-get-set-data.c b/tests/conform/test-texture-get-set-data.c
index d92f285..94e53a9 100644
--- a/tests/conform/test-texture-get-set-data.c
+++ b/tests/conform/test-texture-get-set-data.c
@@ -141,7 +141,7 @@ paint_cb (void)
}
void
-test_cogl_texture_get_set_data (TestUtilsGTestFixture *fixture,
+test_texture_get_set_data (TestUtilsGTestFixture *fixture,
void *data)
{
ClutterActor *stage;
diff --git a/tests/conform/test-texture-mipmaps.c b/tests/conform/test-texture-mipmaps.c
index b09dfed..eda31ba 100644
--- a/tests/conform/test-texture-mipmaps.c
+++ b/tests/conform/test-texture-mipmaps.c
@@ -103,7 +103,7 @@ queue_redraw (gpointer stage)
}
void
-test_cogl_texture_mipmaps (TestUtilsGTestFixture *fixture,
+test_texture_mipmaps (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
diff --git a/tests/conform/test-texture-pixmap-x11.c b/tests/conform/test-texture-pixmap-x11.c
index ae11e5a..7f6d81c 100644
--- a/tests/conform/test-texture-pixmap-x11.c
+++ b/tests/conform/test-texture-pixmap-x11.c
@@ -198,7 +198,7 @@ queue_redraw (gpointer stage)
#endif /* COGL_HAS_XLIB */
void
-test_cogl_texture_pixmap_x11 (TestUtilsGTestFixture *fixture,
+test_texture_pixmap_x11 (TestUtilsGTestFixture *fixture,
void *data)
{
#ifdef COGL_HAS_XLIB
diff --git a/tests/conform/test-texture-rectangle.c b/tests/conform/test-texture-rectangle.c
index 53b7310..d7cc354 100644
--- a/tests/conform/test-texture-rectangle.c
+++ b/tests/conform/test-texture-rectangle.c
@@ -237,7 +237,7 @@ check_rectangle_extension (void)
}
void
-test_cogl_texture_rectangle (TestUtilsGTestFixture *fixture,
+test_texture_rectangle (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
diff --git a/tests/conform/test-utils.c b/tests/conform/test-utils.c
index 059c143..0d9c116 100644
--- a/tests/conform/test-utils.c
+++ b/tests/conform/test-utils.c
@@ -9,9 +9,11 @@
static gboolean cogl_test_is_verbose;
+CoglContext *ctx;
+CoglFramebuffer *fb;
+
void
-test_utils_init (TestUtilsSharedState *state,
- TestFlags flags)
+test_utils_init (TestFlags flags)
{
static int counter = 0;
GError *error = NULL;
@@ -43,11 +45,11 @@ test_utils_init (TestUtilsSharedState *state,
g_setenv ("COGL_X11_SYNC", "1", 0);
- state->ctx = cogl_context_new (NULL, &error);
- if (!state->ctx)
+ ctx = cogl_context_new (NULL, &error);
+ if (!ctx)
g_critical ("Failed to create a CoglContext: %s", error->message);
- display = cogl_context_get_display (state->ctx);
+ display = cogl_context_get_display (ctx);
renderer = cogl_display_get_renderer (display);
if (flags & TEST_REQUIREMENT_GL &&
@@ -57,19 +59,19 @@ test_utils_init (TestUtilsSharedState *state,
}
if (flags & TEST_REQUIREMENT_NPOT &&
- !cogl_has_feature (state->ctx, COGL_FEATURE_ID_TEXTURE_NPOT))
+ !cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT))
{
missing_requirement = TRUE;
}
if (flags & TEST_REQUIREMENT_TEXTURE_3D &&
- !cogl_has_feature (state->ctx, COGL_FEATURE_ID_TEXTURE_3D))
+ !cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_3D))
{
missing_requirement = TRUE;
}
if (flags & TEST_REQUIREMENT_POINT_SPRITE &&
- !cogl_has_feature (state->ctx, COGL_FEATURE_ID_POINT_SPRITE))
+ !cogl_has_feature (ctx, COGL_FEATURE_ID_POINT_SPRITE))
{
missing_requirement = TRUE;
}
@@ -81,13 +83,13 @@ test_utils_init (TestUtilsSharedState *state,
if (getenv ("COGL_TEST_ONSCREEN"))
{
- onscreen = cogl_onscreen_new (state->ctx, 640, 480);
- state->fb = COGL_FRAMEBUFFER (onscreen);
+ onscreen = cogl_onscreen_new (ctx, 640, 480);
+ fb = COGL_FRAMEBUFFER (onscreen);
}
else
{
CoglHandle offscreen;
- CoglHandle tex = cogl_texture_2d_new_with_size (state->ctx,
+ CoglHandle tex = cogl_texture_2d_new_with_size (ctx,
FB_WIDTH, FB_HEIGHT,
COGL_PIXEL_FORMAT_ANY,
&error);
@@ -95,37 +97,37 @@ test_utils_init (TestUtilsSharedState *state,
g_critical ("Failed to allocate texture: %s", error->message);
offscreen = cogl_offscreen_new_to_texture (tex);
- state->fb = COGL_FRAMEBUFFER (offscreen);
+ fb = COGL_FRAMEBUFFER (offscreen);
}
- if (!cogl_framebuffer_allocate (state->fb, &error))
+ if (!cogl_framebuffer_allocate (fb, &error))
g_critical ("Failed to allocate framebuffer: %s", error->message);
if (onscreen)
cogl_onscreen_show (onscreen);
- cogl_framebuffer_clear4f (state->fb,
+ cogl_framebuffer_clear4f (fb,
COGL_BUFFER_BIT_COLOR |
COGL_BUFFER_BIT_DEPTH |
COGL_BUFFER_BIT_STENCIL,
0, 0, 0, 1);
- cogl_push_framebuffer (state->fb);
+ //cogl_push_framebuffer (fb);
if (missing_requirement)
g_print ("WARNING: Missing required feature[s] for this test\n");
}
void
-test_utils_fini (TestUtilsSharedState *state)
+test_utils_fini (void)
{
- cogl_pop_framebuffer ();
+ //cogl_pop_framebuffer ();
- if (state->fb)
- cogl_object_unref (state->fb);
+ if (fb)
+ cogl_object_unref (fb);
- if (state->ctx)
- cogl_object_unref (state->ctx);
+ if (ctx)
+ cogl_object_unref (ctx);
}
static gboolean
@@ -156,38 +158,42 @@ test_utils_compare_pixel (const guint8 *screen_pixel, guint32 expected_pixel)
}
void
-test_utils_check_pixel (int x, int y, guint32 expected_pixel)
+test_utils_check_pixel (CoglFramebuffer *fb,
+ int x, int y, guint32 expected_pixel)
{
guint8 pixel[4];
- cogl_read_pixels (x, y, 1, 1, COGL_READ_PIXELS_COLOR_BUFFER,
- COGL_PIXEL_FORMAT_RGBA_8888_PRE,
- pixel);
+ cogl_framebuffer_read_pixels (fb,
+ x, y, 1, 1,
+ COGL_PIXEL_FORMAT_RGBA_8888_PRE,
+ pixel);
test_utils_compare_pixel (pixel, expected_pixel);
}
void
-test_utils_check_pixel_rgb (int x, int y, int r, int g, int b)
+test_utils_check_pixel_rgb (CoglFramebuffer *fb,
+ int x, int y, int r, int g, int b)
{
- test_utils_check_pixel (x, y, (r << 24) | (g << 16) | (b << 8));
+ test_utils_check_pixel (fb, x, y, (r << 24) | (g << 16) | (b << 8));
}
void
-test_utils_check_region (int x, int y,
+test_utils_check_region (CoglFramebuffer *fb,
+ int x, int y,
int width, int height,
guint32 expected_rgba)
{
guint8 *pixels, *p;
pixels = p = g_malloc (width * height * 4);
- cogl_read_pixels (x,
- y,
- width,
- height,
- COGL_READ_PIXELS_COLOR_BUFFER,
- COGL_PIXEL_FORMAT_RGBA_8888,
- p);
+ cogl_framebuffer_read_pixels (fb,
+ x,
+ y,
+ width,
+ height,
+ COGL_PIXEL_FORMAT_RGBA_8888,
+ p);
/* Check whether the center of each division is the right color */
for (y = 0; y < height; y++)
diff --git a/tests/conform/test-utils.h b/tests/conform/test-utils.h
index 8dfd084..727aea8 100644
--- a/tests/conform/test-utils.h
+++ b/tests/conform/test-utils.h
@@ -16,77 +16,68 @@ typedef enum _TestFlags
TEST_REQUIREMENT_POINT_SPRITE = 1<<4
} TestFlags;
-/* For compatability since we used to use the glib gtester
- * infrastructure and all our unit tests have an entry
- * point with a first argument of this type... */
-typedef struct _TestUtilsGTestFixture TestUtilsGTestFixture;
-
-/* Stuff you put in here is setup once in main() and gets passed around to
- * all test functions and fixture setup/teardown functions in the data
- * argument */
-typedef struct _TestUtilsSharedState
-{
- int *argc_addr;
- char ***argv_addr;
-
- CoglContext *ctx;
- CoglFramebuffer *fb;
-} TestUtilsSharedState;
+extern CoglContext *ctx;
+extern CoglFramebuffer *fb;
void
-test_utils_init (TestUtilsSharedState *state,
- TestFlags flags);
+test_utils_init (TestFlags flags);
void
-test_utils_fini (TestUtilsSharedState *state);
+test_utils_fini (void);
/*
* test_utils_check_pixel:
+ * @framebuffer: The #CoglFramebuffer to read from
* @x: x co-ordinate of the pixel to test
* @y: y co-ordinate of the pixel to test
* @pixel: An integer of the form 0xRRGGBBAA representing the expected
* pixel value
*
- * This performs reads a pixel on the current cogl framebuffer and
+ * This performs reads a pixel on the given cogl @framebuffer and
* asserts that it matches the given color. The alpha channel of the
* color is ignored. The pixels are converted to a string and compared
* with g_assert_cmpstr so that if the comparison fails then the
* assert will display a meaningful message
*/
void
-test_utils_check_pixel (int x, int y, guint32 expected_pixel);
+test_utils_check_pixel (CoglFramebuffer *framebuffer,
+ int x, int y, guint32 expected_pixel);
/*
* test_utils_check_pixel:
+ * @framebuffer: The #CoglFramebuffer to read from
* @x: x co-ordinate of the pixel to test
* @y: y co-ordinate of the pixel to test
* @pixel: An integer of the form 0xrrggbb representing the expected pixel value
*
- * This performs reads a pixel on the current cogl framebuffer and
+ * This performs reads a pixel on the given cogl @framebuffer and
* asserts that it matches the given color. The alpha channel of the
* color is ignored. The pixels are converted to a string and compared
* with g_assert_cmpstr so that if the comparison fails then the
* assert will display a meaningful message
*/
void
-test_utils_check_pixel_rgb (int x, int y, int r, int g, int b);
+test_utils_check_pixel_rgb (CoglFramebuffer *framebuffer,
+ int x, int y, int r, int g, int b);
/*
* test_utils_check_region:
+ * @framebuffer: The #CoglFramebuffer to read from
* @x: x co-ordinate of the region to test
* @y: y co-ordinate of the region to test
* @width: width of the region to test
* @height: height of the region to test
* @pixel: An integer of the form 0xrrggbb representing the expected region color
*
- * Performs a read pixel on the specified region of the current cogl
- * framebuffer and asserts that it matches the given color. The alpha
+ * Performs a read pixel on the specified region of the given cogl
+ * @framebuffer and asserts that it matches the given color. The alpha
* channel of the color is ignored. The pixels are converted to a
* string and compared with g_assert_cmpstr so that if the comparison
* fails then the assert will display a meaningful message
*/
void
-test_utils_check_region (int x, int y,
+test_utils_check_region (CoglFramebuffer *framebuffer,
+ int x, int y,
int width, int height,
guint32 expected_rgba);
diff --git a/tests/conform/test-vertex-buffer-contiguous.c b/tests/conform/test-vertex-buffer-contiguous.c
index e0da81e..12f4403 100644
--- a/tests/conform/test-vertex-buffer-contiguous.c
+++ b/tests/conform/test-vertex-buffer-contiguous.c
@@ -152,7 +152,7 @@ queue_redraw (gpointer stage)
void
-test_cogl_vertex_buffer_contiguous (TestUtilsGTestFixture *fixture,
+test_vertex_buffer_contiguous (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
diff --git a/tests/conform/test-vertex-buffer-interleved.c b/tests/conform/test-vertex-buffer-interleved.c
index d2cbb3a..0cefb1c 100644
--- a/tests/conform/test-vertex-buffer-interleved.c
+++ b/tests/conform/test-vertex-buffer-interleved.c
@@ -83,7 +83,7 @@ queue_redraw (gpointer stage)
}
void
-test_cogl_vertex_buffer_interleved (TestUtilsGTestFixture *fixture,
+test_vertex_buffer_interleved (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
diff --git a/tests/conform/test-vertex-buffer-mutability.c b/tests/conform/test-vertex-buffer-mutability.c
index 1693a22..d742eb6 100644
--- a/tests/conform/test-vertex-buffer-mutability.c
+++ b/tests/conform/test-vertex-buffer-mutability.c
@@ -126,7 +126,7 @@ queue_redraw (gpointer stage)
}
void
-test_cogl_vertex_buffer_mutability (TestUtilsGTestFixture *fixture,
+test_vertex_buffer_mutability (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
diff --git a/tests/conform/test-viewport.c b/tests/conform/test-viewport.c
index a2d0f7b..ef22d69 100644
--- a/tests/conform/test-viewport.c
+++ b/tests/conform/test-viewport.c
@@ -385,7 +385,7 @@ queue_redraw (gpointer stage)
}
void
-test_cogl_viewport (TestUtilsGTestFixture *fixture,
+test_viewport (TestUtilsGTestFixture *fixture,
void *data)
{
unsigned int idle_source;
diff --git a/tests/conform/test-wrap-modes.c b/tests/conform/test-wrap-modes.c
index 655dc17..cb75705 100644
--- a/tests/conform/test-wrap-modes.c
+++ b/tests/conform/test-wrap-modes.c
@@ -7,7 +7,6 @@
typedef struct _TestState
{
- CoglContext *ctx;
int width;
int height;
CoglTexture *texture;
@@ -46,7 +45,7 @@ create_pipeline (TestState *state,
{
CoglPipeline *pipeline;
- pipeline = cogl_pipeline_new (state->ctx);
+ pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_layer_texture (pipeline, 0, state->texture);
cogl_pipeline_set_layer_filters (pipeline, 0,
COGL_PIPELINE_FILTER_NEAREST,
@@ -58,7 +57,7 @@ create_pipeline (TestState *state,
}
static CoglPipelineWrapMode
-test_wrap_modes[] =
+wrap_modes[] =
{
COGL_PIPELINE_WRAP_MODE_REPEAT,
COGL_PIPELINE_WRAP_MODE_REPEAT,
@@ -84,22 +83,25 @@ draw_tests (TestState *state)
{
int i;
- for (i = 0; i < G_N_ELEMENTS (test_wrap_modes); i += 2)
+ for (i = 0; i < G_N_ELEMENTS (wrap_modes); i += 2)
{
CoglPipelineWrapMode wrap_mode_s, wrap_mode_t;
CoglPipeline *pipeline;
/* Create a separate pipeline for each pair of wrap modes so
that we can verify whether the batch splitting works */
- wrap_mode_s = test_wrap_modes[i];
- wrap_mode_t = test_wrap_modes[i + 1];
+ wrap_mode_s = wrap_modes[i];
+ wrap_mode_t = wrap_modes[i + 1];
pipeline = create_pipeline (state, wrap_mode_s, wrap_mode_t);
- cogl_set_source (pipeline);
- cogl_handle_unref (pipeline);
/* Render the pipeline at four times the size of the texture */
- cogl_rectangle_with_texture_coords (i * TEX_SIZE, 0,
- (i + 2) * TEX_SIZE, TEX_SIZE * 2,
- 0, 0, 2, 2);
+ cogl_framebuffer_draw_textured_rectangle (fb,
+ pipeline,
+ i * TEX_SIZE,
+ 0,
+ (i + 2) * TEX_SIZE,
+ TEX_SIZE * 2,
+ 0, 0, 2, 2);
+ cogl_object_unref (pipeline);
}
}
@@ -116,16 +118,16 @@ draw_tests_polygon (TestState *state)
{
int i;
- for (i = 0; i < G_N_ELEMENTS (test_wrap_modes); i += 2)
+ for (i = 0; i < G_N_ELEMENTS (wrap_modes); i += 2)
{
CoglPipelineWrapMode wrap_mode_s, wrap_mode_t;
CoglPipeline *pipeline;
- wrap_mode_s = test_wrap_modes[i];
- wrap_mode_t = test_wrap_modes[i + 1];
+ wrap_mode_s = wrap_modes[i];
+ wrap_mode_t = wrap_modes[i + 1];
pipeline = create_pipeline (state, wrap_mode_s, wrap_mode_t);
cogl_set_source (pipeline);
- cogl_handle_unref (pipeline);
+ cogl_object_unref (pipeline);
cogl_push_matrix ();
cogl_translate (TEX_SIZE * i, 0.0f, 0.0f);
/* Render the pipeline at four times the size of the texture */
@@ -151,16 +153,16 @@ draw_tests_vbo (TestState *state)
&vertices[0].tx);
cogl_vertex_buffer_submit (vbo);
- for (i = 0; i < G_N_ELEMENTS (test_wrap_modes); i += 2)
+ for (i = 0; i < G_N_ELEMENTS (wrap_modes); i += 2)
{
CoglPipelineWrapMode wrap_mode_s, wrap_mode_t;
CoglPipeline *pipeline;
- wrap_mode_s = test_wrap_modes[i];
- wrap_mode_t = test_wrap_modes[i + 1];
+ wrap_mode_s = wrap_modes[i];
+ wrap_mode_t = wrap_modes[i + 1];
pipeline = create_pipeline (state, wrap_mode_s, wrap_mode_t);
cogl_set_source (pipeline);
- cogl_handle_unref (pipeline);
+ cogl_object_unref (pipeline);
cogl_push_matrix ();
cogl_translate (TEX_SIZE * i, 0.0f, 0.0f);
/* Render the pipeline at four times the size of the texture */
@@ -177,18 +179,17 @@ validate_set (TestState *state, int offset)
guint8 data[TEX_SIZE * 2 * TEX_SIZE * 2 * 4], *p;
int x, y, i;
- for (i = 0; i < G_N_ELEMENTS (test_wrap_modes); i += 2)
+ for (i = 0; i < G_N_ELEMENTS (wrap_modes); i += 2)
{
CoglPipelineWrapMode wrap_mode_s, wrap_mode_t;
- wrap_mode_s = test_wrap_modes[i];
- wrap_mode_t = test_wrap_modes[i + 1];
+ wrap_mode_s = wrap_modes[i];
+ wrap_mode_t = wrap_modes[i + 1];
- cogl_read_pixels (i * TEX_SIZE, offset * TEX_SIZE * 2,
- TEX_SIZE * 2, TEX_SIZE * 2,
- COGL_READ_PIXELS_COLOR_BUFFER,
- COGL_PIXEL_FORMAT_RGBA_8888,
- data);
+ cogl_framebuffer_read_pixels (fb, i * TEX_SIZE, offset * TEX_SIZE * 2,
+ TEX_SIZE * 2, TEX_SIZE * 2,
+ COGL_PIXEL_FORMAT_RGBA_8888,
+ data);
p = data;
@@ -237,7 +238,7 @@ paint (TestState *state)
/* Draw the tests first with a non atlased texture */
state->texture = create_texture (COGL_TEXTURE_NO_ATLAS);
draw_tests (state);
- cogl_handle_unref (state->texture);
+ cogl_object_unref (state->texture);
/* Draw the tests again with a possible atlased texture. This should
end up testing software repeats */
@@ -246,7 +247,7 @@ paint (TestState *state)
cogl_translate (0.0f, TEX_SIZE * 2.0f, 0.0f);
draw_tests (state);
cogl_pop_matrix ();
- cogl_handle_unref (state->texture);
+ cogl_object_unref (state->texture);
/* Draw the tests using cogl_polygon */
state->texture = create_texture (COGL_TEXTURE_NO_ATLAS);
@@ -254,7 +255,7 @@ paint (TestState *state)
cogl_translate (0.0f, TEX_SIZE * 4.0f, 0.0f);
draw_tests_polygon (state);
cogl_pop_matrix ();
- cogl_handle_unref (state->texture);
+ cogl_object_unref (state->texture);
/* Draw the tests using a vertex buffer */
state->texture = create_texture (COGL_TEXTURE_NO_ATLAS);
@@ -262,27 +263,31 @@ paint (TestState *state)
cogl_translate (0.0f, TEX_SIZE * 6.0f, 0.0f);
draw_tests_vbo (state);
cogl_pop_matrix ();
- cogl_handle_unref (state->texture);
+ cogl_object_unref (state->texture);
validate_result (state);
}
void
-test_cogl_wrap_modes (TestUtilsGTestFixture *fixture,
- void *data)
+test_wrap_modes (void)
{
- TestUtilsSharedState *shared_state = data;
TestState state;
- state.ctx = shared_state->ctx;
- state.width = cogl_framebuffer_get_width (shared_state->fb);
- state.height = cogl_framebuffer_get_height (shared_state->fb);
+ state.width = cogl_framebuffer_get_width (fb);
+ state.height = cogl_framebuffer_get_height (fb);
- cogl_ortho (0, state.width, /* left, right */
- state.height, 0, /* bottom, top */
- -1, 100 /* z near, far */);
+ cogl_framebuffer_orthographic (fb,
+ 0, 0,
+ state.width,
+ state.height,
+ -1,
+ 100);
+ /* XXX: we have to push/pop a framebuffer since this test currently
+ * uses the legacy cogl_vertex_buffer_draw() api. */
+ cogl_push_framebuffer (fb);
paint (&state);
+ cogl_pop_framebuffer ();
if (cogl_test_verbose ())
g_print ("OK\n");
diff --git a/tests/conform/test-write-texture-formats.c b/tests/conform/test-write-texture-formats.c
index c794286..3081182 100644
--- a/tests/conform/test-write-texture-formats.c
+++ b/tests/conform/test-write-texture-formats.c
@@ -139,12 +139,8 @@ test_write_int (CoglContext *context,
}
void
-test_cogl_write_texture_formats (TestUtilsGTestFixture *fixture,
- void *data)
+test_write_texture_formats (void)
{
- TestUtilsSharedState *shared_state = data;
- CoglContext *ctx = shared_state->ctx;
-
test_write_byte (ctx, COGL_PIXEL_FORMAT_A_8, 0x34, 0x00000034);
#if 0
/* I'm not sure what's the right value to put here because Nvidia
--
1.7.7.6
More information about the Cogl
mailing list