[cogl/wip/cogl-1.14: 166/177] Add a conformance test for some wrap modes on a rectangle texture

[Robert Bragg <rbragg src gnome org>]

commit 03c25c97bd9dd1dbcc774de5c01db527f50d451a
Author: Neil Roberts <neil linux intel com>
Date:   Mon Dec 10 18:11:28 2012 +0000

    Add a conformance test for some wrap modes on a rectangle texture
    
    This adds a conformance test which renders a rectangle texture using
    the two wrap modes clamp-to-edge and repeat. It then verifies that the
    correct region of the texture is drawn for the texture coordinates
    that are > 1.0.
    
    The test currently always fails. The cogl_framebuffer_draw_rectangle
    function is documented to always take normalized texture coordinates
    regardless of the coordinate system of the texture. This works
    correctly if all of the texture coordinates are in the range [0.0,1.0]
    because cogl-primitives uses a different code path in that case.
    However if the multiple-quad code path is taken then the coordinates
    actually need to un-normalized for it to work.
    
    There is a comment in cogl_meta_texture_foreach_in_region() which
    implies that the incoming coordinates should always be normalized.
    The documentation for the callback says that the resulting sub-texture
    coordinates will always be in the coordinate system of the low-level
    texture. However it doesn't work out like this because the meta
    texture function uses the span iterating function which always returns
    normalized coordinates. It looks like there needs to be some more
    conversions going on somewhere.
    
    Reviewed-by: Robert Bragg <robert linux intel com>
    
    (cherry picked from commit d2059bb32b8015060e10f41dbbb68d4230b47ddb)

 tests/conform/Makefile.am                    |    1 +
 tests/conform/test-conform-main.c            |    3 +
 tests/conform/test-utils.c                   |    6 +
 tests/conform/test-utils.h                   |   17 ++-
 tests/conform/test-wrap-rectangle-textures.c |  179 ++++++++++++++++++++++++++
 5 files changed, 198 insertions(+), 8 deletions(-)
---
diff --git a/tests/conform/Makefile.am b/tests/conform/Makefile.am
index f068815..3cc1e14 100644
--- a/tests/conform/Makefile.am
+++ b/tests/conform/Makefile.am
@@ -60,6 +60,7 @@ test_sources = \
 	test-map-buffer-range.c \
 	test-npot-texture.c \
 	test-alpha-textures.c \
+	test-wrap-rectangle-textures.c \
 	test-texture-get-set-data.c \
 	$(NULL)
 
diff --git a/tests/conform/test-conform-main.c b/tests/conform/test-conform-main.c
index 643a59e..b0aaebd 100644
--- a/tests/conform/test-conform-main.c
+++ b/tests/conform/test-conform-main.c
@@ -80,6 +80,9 @@ main (int argc, char **argv)
   ADD_TEST (test_read_texture_formats, 0, 0);
   ADD_TEST (test_write_texture_formats, 0, 0);
   ADD_TEST (test_alpha_textures, 0, 0);
+  ADD_TEST (test_wrap_rectangle_textures,
+            TEST_REQUIREMENT_TEXTURE_RECTANGLE,
+            TEST_KNOWN_FAILURE);
 
   UNPORTED_TEST (test_vertex_buffer_contiguous);
   UNPORTED_TEST (test_vertex_buffer_interleved);
diff --git a/tests/conform/test-utils.c b/tests/conform/test-utils.c
index 9f3a4b4..6062ec6 100644
--- a/tests/conform/test-utils.c
+++ b/tests/conform/test-utils.c
@@ -35,6 +35,12 @@ check_flags (TestFlags flags,
       return FALSE;
     }
 
