isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-10 16:16:20 -05:00
Code Issues Packages Projects Releases Wiki Activity
364f232507
mutter/tests/conform/test-gles2-context.c
Robert Bragg 73e8a6d7ce Allow lazy texture storage allocation 
Consistent with how we lazily allocate framebuffers this patch allows us
to instantiate textures but still specify constraints and requirements
before allocating storage so that we can be sure to allocate the most
appropriate/efficient storage.

This adds a cogl_texture_allocate() function that is analogous to
cogl_framebuffer_allocate() which can optionally be called to explicitly
allocate storage and catch any errors. If this function isn't used
explicitly then Cogl will implicitly ensure textures are allocated
before the storage is needed.

It is generally recommended to rely on lazy storage allocation or at
least perform explicit allocation as late as possible so Cogl can be
fully informed about the best way to allocate storage.

Reviewed-by: Neil Roberts <neil@linux.intel.com>

(cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7)

Note: This reverts the cogl_texture_rectangle_new_with_size API change
that dropped the CoglError argument and keeps the semantics of
allocating the texture immediately. This is because Mutter currently
uses this API so we will probably look at updating this later once
we have a corresponding Mutter patch prepared. The other API changes
were kept since they only affected experimental api.
2013-01-22 17:48:17 +00:00

975 lines
30 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include <cogl/cogl.h>
#include <cogl/cogl-gles2.h>
#include <string.h>
#include "test-utils.h"
typedef struct _TestState
{
CoglTexture *offscreen_texture;
CoglOffscreen *offscreen;
CoglGLES2Context *gles2_ctx;
const CoglGLES2Vtable *gles2;
} TestState;
static void
test_push_pop_single_context (void)
{
CoglTexture *offscreen_texture;
CoglOffscreen *offscreen;
CoglPipeline *pipeline;
CoglGLES2Context *gles2_ctx;
const CoglGLES2Vtable *gles2;
CoglError *error = NULL;
offscreen_texture = COGL_TEXTURE (
cogl_texture_2d_new_with_size (test_ctx,
cogl_framebuffer_get_width (test_fb),
cogl_framebuffer_get_height (test_fb),
COGL_PIXEL_FORMAT_ANY));
offscreen = cogl_offscreen_new_to_texture (offscreen_texture);
pipeline = cogl_pipeline_new (test_ctx);
cogl_pipeline_set_layer_texture (pipeline, 0, offscreen_texture);
gles2_ctx = cogl_gles2_context_new (test_ctx, &error);
if (!gles2_ctx)
g_error ("Failed to create GLES2 context: %s\n", error->message);
gles2 = cogl_gles2_context_get_vtable (gles2_ctx);
/* Clear onscreen to 0xffff00 using GLES2 */
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx,
test_fb,
test_fb,
&error))
{
g_error ("Failed to push gles2 context: %s\n", error->message);
}
gles2->glClearColor (1, 1, 0, 1);
gles2->glClear (GL_COLOR_BUFFER_BIT);
cogl_pop_gles2_context (test_ctx);
test_utils_check_pixel (test_fb, 0, 0, 0xffff00ff);
/* Clear offscreen to 0xff0000 using GLES2 and then copy the result
* onscreen.
*
* If we fail to bind the new context here then we'd probably end up
* clearing onscreen to 0xff0000 and copying 0xffff00 to onscreen
* instead.
*/
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx,
COGL_FRAMEBUFFER (offscreen),
COGL_FRAMEBUFFER (offscreen),
&error))
{
g_error ("Failed to push gles2 context: %s\n", error->message);
}
gles2->glClearColor (1, 0, 0, 1);
gles2->glClear (GL_COLOR_BUFFER_BIT);
cogl_pop_gles2_context (test_ctx);
cogl_framebuffer_draw_rectangle (test_fb,
pipeline,
-1, 1, 1, -1);
/* NB: Cogl doesn't automatically support mid-scene modifications
* of textures and so we explicitly flush the drawn rectangle to the
* framebuffer now otherwise it may be batched until after the
* offscreen texture has been modified again. */
cogl_flush ();
/* Clear the offscreen framebuffer to blue using GLES2 before
* reading back from the onscreen framebuffer in case we mistakenly
* read from the offscreen framebuffer and get a false positive
*/
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx,
COGL_FRAMEBUFFER (offscreen),
COGL_FRAMEBUFFER (offscreen),
&error))
{
g_error ("Failed to push gles2 context: %s\n", error->message);
}
gles2->glClearColor (0, 0, 1, 1);
gles2->glClear (GL_COLOR_BUFFER_BIT);
cogl_pop_gles2_context (test_ctx);
test_utils_check_pixel (test_fb, 0, 0, 0xff0000ff);
/* Now copy the offscreen blue clear to the onscreen framebufer and
* check that too */
cogl_framebuffer_draw_rectangle (test_fb,
pipeline,
-1, 1, 1, -1);
test_utils_check_pixel (test_fb, 0, 0, 0x0000ffff);
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx,
test_fb,
test_fb,
&error))
{
g_error ("Failed to push gles2 context: %s\n", error->message);
}
gles2->glClearColor (1, 0, 1, 1);
gles2->glClear (GL_COLOR_BUFFER_BIT);
cogl_pop_gles2_context (test_ctx);
test_utils_check_pixel (test_fb, 0, 0, 0xff00ffff);
cogl_object_unref (gles2_ctx);
cogl_object_unref (pipeline);
}
static void
create_gles2_context (CoglTexture **offscreen_texture,
CoglOffscreen **offscreen,
CoglPipeline **pipeline,
CoglGLES2Context **gles2_ctx,
const CoglGLES2Vtable **gles2)
{
CoglError *error = NULL;
*offscreen_texture = COGL_TEXTURE (
cogl_texture_2d_new_with_size (test_ctx,
cogl_framebuffer_get_width (test_fb),
cogl_framebuffer_get_height (test_fb),
COGL_PIXEL_FORMAT_ANY));
*offscreen = cogl_offscreen_new_to_texture (*offscreen_texture);
*pipeline = cogl_pipeline_new (test_ctx);
cogl_pipeline_set_layer_texture (*pipeline, 0, *offscreen_texture);
*gles2_ctx = cogl_gles2_context_new (test_ctx, &error);
if (!*gles2_ctx)
g_error ("Failed to create GLES2 context: %s\n", error->message);
*gles2 = cogl_gles2_context_get_vtable (*gles2_ctx);
}
static void
test_push_pop_multi_context (void)
{
CoglTexture *offscreen_texture0;
CoglOffscreen *offscreen0;
CoglPipeline *pipeline0;
CoglGLES2Context *gles2_ctx0;
const CoglGLES2Vtable *gles20;
CoglTexture *offscreen_texture1;
CoglOffscreen *offscreen1;
CoglPipeline *pipeline1;
CoglGLES2Context *gles2_ctx1;
const CoglGLES2Vtable *gles21;
CoglError *error = NULL;
create_gles2_context (&offscreen_texture0,
&offscreen0,
&pipeline0,
&gles2_ctx0,
&gles20);
create_gles2_context (&offscreen_texture1,
&offscreen1,
&pipeline1,
&gles2_ctx1,
&gles21);
cogl_framebuffer_clear4f (test_fb, COGL_BUFFER_BIT_COLOR, 1, 1, 1, 1);
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx0,
COGL_FRAMEBUFFER (offscreen0),
COGL_FRAMEBUFFER (offscreen0),
&error))
{
g_error ("Failed to push gles2 context 0: %s\n", error->message);
}
gles20->glClearColor (1, 0, 0, 1);
gles20->glClear (GL_COLOR_BUFFER_BIT);
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx1,
COGL_FRAMEBUFFER (offscreen1),
COGL_FRAMEBUFFER (offscreen1),
&error))
{
g_error ("Failed to push gles2 context 1: %s\n", error->message);
}
gles21->glClearColor (0, 1, 0, 1);
gles21->glClear (GL_COLOR_BUFFER_BIT);
cogl_pop_gles2_context (test_ctx);
cogl_pop_gles2_context (test_ctx);
test_utils_check_pixel (test_fb, 0, 0, 0xffffffff);
cogl_framebuffer_draw_rectangle (test_fb,
pipeline0,
-1, 1, 1, -1);
test_utils_check_pixel (test_fb, 0, 0, 0xff0000ff);
cogl_framebuffer_draw_rectangle (test_fb,
pipeline1,
-1, 1, 1, -1);
test_utils_check_pixel (test_fb, 0, 0, 0x00ff00ff);
}
static GLuint
create_gles2_framebuffer (const CoglGLES2Vtable *gles2,
int width,
int height)
{
GLuint texture_handle;
GLuint fbo_handle;
GLenum status;
gles2->glGenTextures (1, &texture_handle);
gles2->glGenFramebuffers (1, &fbo_handle);
gles2->glBindTexture (GL_TEXTURE_2D, texture_handle);
gles2->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gles2->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gles2->glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
GL_UNSIGNED_BYTE, NULL);
gles2->glBindTexture (GL_TEXTURE_2D, 0);
gles2->glBindFramebuffer (GL_FRAMEBUFFER, fbo_handle);
gles2->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, texture_handle, 0);
status = gles2->glCheckFramebufferStatus (GL_FRAMEBUFFER);
if (cogl_test_verbose ())
g_print ("status for gles2 framebuffer = 0x%x %s\n",
status, status == GL_FRAMEBUFFER_COMPLETE ? "(complete)" : "(?)");
gles2->glBindFramebuffer (GL_FRAMEBUFFER, 0);
return fbo_handle;
}
static void
test_gles2_read_pixels (void)
{
CoglTexture *offscreen_texture;
CoglOffscreen *offscreen;
CoglPipeline *pipeline;
CoglGLES2Context *gles2_ctx;
const CoglGLES2Vtable *gles2;
CoglError *error = NULL;
GLubyte pixel[3];
GLuint fbo_handle;
create_gles2_context (&offscreen_texture,
&offscreen,
&pipeline,
&gles2_ctx,
&gles2);
cogl_framebuffer_clear4f (test_fb, COGL_BUFFER_BIT_COLOR, 1, 1, 1, 1);
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx,
COGL_FRAMEBUFFER (offscreen),
COGL_FRAMEBUFFER (offscreen),
&error))
{
g_error ("Failed to push gles2 context: %s\n", error->message);
}
gles2->glClearColor (1, 0, 0, 1);
gles2->glClear (GL_COLOR_BUFFER_BIT);
gles2->glReadPixels (0, 0, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &pixel);
g_assert (pixel[0] == 0xff);
g_assert (pixel[1] == 0);
g_assert (pixel[2] == 0);
fbo_handle = create_gles2_framebuffer (gles2, 256, 256);
gles2->glBindFramebuffer (GL_FRAMEBUFFER, fbo_handle);
gles2->glClearColor (0, 1, 0, 1);
gles2->glClear (GL_COLOR_BUFFER_BIT);
gles2->glReadPixels (0, 0, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &pixel);
g_assert (pixel[0] == 0);
g_assert (pixel[1] == 0xff);
g_assert (pixel[2] == 0);
gles2->glBindFramebuffer (GL_FRAMEBUFFER, 0);
gles2->glClearColor (0, 1, 1, 1);
gles2->glClear (GL_COLOR_BUFFER_BIT);
gles2->glReadPixels (0, 0, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &pixel);
g_assert (pixel[0] == 0);
g_assert (pixel[1] == 0xff);
g_assert (pixel[2] == 0xff);
cogl_pop_gles2_context (test_ctx);
test_utils_check_pixel (test_fb, 0, 0, 0xffffffff);
/* Bind different read and write buffers */
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx,
COGL_FRAMEBUFFER (offscreen),
test_fb,
&error))
{
g_error ("Failed to push gles2 context: %s\n", error->message);
}
gles2->glReadPixels (0, 0, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &pixel);
g_assert (pixel[0] == 0);
g_assert (pixel[1] == 0xff);
g_assert (pixel[2] == 0xff);
cogl_pop_gles2_context (test_ctx);
test_utils_check_pixel (test_fb, 0, 0, 0xffffffff);
/* Bind different read and write buffers (the other way around from
* before so when we test with COGL_TEST_ONSCREEN=1 we will read
* from an onscreen framebuffer) */
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx,
test_fb,
COGL_FRAMEBUFFER (offscreen),
&error))
{
g_error ("Failed to push gles2 context: %s\n", error->message);
}
gles2->glReadPixels (0, 0, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &pixel);
g_assert (pixel[0] == 0xff);
g_assert (pixel[1] == 0xff);
g_assert (pixel[2] == 0xff);
cogl_pop_gles2_context (test_ctx);
}
void
test_gles2_context (void)
{
test_push_pop_single_context ();
test_push_pop_multi_context ();
test_gles2_read_pixels ();
if (cogl_test_verbose ())
g_print ("OK\n");
}
static GLuint
create_shader (const CoglGLES2Vtable *gles2,
GLenum type,
const char *source)
{
GLuint shader;
GLint status;
int length = strlen (source);
shader = gles2->glCreateShader (type);
gles2->glShaderSource (shader, 1, &source, &length);
gles2->glCompileShader (shader);
gles2->glGetShaderiv (shader, GL_COMPILE_STATUS, &status);
if (!status)
{
char buf[512];
gles2->glGetShaderInfoLog (shader, sizeof (buf), NULL, buf);
g_error ("Shader compilation failed:\n%s", buf);
}
return shader;
}
static GLuint
create_program (const CoglGLES2Vtable *gles2,
const char *vertex_shader_source,
const char *fragment_shader_source)
{
GLuint fragment_shader, vertex_shader, program;
GLint status;
vertex_shader =
create_shader (gles2, GL_VERTEX_SHADER, vertex_shader_source);
fragment_shader =
create_shader (gles2, GL_FRAGMENT_SHADER, fragment_shader_source);
program = gles2->glCreateProgram ();
gles2->glAttachShader (program, vertex_shader);
gles2->glAttachShader (program, fragment_shader);
gles2->glLinkProgram (program);
gles2->glGetProgramiv (program, GL_LINK_STATUS, &status);
if (!status)
{
char buf[512];
gles2->glGetProgramInfoLog (program, sizeof (buf), NULL, buf);
g_error ("Program linking failed:\n%s", buf);
}
return program;
}
typedef struct
{
const CoglGLES2Vtable *gles2;
GLint color_location;
GLint pos_location;
int fb_width, fb_height;
} PaintData;
typedef void (* PaintMethod) (PaintData *data);
/* Top vertices are counter-clockwise */
static const float top_vertices[] =
{
-1.0f, 0.0f,
1.0f, 0.0f,
-1.0f, 1.0f,
1.0f, 1.0f
};
/* Bottom vertices are clockwise */
static const float bottom_vertices[] =
{
1.0f, 0.0f,
1.0f, -1.0f,
-1.0f, 0.0f,
-1.0f, -1.0f
};
static void
paint_quads (PaintData *data)
{
const CoglGLES2Vtable *gles2 = data->gles2;
gles2->glEnableVertexAttribArray (data->pos_location);
/* Paint the top half in red */
gles2->glUniform4f (data->color_location,
1.0f, 0.0f, 0.0f, 1.0f);
gles2->glVertexAttribPointer (data->pos_location,
2, /* size */
GL_FLOAT,
GL_FALSE, /* not normalized */
sizeof (float) * 2,
top_vertices);
gles2->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
/* Paint the bottom half in blue */
gles2->glUniform4f (data->color_location,
0.0f, 0.0f, 1.0f, 1.0f);
gles2->glVertexAttribPointer (data->pos_location,
2, /* size */
GL_FLOAT,
GL_FALSE, /* not normalized */
sizeof (float) * 2,
bottom_vertices);
gles2->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
}
static void
paint_viewport (PaintData *data)
{
const CoglGLES2Vtable *gles2 = data->gles2;
int viewport[4];
/* Vertices to fill the entire framebuffer */
static const float vertices[] =
{
-1.0f, -1.0f,
1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, 1.0f
};
gles2->glEnableVertexAttribArray (data->pos_location);
gles2->glVertexAttribPointer (data->pos_location,
2, /* size */
GL_FLOAT,
GL_FALSE, /* not normalized */
sizeof (float) * 2,
vertices);
/* Paint the top half in red */
gles2->glViewport (0, data->fb_height / 2,
data->fb_width, data->fb_height / 2);
gles2->glUniform4f (data->color_location,
1.0f, 0.0f, 0.0f, 1.0f);
gles2->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
/* Paint the bottom half in blue */
gles2->glViewport (0, 0, data->fb_width, data->fb_height / 2);
gles2->glUniform4f (data->color_location,
0.0f, 0.0f, 1.0f, 1.0f);
gles2->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
gles2->glGetIntegerv (GL_VIEWPORT, viewport);
g_assert_cmpint (viewport[0], ==, 0.0f);
g_assert_cmpint (viewport[1], ==, 0.0f);
g_assert_cmpint (viewport[2], ==, data->fb_width);
g_assert_cmpint (viewport[3], ==, data->fb_height / 2);
}
static void
paint_scissor (PaintData *data)
{
const CoglGLES2Vtable *gles2 = data->gles2;
float scissor[4];
gles2->glEnable (GL_SCISSOR_TEST);
/* Paint the top half in red */
gles2->glScissor (0, data->fb_height / 2,
data->fb_width, data->fb_height / 2);
gles2->glClearColor (1.0, 0.0, 0.0, 1.0);
gles2->glClear (GL_COLOR_BUFFER_BIT);
/* Paint the bottom half in blue */
gles2->glScissor (0, 0, data->fb_width, data->fb_height / 2);
gles2->glClearColor (0.0, 0.0, 1.0, 1.0);
gles2->glClear (GL_COLOR_BUFFER_BIT);
gles2->glGetFloatv (GL_SCISSOR_BOX, scissor);
g_assert_cmpfloat (scissor[0], ==, 0.0f);
g_assert_cmpfloat (scissor[1], ==, 0.0f);
g_assert_cmpfloat (scissor[2], ==, data->fb_width);
g_assert_cmpfloat (scissor[3], ==, data->fb_height / 2);
}
static void
paint_cull (PaintData *data)
{
const CoglGLES2Vtable *gles2 = data->gles2;
GLint front_face;
int i;
gles2->glEnableVertexAttribArray (data->pos_location);
gles2->glEnable (GL_CULL_FACE);
/* First time round we'll use GL_CCW as the front face so that the
* bottom quad will be culled */
gles2->glFrontFace (GL_CCW);
gles2->glUniform4f (data->color_location,
1.0f, 0.0f, 0.0f, 1.0f);
gles2->glGetIntegerv (GL_FRONT_FACE, &front_face);
g_assert_cmpint (front_face, ==, GL_CCW);
for (i = 0; i < 2; i++)
{
/* Paint both quads in the same color. One of these will be
* culled */
gles2->glVertexAttribPointer (data->pos_location,
2, /* size */
GL_FLOAT,
GL_FALSE, /* not normalized */
sizeof (float) * 2,
top_vertices);
gles2->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
gles2->glVertexAttribPointer (data->pos_location,
2, /* size */
GL_FLOAT,
GL_FALSE, /* not normalized */
sizeof (float) * 2,
bottom_vertices);
gles2->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
/* Second time round we'll use GL_CW as the front face so that the
* top quad will be culled */
gles2->glFrontFace (GL_CW);
gles2->glUniform4f (data->color_location,
0.0f, 0.0f, 1.0f, 1.0f);
gles2->glGetIntegerv (GL_FRONT_FACE, &front_face);
g_assert_cmpint (front_face, ==, GL_CW);
}
}
static void
verify_read_pixels (const PaintData *data)
{
int stride = data->fb_width * 4;
uint8_t *buf = g_malloc (data->fb_height * stride);
data->gles2->glReadPixels (0, 0, /* x/y */
data->fb_width, data->fb_height,
GL_RGBA,
GL_UNSIGNED_BYTE,
buf);
/* In GL, the lines earlier in the buffer are the bottom */
/* Bottom should be blue */
test_utils_compare_pixel (buf + data->fb_width / 2 * 4 +
data->fb_height / 4 * stride,
0x0000ffff);
/* Top should be red */
test_utils_compare_pixel (buf + data->fb_width / 2 * 4 +
data->fb_height * 3 / 4 * stride,
0xff0000ff);
g_free (buf);
}
void
test_gles2_context_fbo (void)
{
static const char vertex_shader_source[] =
"attribute vec2 pos;\n"
"\n"
"void\n"
"main ()\n"
"{\n"
" gl_Position = vec4 (pos, 0.0, 1.0);\n"
"}\n";
static const char fragment_shader_source[] =
"precision mediump float;\n"
"uniform vec4 color;\n"
"\n"
"void\n"
"main ()\n"
"{\n"
" gl_FragColor = color;\n"
"}\n";
static const PaintMethod paint_methods[] =
{
paint_quads,
paint_viewport,
paint_scissor,
paint_cull
};
int i;
PaintData data;
data.fb_width = cogl_framebuffer_get_width (test_fb);
data.fb_height = cogl_framebuffer_get_height (test_fb);
for (i = 0; i < G_N_ELEMENTS (paint_methods); i++)
{
CoglTexture *offscreen_texture;
CoglOffscreen *offscreen;
CoglPipeline *pipeline;
CoglGLES2Context *gles2_ctx;
GLuint program;
CoglError *error = NULL;
create_gles2_context (&offscreen_texture,
&offscreen,
&pipeline,
&gles2_ctx,
&data.gles2);
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx,
COGL_FRAMEBUFFER (offscreen),
COGL_FRAMEBUFFER (offscreen),
&error))
g_error ("Failed to push gles2 context: %s\n", error->message);
program = create_program (data.gles2,
vertex_shader_source,
fragment_shader_source);
data.gles2->glClearColor (1.0, 1.0, 0.0, 1.0);
data.gles2->glClear (GL_COLOR_BUFFER_BIT);
data.gles2->glUseProgram (program);
data.color_location = data.gles2->glGetUniformLocation (program, "color");
if (data.color_location == -1)
g_error ("Couldn't find ‘color’ uniform");
data.pos_location = data.gles2->glGetAttribLocation (program, "pos");
if (data.pos_location == -1)
g_error ("Couldn't find ‘pos’ attribute");
paint_methods[i] (&data);
verify_read_pixels (&data);
cogl_pop_gles2_context (test_ctx);
cogl_object_unref (offscreen);
cogl_object_unref (gles2_ctx);
cogl_framebuffer_draw_rectangle (test_fb,
pipeline,
-1.0f, 1.0f,
1.0f, -1.0f);
cogl_object_unref (pipeline);
cogl_object_unref (offscreen_texture);
/* Top half of the framebuffer should be red */
test_utils_check_pixel (test_fb,
data.fb_width / 2, data.fb_height / 4,
0xff0000ff);
/* Bottom half should be blue */
test_utils_check_pixel (test_fb,
data.fb_width / 2, data.fb_height * 3 / 4,
0x0000ffff);
}
}
/* Position to draw a rectangle in. The top half of this rectangle
* will be red, and the bottom will be blue */
#define RECTANGLE_DRAW_X 10
#define RECTANGLE_DRAW_Y 15
/* Position to copy the rectangle to in the destination texture */
#define RECTANGLE_COPY_X 110
#define RECTANGLE_COPY_Y 115
#define RECTANGLE_WIDTH 30
#define RECTANGLE_HEIGHT 40
static void
verify_region (const CoglGLES2Vtable *gles2,
int x,
int y,
int width,
int height,
uint32_t expected_pixel)
{
uint8_t *buf, *p;
buf = g_malloc (width * height * 4);
gles2->glReadPixels (x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buf);
for (p = buf + width * height * 4; p > buf; p -= 4)
test_utils_compare_pixel (p - 4, expected_pixel);
g_free (buf);
}
void
test_gles2_context_copy_tex_image (void)
{
static const char vertex_shader_source[] =
"attribute vec2 pos;\n"
"attribute vec2 tex_coord_attrib;\n"
"varying vec2 tex_coord_varying;\n"
"\n"
"void\n"
"main ()\n"
"{\n"
" gl_Position = vec4 (pos, 0.0, 1.0);\n"
" tex_coord_varying = tex_coord_attrib;\n"
"}\n";
static const char fragment_shader_source[] =
"precision mediump float;\n"
"varying vec2 tex_coord_varying;\n"
"uniform sampler2D tex;\n"
"\n"
"void\n"
"main ()\n"
"{\n"
" gl_FragColor = texture2D (tex, tex_coord_varying);\n"
"}\n";
static const float verts[] =
{
-1.0f, -1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f
};
int fb_width = cogl_framebuffer_get_width (test_fb);
int fb_height = cogl_framebuffer_get_height (test_fb);
CoglTexture *offscreen_texture;
CoglOffscreen *offscreen;
CoglPipeline *pipeline;
CoglGLES2Context *gles2_ctx;
const CoglGLES2Vtable *gles2;
CoglError *error = NULL;
GLuint tex;
GLint tex_uniform_location;
GLint pos_location;
GLint tex_coord_location;
GLuint program;
create_gles2_context (&offscreen_texture,
&offscreen,
&pipeline,
&gles2_ctx,
&gles2);
if (!cogl_push_gles2_context (test_ctx,
gles2_ctx,
COGL_FRAMEBUFFER (offscreen),
COGL_FRAMEBUFFER (offscreen),
&error))
g_error ("Failed to push gles2 context: %s\n", error->message);
gles2->glClearColor (1.0, 1.0, 0.0, 1.0);
gles2->glClear (GL_COLOR_BUFFER_BIT);
/* Draw a rectangle using clear and the scissor so that we don't
* have to create a shader */
gles2->glEnable (GL_SCISSOR_TEST);
/* Top half red */
gles2->glScissor (RECTANGLE_DRAW_X,
RECTANGLE_DRAW_Y + RECTANGLE_HEIGHT / 2,
RECTANGLE_WIDTH,
RECTANGLE_HEIGHT / 2);
gles2->glClearColor (1.0, 0.0, 0.0, 1.0);
gles2->glClear (GL_COLOR_BUFFER_BIT);
/* Bottom half blue */
gles2->glScissor (RECTANGLE_DRAW_X,
RECTANGLE_DRAW_Y,
RECTANGLE_WIDTH,
RECTANGLE_HEIGHT / 2);
gles2->glClearColor (0.0, 0.0, 1.0, 1.0);
gles2->glClear (GL_COLOR_BUFFER_BIT);
/* Draw where the rectangle would be if the coordinates were flipped
* in white to make it obvious that that is the problem if the
* assertion fails */
gles2->glScissor (RECTANGLE_DRAW_X,
fb_width - (RECTANGLE_DRAW_Y + RECTANGLE_HEIGHT),
RECTANGLE_WIDTH,
RECTANGLE_HEIGHT);
gles2->glClearColor (1.0, 1.0, 1.0, 1.0);
gles2->glClear (GL_COLOR_BUFFER_BIT);
gles2->glDisable (GL_SCISSOR_TEST);
/* Create a texture */
gles2->glGenTextures (1, &tex);
gles2->glBindTexture (GL_TEXTURE_2D, tex);
gles2->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gles2->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
/* Copy the entire framebuffer into the texture */
gles2->glCopyTexImage2D (GL_TEXTURE_2D,
0, /* level */
GL_RGBA,
0, 0, /* x/y */
fb_width, fb_height,
0 /* border */);
/* Copy the rectangle into another part of the texture */
gles2->glCopyTexSubImage2D (GL_TEXTURE_2D,
0, /* level */
RECTANGLE_COPY_X,
RECTANGLE_COPY_Y,
RECTANGLE_DRAW_X,
RECTANGLE_DRAW_Y,
RECTANGLE_WIDTH,
RECTANGLE_HEIGHT);
/* Clear the framebuffer to make the test more thorough */
gles2->glClearColor (1.0, 1.0, 0.0, 1.0);
gles2->glClear (GL_COLOR_BUFFER_BIT);
/* Create a program to render the texture */
program = create_program (gles2,
vertex_shader_source,
fragment_shader_source);
pos_location =
gles2->glGetAttribLocation (program, "pos");
if (pos_location == -1)
g_error ("Couldn't find ‘pos’ attribute");
tex_coord_location =
gles2->glGetAttribLocation (program, "tex_coord_attrib");
if (tex_coord_location == -1)
g_error ("Couldn't find ‘tex_coord_attrib’ attribute");
tex_uniform_location =
gles2->glGetUniformLocation (program, "tex");
if (tex_uniform_location == -1)
g_error ("Couldn't find ‘tex’ uniform");
gles2->glUseProgram (program);
gles2->glUniform1i (tex_uniform_location, 0);
/* Render the texture to fill the framebuffer */
gles2->glEnableVertexAttribArray (pos_location);
gles2->glVertexAttribPointer (pos_location,
2, /* n_components */
GL_FLOAT,
FALSE, /* normalized */
sizeof (float) * 4,
verts);
gles2->glEnableVertexAttribArray (tex_coord_location);
gles2->glVertexAttribPointer (tex_coord_location,
2, /* n_components */
GL_FLOAT,
FALSE, /* normalized */
sizeof (float) * 4,
verts + 2);
gles2->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
/* Verify top of drawn rectangle is red */
verify_region (gles2,
RECTANGLE_DRAW_X,
RECTANGLE_DRAW_Y + RECTANGLE_HEIGHT / 2,
RECTANGLE_WIDTH,
RECTANGLE_HEIGHT / 2,
0xff0000ff);
/* Verify bottom of drawn rectangle is blue */
verify_region (gles2,
RECTANGLE_DRAW_X,
RECTANGLE_DRAW_Y,
RECTANGLE_WIDTH,
RECTANGLE_HEIGHT / 2,
0x0000ffff);
/* Verify top of copied rectangle is red */
verify_region (gles2,
RECTANGLE_COPY_X,
RECTANGLE_COPY_Y + RECTANGLE_HEIGHT / 2,
RECTANGLE_WIDTH,
RECTANGLE_HEIGHT / 2,
0xff0000ff);
/* Verify bottom of copied rectangle is blue */
verify_region (gles2,
RECTANGLE_COPY_X,
RECTANGLE_COPY_Y,
RECTANGLE_WIDTH,
RECTANGLE_HEIGHT / 2,
0x0000ffff);
cogl_pop_gles2_context (test_ctx);
cogl_object_unref (offscreen);
cogl_object_unref (gles2_ctx);
cogl_object_unref (pipeline);
cogl_object_unref (offscreen_texture);
}
Reference in New Issue View Git Blame Copy Permalink