void
piglit_init(int argc, char **argv)
{
int rgb_tol = 0;
int alpha_tol = 0;
const char* blend_rgb_tol = getenv("PIGLIT_BLEND_RGB_TOLERANCE");
const char* blend_alpha_tol = getenv("PIGLIT_BLEND_ALPHA_TOLERANCE");
/*
* Hack: Make driver tests on incorrect hardware feasible
* We want to be able to perform meaningful tests
* even when the blend unit of a GPU simply doesn't have
* sufficient precision.
*/
if (blend_rgb_tol)
{
rgb_tol = atoi(blend_rgb_tol);
printf("Note: RGB tolerance changed to %i %s.\n", rgb_tol,
rgb_tol == 1 ? "bit" : "bits");
}
if (blend_alpha_tol)
{
alpha_tol = atoi(blend_alpha_tol);
printf("Note: Alpha tolerance changed to %i %s.\n", alpha_tol,
alpha_tol == 1 ? "bit" : "bits");
}
/* A 0 passed in yields the default tolerance of 3.0/(1 << 8) ~= 0.01. */
piglit_set_tolerance_for_bits(rgb_tol, rgb_tol, rgb_tol, alpha_tol);
/* Initialize random images. */
srand(0);
/* Fill src and dst with randomness. */
dst_img.data = random_image_data();
src_img.data = random_image_data();
/* Fill exp_img with constant_color. */
/*
* You can use this as a check to make sure the test is working
* properly.
*/
exp_img.data = color_fill_data(constant_color[0],
constant_color[1],
constant_color[2],
constant_color[3]);
image_init(&dst_img);
image_init(&src_img);
image_init(&exp_img);
} /* piglit_init */
void piglit_init(int argc, char **argv)
{
glDisable(GL_DITHER);
/* Set the tolerance a little looser since we're using GL_NEAREST
* texture sampling. GL_NEAREST is fastest for software rendering.
* We probably wouldn't have to loosen the tolerance if we used
* GL_LINEAR filtering.
*/
piglit_set_tolerance_for_bits(7, 7, 7, 7);
printf("Probe tolerance: %f, %f, %f, %f\n",
piglit_tolerance[0],
piglit_tolerance[1],
piglit_tolerance[2],
piglit_tolerance[3]);
}
void piglit_init(int argc, char **argv)
{
int i;
piglit_require_extension("GL_ARB_framebuffer_object");
piglit_require_extension("GL_ARB_texture_storage");
piglit_require_GLSL_version(120);
format = GL_RGBA8;
target = GL_TEXTURE_CUBE_MAP;
num_layers = 6;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "array") == 0) {
piglit_require_GLSL_version(130);
piglit_require_extension("GL_ARB_texture_cube_map_array");
test_array = GL_TRUE;
target = GL_TEXTURE_CUBE_MAP_ARRAY;
num_layers = 6 * 5;
}
else if (strcmp(argv[i], "RGB9_E5") == 0) {
/* Test a non-renderable format. */
piglit_require_extension("GL_EXT_texture_shared_exponent");
format = GL_RGB9_E5;
}
else if (strcmp(argv[i], "S3TC_DXT1") == 0) {
/* Test a compressed format. */
piglit_require_extension("GL_EXT_texture_compression_s3tc");
format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
piglit_set_tolerance_for_bits(5, 6, 5, 8);
}
else {
assert(0);
}
}
prog = piglit_build_simple_program(NULL, test_array ? fs_cube_array :
fs_cube);
glClearColor(0.25, 0.25, 0.25, 0.25);
}
static enum piglit_result test_format(const struct format_desc *format)
{
GLboolean pass = GL_TRUE;
GLuint tex, fb;
GLenum status;
int r, g, b, l, a, i;
float res0[] = {0.3, 0.3, 0.3, 0.0};
float pos1[] = {-0.66, -1.0, 0.33, 2.0};
float src1[] = {0.4, 0.9, 0.8, fix_alpha(0.7)};
float dst1[] = {0.5, 0.4, 0.6, fix_alpha(0.2)};
float con1[] = {0.2, 0.8, 0.4, fix_alpha(0.6)};
float res1[] = {dst1[0]*(1-con1[0]) + src1[0]*con1[0],
dst1[1]*(1-con1[1]) + src1[1]*con1[1],
dst1[2]*(1-con1[2]) + src1[2]*con1[2],
dst1[3]*(1-con1[3]) + src1[3]*con1[3]};
float pos2[] = {-0.33, -1.0, 0.33, 2.0};
float dst2[] = {0.9, 0.4, 0.7, fix_alpha(0.5)};
float src2[] = {0.8, 0.3, 0.5, fix_alpha(0.9)};
float res2[] = {dst2[0]*(1-dst2[0]) + src2[0]*dst2[0],
dst2[1]*(1-dst2[1]) + src2[1]*dst2[1],
dst2[2]*(1-dst2[2]) + src2[2]*dst2[2],
dst2[3]*(1-dst2[3]) + src2[3]*dst2[3]};
float pos3[] = {0.0, -1.0, 0.33, 2.0};
float dst3[] = {0.6, 0.4, 0.8, fix_alpha(0.5)};
float src3[] = {0.8, 0.9, 0.7, fix_alpha(0.8)};
float res3[] = {dst3[0]*(1-src3[0]) + src3[0]*src3[0],
dst3[1]*(1-src3[1]) + src3[1]*src3[1],
dst3[2]*(1-src3[2]) + src3[2]*src3[2],
dst3[3]*(1-src3[3]) + src3[3]*src3[3]};
float pos4[] = {0.33, -1.0, 0.33, 2.0};
float dst4[] = {0.9, 0.4, 0.7, fix_alpha(0.5)};
float src4[] = {0.8, 0.3, 0.5, fix_alpha(0.9)};
float res4[] = {dst4[0]*(1-dst4[3]) + src4[0]*dst4[3],
dst4[1]*(1-dst4[3]) + src4[1]*dst4[3],
dst4[2]*(1-dst4[3]) + src4[2]*dst4[3],
dst4[3]*(1-dst4[3]) + src4[3]*dst4[3]};
float res4i = dst4[0]*(1-dst4[0]) + src4[0]*dst4[0]; /* intensity */
float res4l = src4[0]; /* luminance without alpha */
float pos5[] = {0.66, -1.0, 0.33, 2.0};
float dst5[] = {0.6, 0.4, 0.8, fix_alpha(0.5)};
float src5[] = {0.8, 0.9, 0.7, fix_alpha(0.8)};
float res5[] = {dst5[0]*(1-src5[3]) + src5[0]*src5[3],
dst5[1]*(1-src5[3]) + src5[1]*src5[3],
dst5[2]*(1-src5[3]) + src5[2]*src5[3],
dst5[3]*(1-src5[3]) + src5[3]*src5[3]};
if (format->base_internal_format == GL_DEPTH_COMPONENT ||
format->base_internal_format == GL_DEPTH_STENCIL)
return PIGLIT_SKIP;
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glViewport(0, 0, piglit_width, piglit_height);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, format->internalformat,
piglit_width, piglit_height, 0,
GL_RGBA, GL_FLOAT, NULL);
l = get_texture_bits(GL_TEXTURE_2D,
GL_TEXTURE_LUMINANCE_SIZE,
GL_TEXTURE_LUMINANCE_TYPE);
a = get_texture_bits(GL_TEXTURE_2D,
GL_TEXTURE_ALPHA_SIZE,
GL_TEXTURE_ALPHA_TYPE);
i = get_texture_bits(GL_TEXTURE_2D,
GL_TEXTURE_INTENSITY_SIZE,
GL_TEXTURE_INTENSITY_TYPE);
r = get_texture_bits(GL_TEXTURE_2D,
GL_TEXTURE_RED_SIZE,
GL_TEXTURE_RED_TYPE);
g = get_texture_bits(GL_TEXTURE_2D,
GL_TEXTURE_GREEN_SIZE,
GL_TEXTURE_GREEN_TYPE);
b = get_texture_bits(GL_TEXTURE_2D,
GL_TEXTURE_BLUE_SIZE,
GL_TEXTURE_BLUE_TYPE);
/* Compute expected result colors when reading back from a texture/FBO */
if (i) {
/* expected result = (I, 0, 0, 1) */
res0[1] = res0[2] = 0.0; res0[3] = 1.0;
res1[1] = res1[2] = 0.0; res1[3] = 1.0;
res2[1] = res2[2] = 0.0; res2[3] = 1.0;
res3[1] = res3[2] = 0.0; res3[3] = 1.0;
res4[1] = res4[2] = 0.0; res4[3] = 1.0; res4[0] = res4i;
res5[1] = res5[2] = 0.0; res5[3] = 1.0;
} else if (l) {
/* expected result = (L, 0, 0, A) */
res0[1] = res0[2] = 0.0;
res1[1] = res1[2] = 0.0;
res2[1] = res2[2] = 0.0;
res3[1] = res3[2] = 0.0;
res4[1] = res4[2] = 0.0;
res5[1] = res5[2] = 0.0;
if (!a) {
res0[3] = 1;
res1[3] = 1;
res2[3] = 1;
res3[3] = 1;
res4[3] = 1; res4[0] = res4l;
res5[3] = 1;
}
} else {
if (!r) {
res0[0] = 0;
res1[0] = 0;
res2[0] = 0;
res3[0] = 0;
res4[0] = 0;
res5[0] = 0;
}
if (!g) {
res0[1] = 0;
res1[1] = 0;
res2[1] = 0;
res3[1] = 0;
res4[1] = 0;
res5[1] = 0;
}
if (!b) {
res0[2] = 0;
res1[2] = 0;
res2[2] = 0;
res3[2] = 0;
res4[2] = 0;
res5[2] = 0;
}
if (!a) {
/* When there are no bits for the alpha channel, we
* always expect to read an alpha value of 1.0.
*/
res0[3] = 1;
res1[3] = 1;
res2[3] = 1;
res3[3] = 1;
res4[3] = 1;
res5[3] = 1;
/* Also blending with
* DST_ALPHA/ONE_MINUS_DST_ALPHA (as in case
* 4) with an implicit destination alpha value
* of 1.0 means that the result color should
* be identical to the source color, (if there
* are any bits to store that color that is).
*/
if (r) {
res4[0] = src4[0];
}
if (g) {
res4[1] = src4[1];
}
if (b) {
res4[2] = src4[2];
}
}
}
/* Clamp the bits for the framebuffer, except we aren't checking
* the actual framebuffer bits.
*/
if (l > 8)
l = 8;
if (i > 8)
i = 8;
if (r > 8)
r = 8;
if (g > 8)
g = 8;
if (b > 8)
b = 8;
if (a > 8)
a = 8;
if (format->internalformat == GL_R11F_G11F_B10F) {
r = 6; /* precision of mantissa */
g = 6;
b = 5;
}
if (i) {
piglit_set_tolerance_for_bits(i, i, i, i);
} else if (l) {
piglit_set_tolerance_for_bits(l, l, l, a);
} else {
piglit_set_tolerance_for_bits(r, g, b, a);
}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
printf("Testing %s", format->name);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf(" - fbo incomplete (status = %s)\n",
piglit_get_gl_enum_name(status));
piglit_report_subtest_result(PIGLIT_SKIP, "%s", format->name);
return PIGLIT_SKIP;
}
printf("\n");
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor4fv(res0);
piglit_draw_rect(-1.0, -1.0, 0.33, 2.0);
blend(pos1, src1, dst1, con1, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR);
blend(pos2, src2, dst2, NULL, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR);
blend(pos3, src3, dst3, NULL, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
blend(pos4, src4, dst4, NULL, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
blend(pos5, src5, dst5, NULL, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (!piglit_probe_pixel_rgba(piglit_width * 1 / 12, 0, res0)) {
printf(" when testing FBO result, simple.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 3 / 12, 0, res1)) {
printf(" when testing FBO result, blending with CONSTANT_COLOR.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 5 / 12, 0, res2)) {
printf(" when testing FBO result, blending with DST_COLOR.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 7 / 12, 0, res3)) {
printf(" when testing FBO result, blending with SRC_COLOR.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 9 / 12, 0, res4)) {
printf(" when testing FBO result, blending with DST_ALPHA.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 11 / 12, 0, res5)) {
printf(" when testing FBO result, blending with SRC_ALPHA.\n");
pass = GL_FALSE;
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glViewport(0, 0, piglit_width, piglit_height);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glColor4f(1, 1, 1, 1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, tex);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &tex);
glBindFramebufferEXT(GL_FRAMEBUFFER, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
if (!pass) {
piglit_present_results();
piglit_report_subtest_result(PIGLIT_FAIL, "%s", format->name);
return PIGLIT_FAIL;
}
/* Compute expected result colors when reading back from the window */
if (i) {
/* expected result = (I, I, I, I) */
res0[3] = res0[2] = res0[1] = res0[0];
res1[3] = res1[2] = res1[1] = res1[0];
res2[3] = res2[2] = res2[1] = res2[0];
res3[3] = res3[2] = res3[1] = res3[0];
res4[3] = res4[2] = res4[1] = res4[0] = res4i;
res5[3] = res5[2] = res5[1] = res5[0];
} else if (l) {
/* expected result = (L, L, L, A) */
res0[2] = res0[1] = res0[0];
res1[2] = res1[1] = res1[0];
res2[2] = res2[1] = res2[0];
res3[2] = res3[1] = res3[0];
res4[2] = res4[1] = res4[0];
res5[2] = res5[1] = res5[0];
} else {
/* leave 'res' colors as-is from above */
}
if (!piglit_probe_pixel_rgba(piglit_width * 1 / 12, 0, res0)) {
printf(" when testing window result, simple.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 3 / 12, 0, res1)) {
printf(" when testing window result, blending with CONSTANT_COLOR.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 5 / 12, 0, res2)) {
printf(" when testing window result, blending DST_COLOR.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 7 / 12, 0, res3)) {
printf(" when testing window result, blending SRC_COLOR.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 9 / 12, 0, res4)) {
printf(" when testing window result, blending DST_ALPHA.\n");
pass = GL_FALSE;
}
if (!piglit_probe_pixel_rgba(piglit_width * 11 / 12, 0, res5)) {
printf(" when testing window result, blending SRC_ALPHA.\n");
pass = GL_FALSE;
}
piglit_present_results();
piglit_report_subtest_result(pass ? PIGLIT_PASS : PIGLIT_FAIL,
"%s", format->name);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
/**
* Test a specific texture target and format combination.
*/
static GLboolean
test_target_and_format(GLint x, GLint y, GLenum target, GLenum format,
const GLfloat *expected)
{
GLboolean pass = GL_TRUE;
GLuint k;
GLuint prog = 0;
printf("Texture target = %s, Internal format = %s",
piglit_get_gl_enum_name(target),
piglit_get_gl_enum_name(format));
if (!supported_format(format) ||
!supported_target_format(target, format)) {
printf(" - skipped\n");
return GL_TRUE; /* not a failure */
} else {
printf("\n");
}
/* To avoid failures not related to this test case,
* loosen up the tolerence for compressed texture
* formats
*/
if (is_compressed_format(format))
piglit_set_tolerance_for_bits(5, 5, 5, 5);
else
piglit_set_tolerance_for_bits(8, 8, 8, 8);
switch(target) {
case GL_TEXTURE_1D:
draw(format, 1.0);
glCopyTexImage1D(GL_TEXTURE_1D, 0,
format,
0, 0, IMAGE_SIZE, 0);
pass = piglit_check_gl_error(GL_NO_ERROR)
&& pass;
glEnable(target);
piglit_draw_rect_tex(x, y, IMAGE_SIZE, IMAGE_SIZE,
0, 0, 1, 1);
pass = piglit_probe_rect_rgba(x, y, IMAGE_SIZE,
IMAGE_SIZE,
expected)
&& pass;
break;
case GL_TEXTURE_2D:
draw(format, 1.0);
glCopyTexImage2D(GL_TEXTURE_2D, 0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glEnable(target);
piglit_draw_rect_tex(x, y, IMAGE_SIZE, IMAGE_SIZE,
0, 0, 1, 1);
pass = piglit_probe_rect_rgba(x, y, IMAGE_SIZE,
IMAGE_SIZE,
expected)
&& pass;
break;
case GL_TEXTURE_3D:
glTexImage3D(GL_TEXTURE_3D, 0, format, IMAGE_SIZE, IMAGE_SIZE, 4,
0, GL_RGBA, get_type(format), NULL);
for (k = 0; k < 4; k++) {
draw(format, 1.0 - k*0.2);
glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, k,
0, 0, IMAGE_SIZE, IMAGE_SIZE);
}
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glEnable(target);
for (k = 0; k < 4; k++) {
const float tz = k * 0.25;
draw_rect_tex_3d(x, y, IMAGE_SIZE, IMAGE_SIZE,
0, 0, tz, 1, 1);
pass = probe_rect(x, y, IMAGE_SIZE, IMAGE_SIZE,
expected, 1.0 - k*0.2) && pass;
}
break;
case GL_TEXTURE_CUBE_MAP:
for (k = 0; k < 6; k++) {
draw(format, 1.0 - k*0.15);
glCopyTexImage2D(cube_face_targets[k],
0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
}
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glEnable(target);
for (k = 0; k < 6; k++) {
draw_rect_tex_cube_face(x, y, IMAGE_SIZE, IMAGE_SIZE, k);
pass = probe_rect(x, y, IMAGE_SIZE, IMAGE_SIZE,
expected, 1.0 - k*0.15) && pass;
}
break;
case GL_TEXTURE_1D_ARRAY:
glTexImage2D(GL_TEXTURE_1D_ARRAY, 0, format, IMAGE_SIZE, 16,
0, get_format(format), get_type(format), NULL);
for (k = 0; k < 4; k++) {
draw(format, 1.0 - 0.2*k);
glCopyTexSubImage2D(GL_TEXTURE_1D_ARRAY, 0, 0, 4*k,
0, 0, IMAGE_SIZE, 4);
}
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
prog = piglit_build_simple_program(NULL, array1D_shader_text);
glUseProgram(prog);
glDeleteProgram(prog);
for (k = 0; k < 16; k++) {
piglit_draw_rect_tex(x, y, IMAGE_SIZE, IMAGE_SIZE,
0, k, 1, 0);
pass = probe_rect(x, y, IMAGE_SIZE, IMAGE_SIZE,
expected, 1.0 - 0.2*(k/4)) && pass;
}
break;
case GL_TEXTURE_2D_ARRAY:
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, format, IMAGE_SIZE, IMAGE_SIZE, 4,
0, get_format(format), get_type(format), NULL);
for (k = 0; k < 4; k++) {
draw(format, 1.0 - k*0.2);
glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, k,
0, 0, IMAGE_SIZE, IMAGE_SIZE);
}
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
prog = piglit_build_simple_program(NULL, array2D_shader_text);
glUseProgram(prog);
glDeleteProgram(prog);
for (k = 0; k < 4; k++) {
draw_rect_tex_3d(x, y, IMAGE_SIZE, IMAGE_SIZE,
0, 0, k, 1, 1);
pass = probe_rect(x, y, IMAGE_SIZE, IMAGE_SIZE,
expected, 1.0 - k*0.2) && pass;
}
break;
case GL_TEXTURE_RECTANGLE:
draw(format, 1.0);
glCopyTexImage2D(GL_TEXTURE_RECTANGLE, 0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glEnable(target);
piglit_draw_rect_tex(x, y, IMAGE_SIZE, IMAGE_SIZE,
0, 0, IMAGE_SIZE - 1, IMAGE_SIZE - 1);
pass = piglit_probe_rect_rgba(x, y, IMAGE_SIZE,
IMAGE_SIZE,
expected)
&& pass;
break;
}
/* If a GLSL program is in use, then the preceeding code should not
* have called glEnable(target). In that case, this code should not
* disable it. For some targets, like GL_TEXTURE_1D_ARRAY,
* glDisable(target) will generate an error.
*/
if (prog == 0)
glDisable(target);
else
glUseProgram(0);
return pass;
}
static GLboolean
test_mipmap_drawing(int x, int y, int dim, int level, GLuint internalformat)
{
GLboolean pass = GL_TRUE;
int half = dim / 2;
int x1 = x, y1 = y, x2 = x + half, y2 = y + half;
float r[] = {1, 0, 0, 0};
float g[] = {0, 1, 0, 0.25};
float b[] = {0, 0, 1, 0.5};
float w[] = {1, 1, 1, 1};
GLint r_size, g_size, b_size, l_size, a_size, d_size, i_size;
GLint compressed;
glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
GL_TEXTURE_COMPRESSED, &compressed);
if (compressed && dim < 8)
return GL_TRUE;
if (piglit_is_extension_supported("GL_ARB_depth_texture")) {
glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
GL_TEXTURE_DEPTH_SIZE, &d_size);
} else {
d_size = 0;
}
glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
GL_TEXTURE_LUMINANCE_SIZE, &l_size);
glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
GL_TEXTURE_ALPHA_SIZE, &a_size);
glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
GL_TEXTURE_INTENSITY_SIZE, &i_size);
glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
GL_TEXTURE_RED_SIZE, &r_size);
glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
GL_TEXTURE_GREEN_SIZE, &g_size);
glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
GL_TEXTURE_BLUE_SIZE, &b_size);
if (d_size) {
for (x1 = x; x1 < x + dim; x1++) {
float val = (x1 - x + 0.5) / (dim);
float color[3] = {val, val, val};
pass = pass && piglit_probe_rect_rgb(x1, y, 1, dim,
color);
}
return pass;
}
if (i_size || l_size) {
r[0] = 1.0;
r[1] = 1.0;
r[2] = 1.0;
g[0] = 0.0;
g[1] = 0.0;
g[2] = 0.0;
b[0] = 0.0;
b[1] = 0.0;
b[2] = 0.0;
if (i_size) {
r[3] = 1.0;
g[3] = 0.0;
b[3] = 0.0;
} else if (l_size && !a_size) {
r[3] = 1.0;
g[3] = 1.0;
b[3] = 1.0;
w[3] = 1.0;
}
} else if (a_size && !r_size && !l_size) {
r[0] = 1.0;
r[1] = 1.0;
r[2] = 1.0;
g[0] = 1.0;
g[1] = 1.0;
g[2] = 1.0;
b[0] = 1.0;
b[1] = 1.0;
b[2] = 1.0;
} else {
if (!r_size) {
r[0] = 0.0;
w[0] = 0.0;
}
if (!g_size) {
g[1] = 0.0;
w[1] = 0.0;
}
if (!b_size) {
b[2] = 0.0;
w[2] = 0.0;
}
if (!a_size) {
r[3] = 1.0;
g[3] = 1.0;
b[3] = 1.0;
w[3] = 1.0;
}
}
/* Clamp the bits for the framebuffer, except we aren't checking
* the actual framebuffer bits.
*/
if (l_size > 8)
l_size = 8;
if (i_size > 8)
i_size = 8;
if (r_size > 8)
r_size = 8;
if (g_size > 8)
g_size = 8;
if (b_size > 8)
b_size = 8;
if (a_size > 8)
a_size = 8;
if (d_size) {
piglit_set_tolerance_for_bits(8, 8, 8, 8);
} else if (i_size) {
piglit_set_tolerance_for_bits(i_size, i_size, i_size, i_size);
} else if (l_size) {
piglit_set_tolerance_for_bits(l_size, l_size, l_size, a_size);
} else {
piglit_set_tolerance_for_bits(r_size, g_size, b_size, a_size);
}
if (internalformat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
internalformat == GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT) {
/* If alpha in DXT1 is < 0.5, the whole pixel should be black. */
r[0] = r[1] = r[2] = r[3] = 0;
g[0] = g[1] = g[2] = g[3] = 0;
/* If alpha in DXT1 is >= 0.5, it should be white. */
b[3] = 1;
}
pass = pass && piglit_probe_rect_rgba(x1, y1, half, half, r);
pass = pass && piglit_probe_rect_rgba(x2, y1, half, half, g);
pass = pass && piglit_probe_rect_rgba(x1, y2, half, half, b);
pass = pass && piglit_probe_rect_rgba(x2, y2, half, half, w);
return pass;
}
void piglit_init(int argc, char **argv)
{
GLuint tex, fb;
GLenum status;
int i, dim;
piglit_require_GLSL();
piglit_require_extension("GL_EXT_framebuffer_object");
piglit_require_extension("GL_ARB_shader_texture_lod");
prog_tex = piglit_build_simple_program(NULL, sh_tex);
prog_texgrad = piglit_build_simple_program(NULL, sh_texgrad);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glTexImage2D(GL_TEXTURE_2D, i, GL_RGBA,
dim, dim,
0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
i);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO incomplete\n");
piglit_report_result(PIGLIT_SKIP);
}
glClearColor(colors[i][0],
colors[i][1],
colors[i][2],
0.0);
glClear(GL_COLOR_BUFFER_BIT);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
}
glDeleteFramebuffersEXT(1, &fb);
glBindTexture(GL_TEXTURE_2D, tex);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-0.1, 0.1, -0.1, 0.1, 0.1, 1000.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(-0.5, -0.5, -1.2);
glRotatef(68, 0, 1, 0);
glScalef(2000, 1, 1);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
piglit_set_tolerance_for_bits(7, 7, 7, 7);
printf("Left: texture2D, Right: texture2DGradARB\n");
}
static enum piglit_result test_format(const struct format_desc *format)
{
GLboolean pass = GL_TRUE;
GLuint tex, fb;
GLenum status;
int r, g, b, l, a, i;
unsigned mask, k;
float defaults[] = {-1, -1, -1, -1};
if (format->base_internal_format == GL_DEPTH_COMPONENT ||
format->base_internal_format == GL_DEPTH_STENCIL)
return PIGLIT_SKIP;
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glViewport(0, 0, piglit_width, piglit_height);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, format->internalformat,
piglit_width, piglit_height, 0,
GL_RGBA, GL_FLOAT, NULL);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
GL_TEXTURE_LUMINANCE_SIZE, &l);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
GL_TEXTURE_ALPHA_SIZE, &a);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
GL_TEXTURE_INTENSITY_SIZE, &i);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
GL_TEXTURE_RED_SIZE, &r);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
GL_TEXTURE_GREEN_SIZE, &g);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
GL_TEXTURE_BLUE_SIZE, &b);
/* Set up expected defaults.
* We're using glReadPixels from the texture.
*/
if (i) {
/* GL_INTENSITY texture: result = (I,0,0,1) */
defaults[3] = 1;
defaults[2] = defaults[1] = 0;
} else if (l) {
/* GL_LUMINANCE texture: result = (L,0,0,A) */
defaults[2] = defaults[1] = 0;
if (!a) {
defaults[3] = 1;
}
} else {
/* other format */
if (!r) {
defaults[0] = 0;
}
if (!g) {
defaults[1] = 0;
}
if (!b) {
defaults[2] = 0;
}
if (!a) {
defaults[3] = 1;
}
}
/* Clamp the bits for the framebuffer, except we aren't checking
* the actual framebuffer bits.
*/
if (l > 8)
l = 8;
if (i > 8)
i = 8;
if (r > 8)
r = 8;
if (g > 8)
g = 8;
if (b > 8)
b = 8;
if (a > 8)
a = 8;
if (i) {
piglit_set_tolerance_for_bits(i, i, i, i);
} else if (l) {
piglit_set_tolerance_for_bits(l, l, l, a);
} else {
piglit_set_tolerance_for_bits(r, g, b, a);
}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
printf("Testing %s", format->name);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf(" - fbo incomplete (status = %s)\n",
piglit_get_gl_enum_name(status));
piglit_report_subtest_result(PIGLIT_SKIP,
"%s (fbo incomplete)",
format->name);
return PIGLIT_SKIP;
}
printf("\n");
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
for (mask = 0; mask <= 15; mask++) {
float rect[4];
rect[0] = -1 + (mask / 8.0);
rect[1] = -1;
rect[2] = 2 / 16.0;
rect[3] = 2;
colormask(rect, mask);
}
for (mask = 0; mask <= 15; mask++) {
float color[4], out[4];
for (k = 0; k < 4; k++) {
if (defaults[k] >= 0)
color[k] = defaults[k];
else
color[k] = (mask & (1 << k)) ? 1 : 0;
}
if (!piglit_probe_pixel_rgba_silent(piglit_width * mask / 16, 0,
color, out)) {
printf("glColorMask(%i, %i, %i, %i)\n",
!!(mask & 1), !!(mask & 2),
!!(mask & 4), !!(mask & 8));
printf(" Expected: %f %f %f %f\n",
color[0], color[1], color[2], color[3]);
printf(" Observed: %f %f %f %f\n",
out[0], out[1], out[2], out[3]);
pass = GL_FALSE;
}
}
/*
* Display the texture.
*/
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glViewport(0, 0, piglit_width, piglit_height);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glColor4f(1, 1, 1, 1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, tex);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &tex);
glBindFramebufferEXT(GL_FRAMEBUFFER, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
piglit_present_results();
piglit_report_subtest_result(pass ? PIGLIT_PASS : PIGLIT_FAIL,
"%s", format->name);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
GLfloat buf_fcolor[IMAGE_SIZE][IMAGE_SIZE][4];
GLuint tex;
GLboolean pass = GL_TRUE;
GLenum format;
const GLfloat *expected;
int i, j;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* Image data setup */
for (i = 0; i < IMAGE_SIZE; i++) {
for (j = 0; j < IMAGE_SIZE; j++) {
buf_fcolor[i][j][0] = 0.5;
buf_fcolor[i][j][1] = 0.2;
buf_fcolor[i][j][2] = 0.8;
buf_fcolor[i][j][3] = 0.4;
}
}
/* Do glCopyPixels and draw a textured rectangle for each format
* and each texture target
*/
for (j = 0; j < ARRAY_SIZE(target); j++) {
/* Draw a pixel rectangle with float color data. As per OpenGL 3.0
* specification integer formats are not allowed in glDrawPixels
*/
glDrawPixels(IMAGE_SIZE, IMAGE_SIZE, GL_RGBA,
GL_FLOAT, buf_fcolor);
/* Texture setup */
glGenTextures(1, &tex);
glBindTexture(target[j], tex);
glTexParameteri(target[j],
GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
glTexParameteri(target[j],
GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(target[j],
GL_GENERATE_MIPMAP,
GL_FALSE);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
for (i = 0; i < ARRAY_SIZE(test_vectors); i++) {
GLint x = IMAGE_SIZE * (i + 1);
GLint y = 0;
GLfloat vertices_1d[2][2] = { {x, y},
{x + IMAGE_SIZE, y} };
format = test_vectors[i].format;
expected = (const float*)test_vectors[i].expected;
if(!piglit_automatic)
printf("Texture target = %s, Internal"
" format = %s\n",
piglit_get_gl_enum_name(target[j]),
piglit_get_gl_enum_name(format));
if (!supported_format(format) ||
!supported_target_format(target[j], format)) {
if (!piglit_automatic)
printf("Internal format = %s skipped\n",
piglit_get_gl_enum_name(format));
continue;
}
/* To avoid failures not related to this test case,
* loosen up the tolerence for compressed texture
* formats
*/
if (is_compressed_format(format))
piglit_set_tolerance_for_bits(7, 7, 7, 7);
else
piglit_set_tolerance_for_bits(8, 8, 8, 8);
switch(target[j]) {
case GL_TEXTURE_1D:
glCopyTexImage1D(GL_TEXTURE_1D, 0,
format,
0, 0, IMAGE_SIZE, 0);
pass = piglit_check_gl_error(GL_NO_ERROR)
&& pass;
glEnable(target[j]);
glEnableClientState(GL_VERTEX_ARRAY);
glTexCoordPointer(1, GL_FLOAT, 0, texCoords_1d);
glVertexPointer(2, GL_FLOAT, 0, vertices_1d);
glDrawArrays(GL_LINES, 0, 2);
pass = piglit_probe_pixel_rgba(x, 0, expected)
&& pass;
pass = piglit_probe_pixel_rgba(x + IMAGE_SIZE - 1,
0, expected)
&& pass;
break;
case GL_TEXTURE_2D:
glCopyTexImage2D(GL_TEXTURE_2D, 0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glEnable(target[j]);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords_2d);
piglit_draw_rect(x, y, IMAGE_SIZE, IMAGE_SIZE);
pass = piglit_probe_rect_rgba(x, y, IMAGE_SIZE,
IMAGE_SIZE,
expected)
&& pass;
break;
case GL_TEXTURE_CUBE_MAP:
glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X,
0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
0, format, 0, 0,
IMAGE_SIZE, IMAGE_SIZE, 0);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glEnable(target[j]);
/* Draw a rect with +X cubemap face as texture */
glTexCoordPointer(3, GL_FLOAT, 0,
cube_face_texcoords[0]);
piglit_draw_rect(x, y, IMAGE_SIZE, IMAGE_SIZE);
pass = piglit_probe_rect_rgba(x, y,
IMAGE_SIZE, IMAGE_SIZE, expected)
&& pass;
/* Draw a rect with +Z cubemap face as texture */
glTexCoordPointer(3, GL_FLOAT, 0,
cube_face_texcoords[2]);
piglit_draw_rect(x, y, IMAGE_SIZE, IMAGE_SIZE);
pass = piglit_probe_rect_rgba(x, y,
IMAGE_SIZE, IMAGE_SIZE, expected)
&& pass;
break;
}
glDisable(target[j]);
}
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDeleteTextures(1, &tex);
}
if (!piglit_automatic)
piglit_present_results();
return (pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
