enum piglit_result
piglit_display(void)
{
bool pass = true;
GLint w = pattern_width, h = pattern_height;
GLfloat *color_buffer = NULL;
test->draw_to_default_framebuffer();
/* Read color buffer */
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
color_buffer = (GLfloat *) malloc(w * h * 4 * sizeof(float));
glReadPixels(0, 0, w, h, GL_RGBA, GL_FLOAT, color_buffer);
/* Draw the test pattern in to test_fbo with num_samples = 0. This
* is to verify if glRenderbufferStorageMultisample() with zero sample
* count turns off MSAA.
*/
test->test_fbo.set_samples(0);
test->draw_test_image(&test->test_fbo);
/* Compare rendered scene with color_buffer */
glBindFramebuffer(GL_READ_FRAMEBUFFER, test->test_fbo.handle);
pass = piglit_probe_image_rgba(0, 0, w, h, color_buffer)
&& pass;
/* Switch ON MSAA in this FBO by passing num_samples > 0 */
test->test_fbo.set_samples(num_samples);
/* Draw test image in multisample FBO */
test->draw_test_image(&test->test_fbo);
/* Draw a reference image for MSAA */
test->draw_reference_image();
/* Measure the accuracy of MSAA in multisample FBO by comparing the
* test image to reference image. This varifies if MSAA is actually
* switched on.
*/
pass = test->measure_accuracy() && pass;
/* Switch OFF MSAA again in this FBO */
test->test_fbo.set_samples(0);
test->draw_test_image(&test->test_fbo);
/* Compare rendered scene with color_buffer */
glBindFramebuffer(GL_READ_FRAMEBUFFER, test->test_fbo.handle);
pass = piglit_probe_image_rgba(0, 0, w, h, color_buffer)
&& pass;
if (!piglit_automatic)
piglit_present_results();
return (pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
enum piglit_result piglit_display(void)
{
GLboolean pass = GL_TRUE;
int i;
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16, 0, GL_RGBA, GL_FLOAT, tex_data);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
glViewport(0, 0, 16, 16);
glUseProgram(prog);
glUniform1i(texloc, 0);
for (i = 0; i < PASSES; i++) {
if (i != 0)
glTextureBarrierNV();
piglit_draw_rect_tex(-1, -1, 2, 2, 0, 0, 1, 1);
}
pass = piglit_probe_image_rgba(0, 0, 16, 16, res_data);
glUseProgram(0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glViewport(0, 0, piglit_width, piglit_height);
piglit_draw_rect_tex(-1, -1, 2, 2, 0, 0, 1, 1);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static bool
analyze_image(GLuint fbo)
{
GLfloat *expected_data = malloc(PATTERN_WIDTH * PATTERN_HEIGHT * 4 *
sizeof(GLfloat));
unsigned x, y, component;
bool pass;
for (y = 0; y < PATTERN_HEIGHT; ++y) {
for (x = 0; x < PATTERN_WIDTH; ++x) {
for (component = 0; component < 4; ++component) {
float val = x / 255.0;
if (component < 3 && enable_srgb_framebuffer) {
if (src_format == GL_SRGB8_ALPHA8)
val = srgb_to_linear(val);
if (dst_format == GL_SRGB8_ALPHA8)
val = linear_to_srgb(val);
}
expected_data[(y * PATTERN_WIDTH + x)
* 4 + component] = val;
}
}
}
glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
pass = piglit_probe_image_rgba(0, 0, PATTERN_WIDTH, PATTERN_HEIGHT,
expected_data);
free(expected_data);
return pass;
}
enum piglit_result
piglit_display(void)
{
int x, y;
bool pass = true;
float expected[64 * 64 * 4];
glClearColor(0.0, 1.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
for (x = 0; x < 8; x++) {
for (y = 0; y < 8; y++) {
piglit_Uniform2i(coord1_location, x * 9, y * 9);
piglit_Uniform2i(coord2_location, x * 9, y * 9);
piglit_draw_rect(-1.0 + 0.25 * x,
-1.0 + 0.25 * y,
0.25,
0.25);
}
}
for (x = 0; x < 64; x++) {
for (y = 0; y < 64; y++) {
int sx = x % 8;
int sy = y % 8;
int dx = fabs(sx - x / 8);
int dy = fabs(sy - y / 8);
float pixel[4];
if (dx == 0 && dy == 0) {
pixel[0] = 0.0;
pixel[1] = 1.0;
pixel[2] = 0.0;
pixel[3] = 0.0;
} else {
int i;
pixel[0] = 0.0;
pixel[1] = 0.0;
pixel[2] = 0.0;
pixel[3] = 0.0;
for (i = 0; i < 10; i += (dx + dy))
pixel[2] += 0.1;
}
memcpy(expected + (y * 64 + x) * 4, pixel, 4 * 4);
}
}
pass = piglit_probe_image_rgba(0, 0, 64, 64, expected);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
float red[4] = {1.0, 0.0, 0.0, 0.0};
float green[4] = {0.0, 1.0, 0.0, 0.25};
float blue[4] = {0.0, 0.0, 1.0, 0.5};
float white[4] = {1.0, 1.0, 1.0, 1.0};
float grey[4] = {0.5, 0.5, 0.5, 0.5};
bool pass;
float *ref_image;
/* Draw the source image to src_fbo */
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, src_fbo);
glEnable(GL_SCISSOR_TEST);
glScissor(0, 0, width / 2, height / 2);
glClearColor(red[0], red[1], red[2], red[3]);
glClear(GL_COLOR_BUFFER_BIT);
glScissor(width / 2, 0, width / 2, height / 2);
glClearColor(green[0], green[1], green[2], green[3]);
glClear(GL_COLOR_BUFFER_BIT);
glScissor(0, height / 2, width / 2, height / 2);
glClearColor(blue[0], blue[1], blue[2], blue[3]);
glClear(GL_COLOR_BUFFER_BIT);
glScissor(width / 2, height / 2, width / 2, height / 2);
glClearColor(white[0], white[1], white[2], white[3]);
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glClearColor(grey[0], grey[1], grey[2], grey[3]);
/* Blit to dst_fbo, scissoring the image in an asymmetrical way. */
glBindFramebuffer(GL_READ_FRAMEBUFFER, src_fbo);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dst_fbo);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_SCISSOR_TEST);
glScissor(10, 20, width - 40, height - 60);
glBlitFramebuffer(0, 0, width, height,
0, 0, width, height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glDisable(GL_SCISSOR_TEST);
/* Blit to ref_fbo, simulating the correct scissoring effect
* by manually adjusting the coordinates.
*/
glBindFramebuffer(GL_READ_FRAMEBUFFER, src_fbo);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, ref_fbo);
glClear(GL_COLOR_BUFFER_BIT);
glBlitFramebuffer(10, 20, width - 30, height - 40,
10, 20, width - 30, height - 40,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
/* Read the reference image from ref_fbo */
ref_image = malloc(sizeof(float) * 4 * width * height);
glBindFramebuffer(GL_READ_FRAMEBUFFER, ref_fbo);
glReadPixels(0, 0, width, height, GL_RGBA, GL_FLOAT, ref_image);
/* Compare the image in dst_fbo with the reference image */
glBindFramebuffer(GL_READ_FRAMEBUFFER, dst_fbo);
pass = piglit_probe_image_rgba(0, 0, width, height, ref_image);
if (dst_fbo != 0) {
/* Show the contents of dst_fbo in the window */
glBindFramebuffer(GL_READ_FRAMEBUFFER, dst_fbo);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glBlitFramebuffer(0, 0, width, height,
0, 0, width, height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
GLuint r8_tex, gr88_tex;
float *ref_rgba_image;
GLuint va; /* vertex array */
GLuint vb; /* vertex buffer */
GLuint prog;
static const float vb_data[] = {
-1, -1,
1, -1,
1, 1,
-1, 1,
};
if (piglit_width != WINDOW_WIDTH ||
piglit_height != WINDOW_HEIGHT) {
piglit_loge("window is not %dx%d",
WINDOW_WIDTH, WINDOW_HEIGHT);
return PIGLIT_FAIL;
}
create_textures(&r8_tex, &gr88_tex, &ref_rgba_image);
prog = piglit_build_simple_program(
"#version 300 es\n"
"\n"
"in vec2 a_position;\n"
"out vec2 v_texcoord;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = vec4(a_position, 0, 1);\n"
"\n"
" v_texcoord = a_position;\n"
" v_texcoord += vec2(1, 1);\n"
" v_texcoord /= vec2(2, 2);\n"
"}\n",
"#version 300 es\n"
"\n"
"precision highp float;\n"
"uniform sampler2D u_r8_tex;\n"
"uniform sampler2D u_gr88_tex;\n"
"in vec2 v_texcoord;\n"
"out vec4 f_color;\n"
"\n"
"void main()\n"
"{\n"
" float y = texture(u_r8_tex, v_texcoord).r;\n"
" vec2 uv = texture(u_gr88_tex, v_texcoord).rg;\n"
"\n"
" /* A very fake NV12->RGB conversion */\n"
" f_color = vec4(y, uv.r, uv.g, 1);\n"
"}\n");
glUseProgram(prog);
glUniform1i(glGetUniformLocation(prog, "u_r8_tex"), 0);
glUniform1i(glGetUniformLocation(prog, "u_gr88_tex"), 1);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
glGenBuffers(1, &vb);
glBindBuffer(GL_ARRAY_BUFFER, vb);
glBufferData(GL_ARRAY_BUFFER, sizeof(vb_data), vb_data,
GL_STATIC_DRAW);
glGenVertexArrays(1, &va);
glBindVertexArray(va);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void *) 0);
glEnableVertexAttribArray(0);
glViewport(0, 0, piglit_width, piglit_height);
glClearColor(0.2, 0.2, 0.2, 0.2);
glClear(GL_COLOR_BUFFER_BIT);
glDrawArrays(GL_TRIANGLE_FAN, /*first*/ 0, /*count*/ 4);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
/* Increase the tolerance because the conversion path
* ubyte --(texturing)--> float --(glReadPixels)--> ubyte
* is lossy.
*/
piglit_tolerance[0] = 0.05;
piglit_tolerance[1] = 0.05;
piglit_tolerance[2] = 0.05;
if (!piglit_probe_image_rgba(0, 0, piglit_width, piglit_height,
ref_rgba_image)) {
return PIGLIT_FAIL;
}
return PIGLIT_PASS;
}
/* Test for one set of factor levels */
bool
run_factor_set(GLenum src_factor_rgb, GLenum src_factor_a,
GLenum dst_factor_rgb, GLenum dst_factor_a,
GLenum op_rgb, GLenum op_a,
const GLfloat constant_color[4])
{
int i, j;
bool pass = true;
glDisable(GL_DITHER);
glClear(GL_COLOR_BUFFER_BIT);
/* Send dst image to the framebuffer. */
glDisable(GL_BLEND);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, dst_img.name);
piglit_draw_rect_tex(0, 0, img_width, img_height, 0, 0, 1, 1);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/*
* Read back the contents of the framebuffer, and measure any
* difference from what was actually written. We can't tell
* whether errors occurred when writing or when reading back,
* but at least we can report anything unusual.
*/
pass &= piglit_probe_image_rgba(0, 0, img_width,
img_height, dst_img.data);
/*
* Now apply the blending
* operation to both the framebuffer and a copy in the image
* ``expected''. Note that a fresh source alpha must be
* generated here, because the range of source alpha values is
* not limited by the range of alpha values that can be
* represented in the framebuffer. Save the source pixels in
* the image ``src'' so we can diagnose any problems we find
* later.
*/
/* Configure the appropriate blending settings */
if (have_sep_func)
glBlendFuncSeparate(src_factor_rgb, dst_factor_rgb,
src_factor_a, dst_factor_a);
else
glBlendFunc(src_factor_rgb, dst_factor_rgb);
if (have_blend_equation_sep)
glBlendEquationSeparate(op_rgb, op_a);
else if (have_blend_equation)
glBlendEquation(op_rgb);
/* Send src to the framebuffer and let GL blend it with dst */
glEnable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, src_img.name);
piglit_draw_rect_tex(0, 0, img_width, img_height, 0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* Compute the appropriate expected. */
for (j = 0; j < img_height; ++j) {
for (i = 0; i < img_width; ++i) {
int idx = 4*(img_width*j + i);
/* Initialize expected with dst data. */
exp_img.data[idx + 0] = dst_img.data[idx + 0];
exp_img.data[idx + 1] = dst_img.data[idx + 1];
exp_img.data[idx + 2] = dst_img.data[idx + 2];
exp_img.data[idx + 3] = dst_img.data[idx + 3];
/* Apply the blending. */
apply_blend(src_factor_rgb, src_factor_a,
dst_factor_rgb, dst_factor_a,
op_rgb, op_a,
&exp_img.data[idx], &src_img.data[idx],
constant_color);
}
}
/*
* Compare the image in the framebuffer to the
* computed image (``expected'') to see if any pixels are
* outside the expected tolerance range.
*/
pass &= piglit_probe_image_rgba(0, 0, img_width, img_height,
exp_img.data);
return pass;
} /* run_factor_set */
