2008-04-25 09:37:36 -04:00
|
|
|
#include <glib.h>
|
2008-11-07 14:32:28 -05:00
|
|
|
#include <gmodule.h>
|
2008-04-25 09:37:36 -04:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <clutter/clutter.h>
|
|
|
|
#include <cogl/cogl.h>
|
|
|
|
|
|
|
|
/* Coglbox declaration
|
|
|
|
*--------------------------------------------------*/
|
|
|
|
|
|
|
|
G_BEGIN_DECLS
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
#define TEST_TYPE_COGLBOX test_coglbox_get_type()
|
|
|
|
|
|
|
|
#define TEST_COGLBOX(obj) \
|
|
|
|
(G_TYPE_CHECK_INSTANCE_CAST ((obj), \
|
2019-07-21 07:15:41 -04:00
|
|
|
TEST_TYPE_COGLBOX, TestCoglbox))
|
2008-04-25 09:37:36 -04:00
|
|
|
|
|
|
|
#define TEST_COGLBOX_CLASS(klass) \
|
|
|
|
(G_TYPE_CHECK_CLASS_CAST ((klass), \
|
|
|
|
TEST_TYPE_COGLBOX, TestCoglboxClass))
|
|
|
|
|
|
|
|
#define TEST_IS_COGLBOX(obj) \
|
|
|
|
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
|
|
|
|
TEST_TYPE_COGLBOX))
|
|
|
|
|
|
|
|
#define TEST_IS_COGLBOX_CLASS(klass) \
|
|
|
|
(G_TYPE_CHECK_CLASS_TYPE ((klass), \
|
|
|
|
TEST_TYPE_COGLBOX))
|
|
|
|
|
|
|
|
#define TEST_COGLBOX_GET_CLASS(obj) \
|
|
|
|
(G_TYPE_INSTANCE_GET_CLASS ((obj), \
|
|
|
|
TEST_TYPE_COGLBOX, TestCoglboxClass))
|
|
|
|
|
|
|
|
typedef struct _TestCoglbox TestCoglbox;
|
|
|
|
typedef struct _TestCoglboxClass TestCoglboxClass;
|
|
|
|
typedef struct _TestCoglboxPrivate TestCoglboxPrivate;
|
|
|
|
|
|
|
|
struct _TestCoglbox
|
|
|
|
{
|
|
|
|
ClutterActor parent;
|
|
|
|
|
|
|
|
/*< private >*/
|
|
|
|
TestCoglboxPrivate *priv;
|
|
|
|
};
|
|
|
|
|
2009-05-12 09:15:18 -04:00
|
|
|
struct _TestCoglboxClass
|
2008-04-25 09:37:36 -04:00
|
|
|
{
|
|
|
|
ClutterActorClass parent_class;
|
|
|
|
|
|
|
|
/* padding for future expansion */
|
|
|
|
void (*_test_coglbox1) (void);
|
|
|
|
void (*_test_coglbox2) (void);
|
|
|
|
void (*_test_coglbox3) (void);
|
|
|
|
void (*_test_coglbox4) (void);
|
|
|
|
};
|
|
|
|
|
2008-11-07 14:32:28 -05:00
|
|
|
static GType test_coglbox_get_type (void) G_GNUC_CONST;
|
2008-04-25 09:37:36 -04:00
|
|
|
|
2019-01-20 03:03:50 -05:00
|
|
|
int
|
|
|
|
test_cogl_tex_polygon_main (int argc, char *argv[]);
|
|
|
|
|
|
|
|
const char *
|
|
|
|
test_cogl_tex_polygon_describe (void);
|
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
G_END_DECLS
|
|
|
|
|
|
|
|
/* Coglbox private declaration
|
|
|
|
*--------------------------------------------------*/
|
|
|
|
|
|
|
|
struct _TestCoglboxPrivate
|
|
|
|
{
|
2008-04-28 07:23:27 -04:00
|
|
|
CoglHandle sliced_tex, not_sliced_tex;
|
2008-04-25 09:37:36 -04:00
|
|
|
gint frame;
|
2008-04-28 07:23:27 -04:00
|
|
|
gboolean use_sliced;
|
|
|
|
gboolean use_linear_filtering;
|
2008-04-25 09:37:36 -04:00
|
|
|
};
|
|
|
|
|
2018-07-19 07:45:13 -04:00
|
|
|
G_DEFINE_TYPE_WITH_PRIVATE (TestCoglbox, test_coglbox, CLUTTER_TYPE_ACTOR);
|
|
|
|
|
|
|
|
#define TEST_COGLBOX_GET_PRIVATE(obj) \
|
2019-07-20 10:26:56 -04:00
|
|
|
((TestCoglboxPrivate *)test_coglbox_get_instance_private (TEST_COGLBOX ((obj))))
|
2018-07-19 07:45:13 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
/* Coglbox implementation
|
|
|
|
*--------------------------------------------------*/
|
|
|
|
|
|
|
|
static void
|
2010-03-31 14:03:02 -04:00
|
|
|
test_coglbox_fade_texture (gfloat x1,
|
2009-03-09 13:34:23 -04:00
|
|
|
gfloat y1,
|
|
|
|
gfloat x2,
|
|
|
|
gfloat y2,
|
|
|
|
gfloat tx1,
|
|
|
|
gfloat ty1,
|
|
|
|
gfloat tx2,
|
|
|
|
gfloat ty2)
|
2008-04-25 09:37:36 -04:00
|
|
|
{
|
|
|
|
CoglTextureVertex vertices[4];
|
|
|
|
int i;
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
vertices[0].x = x1;
|
|
|
|
vertices[0].y = y1;
|
|
|
|
vertices[0].z = 0;
|
|
|
|
vertices[0].tx = tx1;
|
|
|
|
vertices[0].ty = ty1;
|
|
|
|
vertices[1].x = x1;
|
|
|
|
vertices[1].y = y2;
|
|
|
|
vertices[1].z = 0;
|
|
|
|
vertices[1].tx = tx1;
|
|
|
|
vertices[1].ty = ty2;
|
|
|
|
vertices[2].x = x2;
|
|
|
|
vertices[2].y = y2;
|
|
|
|
vertices[2].z = 0;
|
|
|
|
vertices[2].tx = tx2;
|
|
|
|
vertices[2].ty = ty2;
|
|
|
|
vertices[3].x = x2;
|
|
|
|
vertices[3].y = y1;
|
|
|
|
vertices[3].z = 0;
|
|
|
|
vertices[3].tx = tx2;
|
|
|
|
vertices[3].ty = ty1;
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
{
|
2010-09-03 11:55:12 -04:00
|
|
|
cogl_color_init_from_4ub (&(vertices[i].color),
|
|
|
|
255,
|
|
|
|
255,
|
|
|
|
255,
|
|
|
|
((i ^ (i >> 1)) & 1) ? 0 : 128);
|
2009-06-11 11:59:50 -04:00
|
|
|
cogl_color_premultiply (&(vertices[i].color));
|
2008-04-25 09:37:36 -04:00
|
|
|
}
|
|
|
|
|
Fully integrates CoglMaterial throughout the rest of Cogl
This glues CoglMaterial in as the fundamental way that Cogl describes how to
fill in geometry.
It adds cogl_set_source (), which is used to set the material which will be
used by all subsequent drawing functions
It adds cogl_set_source_texture as a convenience for setting up a default
material with a single texture layer, and cogl_set_source_color is now also
a convenience for setting up a material with a solid fill.
"drawing functions" include, cogl_rectangle, cogl_texture_rectangle,
cogl_texture_multiple_rectangles, cogl_texture_polygon (though the
cogl_texture_* funcs have been renamed; see below for details),
cogl_path_fill/stroke and cogl_vertex_buffer_draw*.
cogl_texture_rectangle, cogl_texture_multiple_rectangles and
cogl_texture_polygon no longer take a texture handle; instead the current
source material is referenced. The functions have also been renamed to:
cogl_rectangle_with_texture_coords, cogl_rectangles_with_texture_coords
and cogl_polygon respectivly.
Most code that previously did:
cogl_texture_rectangle (tex_handle, x, y,...);
needs to be changed to now do:
cogl_set_source_texture (tex_handle);
cogl_rectangle_with_texture_coords (x, y,....);
In the less likely case where you were blending your source texture with a color
like:
cogl_set_source_color4ub (r,g,b,a); /* where r,g,b,a isn't just white */
cogl_texture_rectangle (tex_handle, x, y,...);
you will need your own material to do that:
mat = cogl_material_new ();
cogl_material_set_color4ub (r,g,b,a);
cogl_material_set_layer (mat, 0, tex_handle));
cogl_set_source_material (mat);
Code that uses the texture coordinates, 0, 0, 1, 1 don't need to use
cog_rectangle_with_texure_coords since these are the coordinates that
cogl_rectangle will use.
For cogl_texture_polygon; as well as dropping the texture handle, the
n_vertices and vertices arguments were transposed for consistency. So
code previously written as:
cogl_texture_polygon (tex_handle, 3, verts, TRUE);
need to be written as:
cogl_set_source_texture (tex_handle);
cogl_polygon (verts, 3, TRUE);
All of the unit tests have been updated to now use the material API and
test-cogl-material has been renamed to test-cogl-multitexture since any
textured quad is now technically a test of CoglMaterial but this test
specifically creates a material with multiple texture layers.
Note: The GLES backend has not been updated yet; that will be done in a
following commit.
2009-01-23 11:15:40 -05:00
|
|
|
cogl_polygon (vertices, 4, TRUE);
|
2008-04-25 09:37:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-03-31 14:03:02 -04:00
|
|
|
test_coglbox_triangle_texture (int tex_width,
|
|
|
|
int tex_height,
|
|
|
|
gfloat x,
|
|
|
|
gfloat y,
|
|
|
|
gfloat tx1,
|
|
|
|
gfloat ty1,
|
|
|
|
gfloat tx2,
|
|
|
|
gfloat ty2,
|
|
|
|
gfloat tx3,
|
|
|
|
gfloat ty3)
|
2008-04-25 09:37:36 -04:00
|
|
|
{
|
|
|
|
CoglTextureVertex vertices[3];
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
vertices[0].x = x + tx1 * tex_width;
|
|
|
|
vertices[0].y = y + ty1 * tex_height;
|
|
|
|
vertices[0].z = 0;
|
|
|
|
vertices[0].tx = tx1;
|
|
|
|
vertices[0].ty = ty1;
|
|
|
|
|
|
|
|
vertices[1].x = x + tx2 * tex_width;
|
|
|
|
vertices[1].y = y + ty2 * tex_height;
|
|
|
|
vertices[1].z = 0;
|
|
|
|
vertices[1].tx = tx2;
|
|
|
|
vertices[1].ty = ty2;
|
|
|
|
|
|
|
|
vertices[2].x = x + tx3 * tex_width;
|
|
|
|
vertices[2].y = y + ty3 * tex_height;
|
|
|
|
vertices[2].z = 0;
|
|
|
|
vertices[2].tx = tx3;
|
|
|
|
vertices[2].ty = ty3;
|
|
|
|
|
Fully integrates CoglMaterial throughout the rest of Cogl
This glues CoglMaterial in as the fundamental way that Cogl describes how to
fill in geometry.
It adds cogl_set_source (), which is used to set the material which will be
used by all subsequent drawing functions
It adds cogl_set_source_texture as a convenience for setting up a default
material with a single texture layer, and cogl_set_source_color is now also
a convenience for setting up a material with a solid fill.
"drawing functions" include, cogl_rectangle, cogl_texture_rectangle,
cogl_texture_multiple_rectangles, cogl_texture_polygon (though the
cogl_texture_* funcs have been renamed; see below for details),
cogl_path_fill/stroke and cogl_vertex_buffer_draw*.
cogl_texture_rectangle, cogl_texture_multiple_rectangles and
cogl_texture_polygon no longer take a texture handle; instead the current
source material is referenced. The functions have also been renamed to:
cogl_rectangle_with_texture_coords, cogl_rectangles_with_texture_coords
and cogl_polygon respectivly.
Most code that previously did:
cogl_texture_rectangle (tex_handle, x, y,...);
needs to be changed to now do:
cogl_set_source_texture (tex_handle);
cogl_rectangle_with_texture_coords (x, y,....);
In the less likely case where you were blending your source texture with a color
like:
cogl_set_source_color4ub (r,g,b,a); /* where r,g,b,a isn't just white */
cogl_texture_rectangle (tex_handle, x, y,...);
you will need your own material to do that:
mat = cogl_material_new ();
cogl_material_set_color4ub (r,g,b,a);
cogl_material_set_layer (mat, 0, tex_handle));
cogl_set_source_material (mat);
Code that uses the texture coordinates, 0, 0, 1, 1 don't need to use
cog_rectangle_with_texure_coords since these are the coordinates that
cogl_rectangle will use.
For cogl_texture_polygon; as well as dropping the texture handle, the
n_vertices and vertices arguments were transposed for consistency. So
code previously written as:
cogl_texture_polygon (tex_handle, 3, verts, TRUE);
need to be written as:
cogl_set_source_texture (tex_handle);
cogl_polygon (verts, 3, TRUE);
All of the unit tests have been updated to now use the material API and
test-cogl-material has been renamed to test-cogl-multitexture since any
textured quad is now technically a test of CoglMaterial but this test
specifically creates a material with multiple texture layers.
Note: The GLES backend has not been updated yet; that will be done in a
following commit.
2009-01-23 11:15:40 -05:00
|
|
|
cogl_polygon (vertices, 3, FALSE);
|
2008-04-25 09:37:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
test_coglbox_paint (ClutterActor *self)
|
|
|
|
{
|
|
|
|
TestCoglboxPrivate *priv = TEST_COGLBOX_GET_PRIVATE (self);
|
2008-10-30 12:50:07 -04:00
|
|
|
CoglHandle tex_handle = priv->use_sliced ? priv->sliced_tex
|
|
|
|
: priv->not_sliced_tex;
|
2008-04-28 07:23:27 -04:00
|
|
|
int tex_width = cogl_texture_get_width (tex_handle);
|
|
|
|
int tex_height = cogl_texture_get_height (tex_handle);
|
2009-06-04 11:04:57 -04:00
|
|
|
CoglHandle material = cogl_material_new ();
|
2008-04-25 09:37:36 -04:00
|
|
|
|
2009-06-04 11:04:57 -04:00
|
|
|
cogl_material_set_layer (material, 0, tex_handle);
|
|
|
|
|
|
|
|
cogl_material_set_layer_filters (material, 0,
|
|
|
|
priv->use_linear_filtering
|
|
|
|
? COGL_MATERIAL_FILTER_LINEAR :
|
|
|
|
COGL_MATERIAL_FILTER_NEAREST,
|
|
|
|
priv->use_linear_filtering
|
|
|
|
? COGL_MATERIAL_FILTER_LINEAR :
|
|
|
|
COGL_MATERIAL_FILTER_NEAREST);
|
2008-04-28 07:23:27 -04:00
|
|
|
|
|
|
|
cogl_push_matrix ();
|
|
|
|
cogl_translate (tex_width / 2, 0, 0);
|
|
|
|
cogl_rotate (priv->frame, 0, 1, 0);
|
|
|
|
cogl_translate (-tex_width / 2, 0, 0);
|
|
|
|
|
|
|
|
/* Draw a hand and refect it */
|
2009-06-04 11:04:57 -04:00
|
|
|
cogl_set_source (material);
|
2009-03-09 13:34:23 -04:00
|
|
|
cogl_rectangle_with_texture_coords (0, 0, tex_width, tex_height,
|
|
|
|
0, 0, 1, 1);
|
2010-03-31 14:03:02 -04:00
|
|
|
test_coglbox_fade_texture (0, tex_height,
|
2009-03-09 13:34:23 -04:00
|
|
|
tex_width, (tex_height * 3 / 2),
|
|
|
|
0.0, 1.0,
|
|
|
|
1.0, 0.5);
|
2008-04-28 07:23:27 -04:00
|
|
|
|
|
|
|
cogl_pop_matrix ();
|
|
|
|
|
|
|
|
cogl_push_matrix ();
|
|
|
|
cogl_translate (tex_width * 3 / 2 + 60, 0, 0);
|
|
|
|
cogl_rotate (priv->frame, 0, 1, 0);
|
|
|
|
cogl_translate (-tex_width / 2 - 10, 0, 0);
|
|
|
|
|
|
|
|
/* Draw the texture split into two triangles */
|
2010-03-31 14:03:02 -04:00
|
|
|
test_coglbox_triangle_texture (tex_width, tex_height,
|
2008-04-28 07:23:27 -04:00
|
|
|
0, 0,
|
|
|
|
0, 0,
|
2009-03-09 13:34:23 -04:00
|
|
|
0, 1,
|
|
|
|
1, 1);
|
2010-03-31 14:03:02 -04:00
|
|
|
test_coglbox_triangle_texture (tex_width, tex_height,
|
2009-03-09 13:34:23 -04:00
|
|
|
20, 0,
|
2008-04-28 07:23:27 -04:00
|
|
|
0, 0,
|
2009-03-09 13:34:23 -04:00
|
|
|
1, 0,
|
|
|
|
1, 1);
|
2008-04-28 07:23:27 -04:00
|
|
|
|
|
|
|
cogl_pop_matrix ();
|
2009-06-04 11:04:57 -04:00
|
|
|
|
2019-02-20 08:51:12 -05:00
|
|
|
cogl_object_unref (material);
|
2008-04-25 09:37:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
test_coglbox_finalize (GObject *object)
|
|
|
|
{
|
|
|
|
G_OBJECT_CLASS (test_coglbox_parent_class)->finalize (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
test_coglbox_dispose (GObject *object)
|
|
|
|
{
|
|
|
|
TestCoglboxPrivate *priv;
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
priv = TEST_COGLBOX_GET_PRIVATE (object);
|
2019-02-20 08:51:12 -05:00
|
|
|
cogl_object_unref (priv->not_sliced_tex);
|
|
|
|
cogl_object_unref (priv->sliced_tex);
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
G_OBJECT_CLASS (test_coglbox_parent_class)->dispose (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
test_coglbox_init (TestCoglbox *self)
|
|
|
|
{
|
|
|
|
TestCoglboxPrivate *priv;
|
2008-04-28 07:23:27 -04:00
|
|
|
GError *error = NULL;
|
2009-11-05 12:30:33 -05:00
|
|
|
gchar *file;
|
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
self->priv = priv = TEST_COGLBOX_GET_PRIVATE (self);
|
2008-04-28 07:23:27 -04:00
|
|
|
|
|
|
|
priv->use_linear_filtering = FALSE;
|
|
|
|
priv->use_sliced = FALSE;
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2009-11-05 12:30:33 -05:00
|
|
|
file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);
|
2009-01-18 10:00:18 -05:00
|
|
|
priv->sliced_tex =
|
2009-11-05 12:30:33 -05:00
|
|
|
cogl_texture_new_from_file (file,
|
2009-01-18 10:00:18 -05:00
|
|
|
COGL_TEXTURE_NONE,
|
|
|
|
COGL_PIXEL_FORMAT_ANY,
|
|
|
|
&error);
|
|
|
|
if (priv->sliced_tex == COGL_INVALID_HANDLE)
|
2008-04-28 07:23:27 -04:00
|
|
|
{
|
2009-01-18 10:00:18 -05:00
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
g_warning ("Texture loading failed: %s", error->message);
|
|
|
|
g_error_free (error);
|
|
|
|
error = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
g_warning ("Texture loading failed: <unknown>");
|
2008-04-28 07:23:27 -04:00
|
|
|
}
|
|
|
|
|
2009-01-18 10:00:18 -05:00
|
|
|
priv->not_sliced_tex =
|
2009-11-05 12:30:33 -05:00
|
|
|
cogl_texture_new_from_file (file,
|
[cogl] Remove max_waste argument from Texture ctors
The CoglTexture constructors expose the "max-waste" argument for
controlling the maximum amount of wasted areas for slicing or,
if set to -1, disables slicing.
Slicing is really relevant only for large images that are never
repeated, so it's a useful feature only in controlled use cases.
Specifying the amount of wasted area is, on the other hand, just
a way to mess up this feature; 99% the times, you either pull this
number out of thin air, hoping it's right, or you try to do the
right thing and you choose the wrong number anyway.
Instead, we can use the CoglTextureFlags to control whether the
texture should not be sliced (useful for Clutter-GST and for the
texture-from-pixmap actors) and provide a reasonable value for
enabling the slicing ourself. At some point, we might even
provide a way to change the default at compile time or at run time,
for particular platforms.
Since max_waste is gone, the :tile-waste property of ClutterTexture
becomes read-only, and it proxies the cogl_texture_get_max_waste()
function.
Inside Clutter, the only cases where the max_waste argument was
not set to -1 are in the Pango glyph cache (which is a POT texture
anyway) and inside the test cases where we want to force slicing;
for the latter we can create larger textures that will be bigger than
the threshold we set.
Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
Signed-off-by: Robert Bragg <robert@linux.intel.com>
Signed-off-by: Neil Roberts <neil@linux.intel.com>
2009-05-23 14:18:18 -04:00
|
|
|
COGL_TEXTURE_NO_SLICING,
|
2009-01-18 10:00:18 -05:00
|
|
|
COGL_PIXEL_FORMAT_ANY,
|
|
|
|
&error);
|
|
|
|
if (priv->not_sliced_tex == COGL_INVALID_HANDLE)
|
2008-04-28 07:23:27 -04:00
|
|
|
{
|
2009-01-18 10:00:18 -05:00
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
g_warning ("Texture loading failed: %s", error->message);
|
|
|
|
g_error_free (error);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
g_warning ("Texture loading failed: <unknown>");
|
2008-04-28 07:23:27 -04:00
|
|
|
}
|
2009-11-05 12:30:33 -05:00
|
|
|
|
|
|
|
g_free (file);
|
2008-04-25 09:37:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
test_coglbox_class_init (TestCoglboxClass *klass)
|
|
|
|
{
|
|
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
|
|
|
|
|
|
|
|
gobject_class->finalize = test_coglbox_finalize;
|
2009-05-12 09:15:18 -04:00
|
|
|
gobject_class->dispose = test_coglbox_dispose;
|
2008-04-25 09:37:36 -04:00
|
|
|
actor_class->paint = test_coglbox_paint;
|
|
|
|
}
|
|
|
|
|
2008-11-07 14:32:28 -05:00
|
|
|
static ClutterActor*
|
2008-04-25 09:37:36 -04:00
|
|
|
test_coglbox_new (void)
|
|
|
|
{
|
|
|
|
return g_object_new (TEST_TYPE_COGLBOX, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
frame_cb (ClutterTimeline *timeline,
|
2009-06-11 11:59:50 -04:00
|
|
|
gint elapsed_msecs,
|
2008-04-25 09:37:36 -04:00
|
|
|
gpointer data)
|
|
|
|
{
|
|
|
|
TestCoglboxPrivate *priv = TEST_COGLBOX_GET_PRIVATE (data);
|
2009-06-11 11:59:50 -04:00
|
|
|
gdouble progress = clutter_timeline_get_progress (timeline);
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2009-06-11 11:59:50 -04:00
|
|
|
priv->frame = 360.0 * progress;
|
2008-04-25 09:37:36 -04:00
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (data));
|
|
|
|
}
|
|
|
|
|
2008-04-28 07:23:27 -04:00
|
|
|
static void
|
2008-12-11 08:48:01 -05:00
|
|
|
update_toggle_text (ClutterText *button, gboolean val)
|
2008-04-28 07:23:27 -04:00
|
|
|
{
|
2008-12-11 08:48:01 -05:00
|
|
|
clutter_text_set_text (button, val ? "Enabled" : "Disabled");
|
2008-04-28 07:23:27 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
on_toggle_click (ClutterActor *button, ClutterEvent *event,
|
|
|
|
gboolean *toggle_val)
|
|
|
|
{
|
2008-12-11 08:48:01 -05:00
|
|
|
update_toggle_text (CLUTTER_TEXT (button), *toggle_val = !*toggle_val);
|
2008-04-28 07:23:27 -04:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ClutterActor *
|
|
|
|
make_toggle (const char *label_text, gboolean *toggle_val)
|
|
|
|
{
|
|
|
|
ClutterActor *group = clutter_group_new ();
|
2008-12-11 08:48:01 -05:00
|
|
|
ClutterActor *label = clutter_text_new_with_text ("Sans 14", label_text);
|
|
|
|
ClutterActor *button = clutter_text_new_with_text ("Sans 14", "");
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-28 07:23:27 -04:00
|
|
|
clutter_actor_set_reactive (button, TRUE);
|
|
|
|
|
2008-12-11 08:48:01 -05:00
|
|
|
update_toggle_text (CLUTTER_TEXT (button), *toggle_val);
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-28 07:23:27 -04:00
|
|
|
clutter_actor_set_position (button, clutter_actor_get_width (label) + 10, 0);
|
|
|
|
clutter_container_add (CLUTTER_CONTAINER (group), label, button, NULL);
|
|
|
|
|
|
|
|
g_signal_connect (button, "button-press-event", G_CALLBACK (on_toggle_click),
|
|
|
|
toggle_val);
|
|
|
|
|
|
|
|
return group;
|
|
|
|
}
|
|
|
|
|
2008-11-07 14:32:28 -05:00
|
|
|
G_MODULE_EXPORT int
|
|
|
|
test_cogl_tex_polygon_main (int argc, char *argv[])
|
2008-04-25 09:37:36 -04:00
|
|
|
{
|
|
|
|
ClutterActor *stage;
|
|
|
|
ClutterActor *coglbox;
|
2008-04-28 07:23:27 -04:00
|
|
|
ClutterActor *filtering_toggle;
|
|
|
|
ClutterActor *slicing_toggle;
|
|
|
|
ClutterActor *note;
|
2008-04-25 09:37:36 -04:00
|
|
|
ClutterTimeline *timeline;
|
|
|
|
ClutterColor blue = { 0x30, 0x30, 0xff, 0xff };
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2011-02-21 19:19:35 -05:00
|
|
|
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
|
|
|
|
return 1;
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
/* Stage */
|
2011-11-09 08:41:15 -05:00
|
|
|
stage = clutter_stage_new ();
|
2008-04-25 09:37:36 -04:00
|
|
|
clutter_stage_set_color (CLUTTER_STAGE (stage), &blue);
|
2008-04-28 07:23:27 -04:00
|
|
|
clutter_actor_set_size (stage, 640, 480);
|
2011-11-09 08:41:15 -05:00
|
|
|
clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl Texture Polygon");
|
|
|
|
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
/* Cogl Box */
|
|
|
|
coglbox = test_coglbox_new ();
|
|
|
|
clutter_container_add_actor (CLUTTER_CONTAINER (stage), coglbox);
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
/* Timeline for animation */
|
2009-06-04 08:05:12 -04:00
|
|
|
timeline = clutter_timeline_new (6000);
|
2009-05-31 10:15:46 -04:00
|
|
|
clutter_timeline_set_loop (timeline, TRUE);
|
2008-04-25 09:37:36 -04:00
|
|
|
g_signal_connect (timeline, "new-frame", G_CALLBACK (frame_cb), coglbox);
|
|
|
|
clutter_timeline_start (timeline);
|
2008-04-28 07:23:27 -04:00
|
|
|
|
|
|
|
/* Labels for toggling settings */
|
|
|
|
slicing_toggle = make_toggle ("Texture slicing: ",
|
|
|
|
&(TEST_COGLBOX_GET_PRIVATE (coglbox)
|
|
|
|
->use_sliced));
|
|
|
|
clutter_actor_set_position (slicing_toggle, 0,
|
|
|
|
clutter_actor_get_height (stage)
|
|
|
|
- clutter_actor_get_height (slicing_toggle));
|
|
|
|
filtering_toggle = make_toggle ("Linear filtering: ",
|
|
|
|
&(TEST_COGLBOX_GET_PRIVATE (coglbox)
|
|
|
|
->use_linear_filtering));
|
|
|
|
clutter_actor_set_position (filtering_toggle, 0,
|
|
|
|
clutter_actor_get_y (slicing_toggle)
|
|
|
|
- clutter_actor_get_height (filtering_toggle));
|
2008-12-11 08:48:01 -05:00
|
|
|
note = clutter_text_new_with_text ("Sans 10", "<- Click to change");
|
2008-04-28 07:23:27 -04:00
|
|
|
clutter_actor_set_position (note,
|
|
|
|
clutter_actor_get_width (filtering_toggle) + 10,
|
|
|
|
(clutter_actor_get_height (stage)
|
|
|
|
+ clutter_actor_get_y (filtering_toggle)) / 2
|
|
|
|
- clutter_actor_get_height (note) / 2);
|
|
|
|
|
|
|
|
clutter_container_add (CLUTTER_CONTAINER (stage),
|
|
|
|
slicing_toggle,
|
|
|
|
filtering_toggle,
|
|
|
|
note,
|
|
|
|
NULL);
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-28 07:23:27 -04:00
|
|
|
clutter_actor_show (stage);
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
clutter_main ();
|
2009-05-12 09:15:18 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
return 0;
|
|
|
|
}
|
2011-11-09 08:41:15 -05:00
|
|
|
|
|
|
|
G_MODULE_EXPORT const char *
|
|
|
|
test_cogl_tex_polygon_describe (void)
|
|
|
|
{
|
|
|
|
return "Texture polygon primitive.";
|
|
|
|
}
|