+  if (flags & TEST_REQUIREMENT_TEXTURE_RECTANGLE &&
+      !cogl_has_feature (test_ctx, COGL_FEATURE_ID_TEXTURE_RECTANGLE))
+    {
+      return FALSE;
+    }
+
   if (flags & TEST_REQUIREMENT_POINT_SPRITE &&
       !cogl_has_feature (test_ctx, COGL_FEATURE_ID_POINT_SPRITE))
     {
diff --git a/tests/conform/test-utils.h b/tests/conform/test-utils.h
index 02af5f4..ec96913 100644
--- a/tests/conform/test-utils.h
+++ b/tests/conform/test-utils.h
@@ -11,14 +11,15 @@
 
 typedef enum _TestFlags
 {
-  TEST_KNOWN_FAILURE             = 1<<0,
-  TEST_REQUIREMENT_GL            = 1<<1,
-  TEST_REQUIREMENT_NPOT          = 1<<2,
-  TEST_REQUIREMENT_TEXTURE_3D    = 1<<3,
-  TEST_REQUIREMENT_POINT_SPRITE  = 1<<4,
-  TEST_REQUIREMENT_GLES2_CONTEXT = 1<<5,
-  TEST_REQUIREMENT_MAP_WRITE     = 1<<6,
-  TEST_REQUIREMENT_GLSL          = 1<<7
+  TEST_KNOWN_FAILURE = 1<<0,
+  TEST_REQUIREMENT_GL = 1<<1,
+  TEST_REQUIREMENT_NPOT = 1<<2,
+  TEST_REQUIREMENT_TEXTURE_3D = 1<<3,
+  TEST_REQUIREMENT_TEXTURE_RECTANGLE = 1<<4,
+  TEST_REQUIREMENT_POINT_SPRITE = 1<<5,
+  TEST_REQUIREMENT_GLES2_CONTEXT = 1<<6,
+  TEST_REQUIREMENT_MAP_WRITE = 1<<7,
+  TEST_REQUIREMENT_GLSL = 1<<8
 } TestFlags;
 
 extern CoglContext *test_ctx;
diff --git a/tests/conform/test-wrap-rectangle-textures.c b/tests/conform/test-wrap-rectangle-textures.c
new file mode 100644
index 0000000..7fee765
--- /dev/null
+++ b/tests/conform/test-wrap-rectangle-textures.c
@@ -0,0 +1,179 @@
+#include <cogl/cogl.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include <string.h>
+
+#include "test-utils.h"
+
+#define DRAW_SIZE 64
+
+static CoglPipeline *
+create_base_pipeline (void)
+{
+  CoglBitmap *bmp;
+  CoglTextureRectangle *tex;
+  CoglPipeline *pipeline;
+  uint8_t tex_data[] =
+    {
+      0x44, 0x44, 0x44, 0x88, 0x88, 0x88,
+      0xcc, 0xcc, 0xcc, 0xff, 0xff, 0xff
+    };
+
+  bmp = cogl_bitmap_new_for_data (test_ctx,
+                                  2, 2, /* width/height */
+                                  COGL_PIXEL_FORMAT_RGB_888,
+                                  2 * 3, /* rowstride */
+                                  tex_data);
+
+  tex = cogl_texture_rectangle_new_from_bitmap (bmp,
+                                                /* internal format */
+                                                COGL_PIXEL_FORMAT_ANY,
+                                                NULL);
+
+  cogl_object_unref (bmp);
+
+  pipeline = cogl_pipeline_new (test_ctx);
+
+  cogl_pipeline_set_layer_filters (pipeline,
+                                   0, /* layer */
+                                   COGL_PIPELINE_FILTER_NEAREST,
+                                   COGL_PIPELINE_FILTER_NEAREST);
+
+  cogl_pipeline_set_layer_texture (pipeline,
+                                   0, /* layer */
+                                   COGL_TEXTURE (tex));
+
+  cogl_object_unref (tex);
+
+  return pipeline;
+}
+
+static void
+check_colors (int x_offset,
+              int y_offset,
+              const uint8_t expected_colors[9])
+{
+  int x, y;
+
+  for (y = 0; y < 4; y++)
+    for (x = 0; x < 4; x++)
+      {
+        uint32_t color = expected_colors[x + y * 4];
+        test_utils_check_region (test_fb,
+                                 x * DRAW_SIZE / 4 + 1 + x_offset,
+                                 y * DRAW_SIZE / 4 + 1 + y_offset,
+                                 DRAW_SIZE / 4 - 2,
+                                 DRAW_SIZE / 4 - 2,
+                                 0xff |
+                                 (color << 8) |
+                                 (color << 16) |
+                                 (color << 24));
+      }
+}
+
+static void
+test_pipeline (CoglPipeline *pipeline,
+               int x_offset,
+               int y_offset,
+               const uint8_t expected_colors[9])
+{
+  float x1 = x_offset;
+  float y1 = y_offset;
+  float x2 = x1 + DRAW_SIZE;
+  float y2 = y1 + DRAW_SIZE;
+  int y, x;
+
+  cogl_framebuffer_draw_textured_rectangle (test_fb,
+                                            pipeline,
+                                            x1, y1,
+                                            x2, y2,
+                                            -0.5f, /* s1 */
+                                            -0.5f, /* t1 */
+                                            1.5f, /* s2 */
+                                            1.5f /* t2 */);
+
+  check_colors (x_offset, y_offset, expected_colors);
+
+  /* Also try drawing each quadrant of the rectangle with a small
+   * rectangle */
+
+  for (y = -1; y < 3; y++)
+    for (x = -1; x < 3; x++)
+      {
+        x1 = x_offset + (x + 1) * DRAW_SIZE / 4 + DRAW_SIZE;
+        y1 = y_offset + (y + 1) * DRAW_SIZE / 4;
+        x2 = x1 + DRAW_SIZE / 4;
+        y2 = y1 + DRAW_SIZE / 4;
+
+        cogl_framebuffer_draw_textured_rectangle (test_fb,
+                                                  pipeline,
+                                                  x1, y1,
+                                                  x2, y2,
+                                                  x / 2.0f, /* s1 */
+                                                  y / 2.0f, /* t1 */
+                                                  (x + 1) / 2.0f, /* s2 */
+                                                  (y + 1) / 2.0f /* t2 */);
+      }
+
+  check_colors (x_offset + DRAW_SIZE, y_offset, expected_colors);
+}
+
+void
+test_wrap_rectangle_textures (void)
+{
+  float fb_width = cogl_framebuffer_get_width (test_fb);
+  float fb_height = cogl_framebuffer_get_height (test_fb);
+  CoglPipeline *base_pipeline;
+  CoglPipeline *clamp_pipeline;
+  CoglPipeline *repeat_pipeline;
+  /* The textures are drawn with the texture coordinates from
+   * -0.5â1.5. That means we get one complete copy of the texture and
+   * an extra half of the texture surrounding it. The drawing is
+   * tested against a 4x4 grid of colors. The center 2x2 colours
+   * specify the normal texture colors and the other colours specify
+   * what the wrap mode should generate */
+  static const uint8_t clamp_colors[] =
+    {
+      0x44, 0x44, 0x88, 0x88,
+      0x44, 0x44, 0x88, 0x88,
+      0xcc, 0xcc, 0xff, 0xff,
+      0xcc, 0xcc, 0xff, 0xff
+    };
+  static const uint8_t repeat_colors[] =
+    {
+      0xff, 0xcc, 0xff, 0xcc,
+      0x88, 0x44, 0x88, 0x44,
+      0xff, 0xcc, 0xff, 0xcc,
+      0x88, 0x44, 0x88, 0x44
+    };
+
+  cogl_framebuffer_orthographic (test_fb,
+                                 0, 0, /* x_1, y_1 */
+                                 fb_width, /* x_2 */
+                                 fb_height /* y_2 */,
+                                 -1, 100 /* near/far */);
+
+  base_pipeline = create_base_pipeline ();
+
+  clamp_pipeline = cogl_pipeline_copy (base_pipeline);
+  cogl_pipeline_set_layer_wrap_mode (clamp_pipeline,
+                                     0, /* layer */
+                                     COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE);
+
+  repeat_pipeline = cogl_pipeline_copy (base_pipeline);
+  cogl_pipeline_set_layer_wrap_mode (repeat_pipeline,
+                                     0, /* layer */
+                                     COGL_PIPELINE_WRAP_MODE_REPEAT);
+
+  test_pipeline (clamp_pipeline,
+                 0, 0, /* x/y offset */
+                 clamp_colors);
+
+  test_pipeline (repeat_pipeline,
+                 0, DRAW_SIZE * 2, /* x/y offset */
+                 repeat_colors);
+
+  cogl_object_unref (repeat_pipeline);
+  cogl_object_unref (clamp_pipeline);
+  cogl_object_unref (base_pipeline);
+}