brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tests: Convert test-npot-texture to Cogl

Browse Source 
This updates the npot-texture test to use Cogl directly instead of
relying on Clutter.

Note that this currently fails when Cogl ends up using sliced
textures. It looks like there is some bug with the meta texture
function to iterate the primitive textures. This happens when
COGL_DEBUG=disable-npot-textures is set.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit 32f0e1e8fff56be3123dc4571f07bb5a314f6818)
This commit is contained in:
Neil Roberts 2012-11-09 16:28:53 +00:00 committed by Robert Bragg
parent 41d59c0af7
commit 11126a1b7e
3 changed files with 74 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tests/conform/Makefile.am
View File

@ -59,6 +59,7 @@ test_sources = \
test-layer-remove.c \ test-layer-remove.c \
test-alpha-test.c \ test-alpha-test.c \
test-map-buffer-range.c \ test-map-buffer-range.c \
test-npot-texture.c \
$(NULL) $(NULL)
test_conformance_SOURCES = $(common_sources) $(test_sources) test_conformance_SOURCES = $(common_sources) $(test_sources)

2
tests/conform/test-conform-main.c
View File

@ -63,7 +63,7 @@ main (int argc, char **argv)
ADD_TEST (test_sparse_pipeline, 0); ADD_TEST (test_sparse_pipeline, 0);
UNPORTED_TEST (test_npot_texture); ADD_TEST (test_npot_texture, TEST_REQUIREMENT_NPOT);
UNPORTED_TEST (test_multitexture); UNPORTED_TEST (test_multitexture);
UNPORTED_TEST (test_texture_mipmaps); UNPORTED_TEST (test_texture_mipmaps);
ADD_TEST (test_sub_texture, 0); ADD_TEST (test_sub_texture, 0);

210
tests/conform/test-npot-texture.c
View File

@ -1,10 +1,8 @@
#include <clutter/clutter.h>
#include <cogl/cogl.h> #include <cogl/cogl.h>
#include <string.h> #include <string.h>
#include "test-conform-common.h" #include "test-utils.h"
static const ClutterColor stage_color = { 0x0, 0x0, 0x0, 0xff };
/* Non-power-of-two sized texture that should cause slicing */ /* Non-power-of-two sized texture that should cause slicing */
#define TEXTURE_SIZE 384 #define TEXTURE_SIZE 384
@ -22,111 +20,44 @@ static const ClutterColor stage_color = { 0x0, 0x0, 0x0, 0xff };
/* The size of a part once rendered */ /* The size of a part once rendered */
#define PART_RENDER_SIZE (TEXTURE_RENDER_SIZE / PARTS) #define PART_RENDER_SIZE (TEXTURE_RENDER_SIZE / PARTS)
static const ClutterColor corner_colors[PARTS * PARTS] = static const uint32_t corner_colors[PARTS * PARTS] =
{ {
/* Top left - red */ { 255, 0, 0, 255 }, /* Top left - red */ 0xff0000ff,
/* Top right - green */ { 0, 255, 0, 255 }, /* Top right - green */ 0x00ff00ff,
/* Bottom left - blue */ { 0, 0, 255, 255 }, /* Bottom left - blue */ 0x0000ffff,
/* Bottom right - yellow */ { 255, 255, 0, 255 } /* Bottom right - yellow */ 0xffff00ff
}; };
typedef struct _TestState static void
validate_part (int xnum,
int ynum,
uint32_t color)
{ {
unsigned int frame; test_utils_check_region (fb,
CoglHandle texture; xnum * PART_RENDER_SIZE + TEST_INSET,
} TestState; ynum * PART_RENDER_SIZE + TEST_INSET,
PART_RENDER_SIZE - TEST_INSET * 2,
static CoglBool PART_RENDER_SIZE - TEST_INSET * 2,
validate_part (int xnum, int ynum, const ClutterColor *color) color);
{
guchar *pixels, *p;
ClutterActor *stage = clutter_stage_get_default ();
CoglBool ret = TRUE;
/* Read the appropriate part but skip out a few pixels around the
edges */
pixels = clutter_stage_read_pixels (CLUTTER_STAGE (stage),
xnum * PART_RENDER_SIZE + TEST_INSET,
ynum * PART_RENDER_SIZE + TEST_INSET,
PART_RENDER_SIZE - TEST_INSET * 2,
PART_RENDER_SIZE - TEST_INSET * 2);
/* Make sure every pixels is the appropriate color */
for (p = pixels;
p < pixels + ((PART_RENDER_SIZE - TEST_INSET * 2)
* (PART_RENDER_SIZE - TEST_INSET * 2));
p += 4)
{
if (p[0] != color->red)
ret = FALSE;
if (p[1] != color->green)
ret = FALSE;
if (p[2] != color->blue)
ret = FALSE;
}
g_free (pixels);
return ret;
} }
static void static void
validate_result (TestState *state) validate_result (void)
{ {
/* Validate that all four corners of the texture are drawn in the /* Validate that all four corners of the texture are drawn in the
right color */ right color */
g_assert (validate_part (0, 0, corner_colors + 0)); validate_part (0, 0, corner_colors[0]);
g_assert (validate_part (1, 0, corner_colors + 1)); validate_part (1, 0, corner_colors[1]);
g_assert (validate_part (0, 1, corner_colors + 2)); validate_part (0, 1, corner_colors[2]);
g_assert (validate_part (1, 1, corner_colors + 3)); validate_part (1, 1, corner_colors[3]);
/* Comment this out if you want visual feedback of what this test
* paints.
*/
clutter_main_quit ();
} }
static void static CoglTexture *
on_paint (ClutterActor *actor, TestState *state)
{
int frame_num;
int y, x;
/* Just render the texture in the top left corner */
cogl_set_source_texture (state->texture);
/* Render the texture using four separate rectangles */
for (y = 0; y < 2; y++)
for (x = 0; x < 2; x++)
cogl_rectangle_with_texture_coords (x * TEXTURE_RENDER_SIZE / 2,
y * TEXTURE_RENDER_SIZE / 2,
(x + 1) * TEXTURE_RENDER_SIZE / 2,
(y + 1) * TEXTURE_RENDER_SIZE / 2,
x / 2.0f,
y / 2.0f,
(x + 1) / 2.0f,
(y + 1) / 2.0f);
/* XXX: validate_result calls clutter_stage_read_pixels which will result in
* another paint run so to avoid infinite recursion we only aim to validate
* the first frame. */
frame_num = state->frame++;
if (frame_num == 1)
validate_result (state);
}
static CoglBool
queue_redraw (void *stage)
{
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
return TRUE;
}
static CoglHandle
make_texture (void) make_texture (void)
{ {
guchar *tex_data, *p; void *tex_data;
CoglHandle tex; uint32_t *p;
CoglTexture *tex;
int partx, party, width, height; int partx, party, width, height;
p = tex_data = g_malloc (TEXTURE_SIZE * TEXTURE_SIZE * 4); p = tex_data = g_malloc (TEXTURE_SIZE * TEXTURE_SIZE * 4);
@ -140,31 +71,26 @@ make_texture (void)
for (partx = 0; partx < PARTS; partx++) for (partx = 0; partx < PARTS; partx++)
{ {
const ClutterColor *color = corner_colors + party * PARTS + partx; uint32_t color = corner_colors[party * PARTS + partx];
width = (partx < PARTS - 1 width = (partx < PARTS - 1
? PART_SIZE ? PART_SIZE
: TEXTURE_SIZE - PART_SIZE * (PARTS - 1)); : TEXTURE_SIZE - PART_SIZE * (PARTS - 1));
while (width-- > 0) while (width-- > 0)
{ *(p++) = GUINT32_TO_BE (color);
*(p++) = color->red;
*(p++) = color->green;
*(p++) = color->blue;
*(p++) = color->alpha;
}
} }
while (--height > 0) while (--height > 0)
{ {
memcpy (p, p - TEXTURE_SIZE * 4, TEXTURE_SIZE * 4); memcpy (p, p - TEXTURE_SIZE, TEXTURE_SIZE * 4);
p += TEXTURE_SIZE * 4; p += TEXTURE_SIZE;
} }
} }
tex = cogl_texture_new_from_data (TEXTURE_SIZE, tex = cogl_texture_new_from_data (TEXTURE_SIZE,
TEXTURE_SIZE, TEXTURE_SIZE,
COGL_TEXTURE_NO_ATLAS, COGL_TEXTURE_NO_ATLAS,
COGL_PIXEL_FORMAT_RGBA_8888, COGL_PIXEL_FORMAT_RGBA_8888_PRE,
COGL_PIXEL_FORMAT_ANY, COGL_PIXEL_FORMAT_ANY,
TEXTURE_SIZE * 4, TEXTURE_SIZE * 4,
tex_data); tex_data);
@ -180,55 +106,63 @@ make_texture (void)
} }
/* The texture should be sliced unless NPOTs are supported */ /* The texture should be sliced unless NPOTs are supported */
g_assert (cogl_features_available (COGL_FEATURE_TEXTURE_NPOT) g_assert (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT)
? !cogl_texture_is_sliced (tex) ? !cogl_texture_is_sliced (tex)
: cogl_texture_is_sliced (tex)); : cogl_texture_is_sliced (tex));
return tex; return tex;
} }
void static void
test_npot_texture (TestUtilsGTestFixture *fixture, paint (void)
void *data)
{ {
TestState state; CoglPipeline *pipeline = cogl_pipeline_new (ctx);
ClutterActor *stage; CoglTexture *texture = make_texture ();
ClutterActor *group; int y, x;
unsigned int idle_source;
cogl_pipeline_set_layer_texture (pipeline, 0, texture);
/* Just render the texture in the top left corner */
/* Render the texture using four separate rectangles */
for (y = 0; y < 2; y++)
for (x = 0; x < 2; x++)
cogl_framebuffer_draw_textured_rectangle (fb,
pipeline,
x * TEXTURE_RENDER_SIZE / 2,
y * TEXTURE_RENDER_SIZE / 2,
(x + 1) *
TEXTURE_RENDER_SIZE / 2,
(y + 1) *
TEXTURE_RENDER_SIZE / 2,
x / 2.0f,
y / 2.0f,
(x + 1) / 2.0f,
(y + 1) / 2.0f);
cogl_object_unref (pipeline);
cogl_object_unref (texture);
}
void
test_npot_texture (void)
{
if (cogl_test_verbose ()) if (cogl_test_verbose ())
{ {
if (cogl_features_available (COGL_FEATURE_TEXTURE_NPOT)) if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT))
g_print ("NPOT textures are supported\n"); g_print ("NPOT textures are supported\n");
else else
g_print ("NPOT textures are not supported\n"); g_print ("NPOT textures are not supported\n");
} }
state.frame = 0; cogl_framebuffer_orthographic (fb,
0, 0,
cogl_framebuffer_get_width (fb),
cogl_framebuffer_get_height (fb),
-1,
100);
state.texture = make_texture (); paint ();
validate_result ();
stage = clutter_stage_get_default ();
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
group = clutter_group_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), group);
/* We force continuous redrawing of the stage, since we need to skip
* the first few frames, and we wont be doing anything else that
* will trigger redrawing. */
idle_source = g_idle_add (queue_redraw, stage);
g_signal_connect (group, "paint", G_CALLBACK (on_paint), &state);
clutter_actor_show_all (stage);
clutter_main ();
g_source_remove (idle_source);
cogl_handle_unref (state.texture);
if (cogl_test_verbose ()) if (cogl_test_verbose ())
g_print ("OK\n"); g_print ("OK\n");