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;
}
enum piglit_result
piglit_display(void)
{
static const char *fp_source =
"!!ARBfp1.0\n"
"TEX result.color, fragment.texcoord[0], texture[1], 2D;\n"
"END\n";
bool pass = true;
GLuint tex;
GLuint prog;
texrect_w = piglit_width / 4 / 2;
texrect_h = piglit_height / 2;
glGenProgramsARB(1, &prog);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(fp_source),
(const GLubyte *) fp_source);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glActiveTexture(GL_TEXTURE1);
tex = piglit_rgbw_texture(GL_RGBA, 2, 2, false, false,
GL_UNSIGNED_NORMALIZED);
/* Given that the failure mode we had that led to this test
* being written was that the sampler state read was
* pseudo-random, go through several statechanges on the
* sampler to make sure we're reliably getting our sampler
* state.
*/
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
piglit_draw_rect_tex(-1, -1, 0.5, 2,
0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
piglit_draw_rect_tex(-0.5, -1, 0.5, 2,
0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
piglit_draw_rect_tex(0, -1, 0.5, 2,
0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
piglit_draw_rect_tex(0.5, -1, 0.5, 2,
0, 0, 1, 1);
pass = pass && test_nearest(piglit_width * 0 / 4);
pass = pass && test_linear(piglit_width * 1 / 4);
pass = pass && test_nearest(piglit_width * 2 / 4);
pass = pass && test_linear(piglit_width * 3 / 4);
piglit_present_results();
glDeleteTextures(1, &tex);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glDeleteProgramsARB(1, &prog);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
float black[4] = {0.0, 0.0, 0.0, 0.0};
float white[4] = {1.0, 1.0, 1.0, 0.0};
float red[4] = {1.0, 0.0, 0.0, 0.0};
float green[4] = {0.0, 1.0, 0.0, 0.0};
float blue[4] = {0.0, 0.0, 1.0, 0.0};
GLboolean pass = GL_TRUE;
GLuint tex;
tex = piglit_checkerboard_texture(0, /* name */
0, /* level */
2, 2, /* width/height */
1, 1, /* checkerboard size */
black, white);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, red);
piglit_draw_rect_tex(-1, -1, 1, 1,
-2, -2, 0, 0);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, green);
piglit_draw_rect_tex( 0, -1, 1, 1,
-2, -2, 0, 0);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, blue);
piglit_draw_rect_tex(-1, 0, 1, 1,
-2, -2, 0, 0);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, white);
piglit_draw_rect_tex( 0, 0, 1, 1,
-2, -2, 0, 0);
pass = piglit_probe_pixel_rgb(piglit_width * 1 / 4,
piglit_height * 1 / 4, red) && pass;
pass = piglit_probe_pixel_rgb(piglit_width * 3 / 4,
piglit_height * 1 / 4, green) && pass;
pass = piglit_probe_pixel_rgb(piglit_width * 1 / 4,
piglit_height * 3 / 4, blue) && pass;
pass = piglit_probe_pixel_rgb(piglit_width * 3 / 4,
piglit_height * 3 / 4, white) && pass;
glDeleteTextures(1, &tex);
glutSwapBuffers();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
/* Clear the whole first texture with green */
glClearTexImage(texture[0], 0, GL_RGB, GL_FLOAT, green);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* Clear the left half of the second texture with blue */
glClearTexSubImage(texture[1], 0,
0, 0, 0,
32, 64, 1,
GL_RGB, GL_FLOAT, blue);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* And the right half with yellow */
glClearTexSubImage(texture[1], 0,
32, 0, 0,
32, 64, 1,
GL_RGB, GL_FLOAT, yellow);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* Render both textures to the screen */
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBindTexture(GL_TEXTURE_2D, texture[0]);
piglit_draw_rect_tex(0, 0, 64, 64, 0, 0, 1, 1);
glBindTexture(GL_TEXTURE_2D, texture[1]);
piglit_draw_rect_tex(64, 0, 64, 64, 0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(2, texture);
/* Check for the 3 separate regions */
pass &= piglit_probe_rect_rgb(0, 0, 64, 64, green);
pass &= piglit_probe_rect_rgb(64, 0, 32, 64, blue);
pass &= piglit_probe_rect_rgb(96, 0, 32, 64, yellow);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glClearColor(0,0,1,0);
glClear(GL_COLOR_BUFFER_BIT);
glAlphaFunc(GL_GEQUAL, 0.5f);
glEnable(GL_ALPHA_TEST);
glUseProgram(prog);
glViewport(0, 0, 64, 64);
piglit_draw_rect(-1, -1, 2, 2);
glDisable(GL_ALPHA_TEST);
/* visualize it */
glUseProgram(0);
glBindFramebuffer(GL_FRAMEBUFFER, piglit_winsys_fbo);
glViewport(0, 0, 128, 64);
glClearColor(0,0,0.5,0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, color0);
piglit_draw_rect_tex(-1, -1, 1, 2,
0, 0, 1, 1);
glBindTexture(GL_TEXTURE_2D, color1);
piglit_draw_rect_tex(0, -1, 1, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
{
bool pass = true;
float red[] = {1,0,0};
float green[] = {0,1,0};
float blue[] = {0,0,1};
pass = piglit_probe_pixel_rgb(4, 4, blue) && pass;
pass = piglit_probe_pixel_rgb(12, 4, red) && pass;
pass = piglit_probe_pixel_rgb(64 + 4, 4, blue) && pass;
pass = piglit_probe_pixel_rgb(64 + 12, 4, green) && pass;
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
}
enum piglit_result
piglit_display(void)
{
static const GLfloat color[4] = { 0.0, 1.0, 0.0, 1.0 };
enum piglit_result result = PIGLIT_PASS;
unsigned i;
glClear(GL_COLOR_BUFFER_BIT);
for (i = 0; i < ARRAY_SIZE(progs); i++) {
const int x = 1 + (i * (BOX_SIZE + 1));
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, progs[i]);
glEnable(GL_CLIP_PLANE0 + i);
piglit_draw_rect_tex(x, 1, BOX_SIZE, BOX_SIZE,
1.0, 1.0, -2.0, 0.0);
glDisable(GL_CLIP_PLANE0 + i);
if (!piglit_probe_pixel_rgb(x + (BOX_SIZE / 2),
1 + (BOX_SIZE / 2),
color)) {
result = PIGLIT_FAIL;
}
}
piglit_present_results();
return result;
}
enum piglit_result
piglit_display(void)
{
const int tile_size = BOX_SIZE / 4;
GLboolean pass = GL_TRUE;
unsigned i;
glClear(GL_COLOR_BUFFER_BIT);
for (i = 0; i < TEST_COLS; i++) {
const int x = 1 + ((BOX_SIZE + 2) * i);
glUniform1f(bias_loc, (float) i);
/* Draw the rectangle the same size as the texture. This
* guarantees that the unbiased LOD will be 0.0.
*/
piglit_draw_rect_tex((float) x, 1.0,
BOX_SIZE, BOX_SIZE,
0.0, 0.0, 1.0, 1.0);
/* The middle of the lower left tile should be green, and the
* middle of the tile next to it should be the clear color.
*/
if (!piglit_probe_pixel_rgb(x + (3 * tile_size / 2), 2, clear_color)
|| !piglit_probe_pixel_rgb(x + (tile_size / 2), 2, green)) {
pass = GL_FALSE;
}
}
glutSwapBuffers();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static GLboolean
draw_and_test(int x_offset, int y_offset, float min_lod, float max_lod)
{
GLfloat y;
int dim;
int level;
GLboolean pass = GL_TRUE;
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, max_lod);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, min_lod);
y = y_offset;
for (level = 0, dim = MAX_SIZE; dim > 0; level++, dim /= 2) {
piglit_draw_rect_tex(x_offset, y, dim, dim,
0.0, 0.0, 1.0, 1.0);
y += dim + PAD;
}
y = y_offset;
for (level = 0, dim = MAX_SIZE; dim > 0; level++, dim /= 2) {
pass = pass && test_results(x_offset, y,
dim, level,
min_lod, max_lod) && pass;
y += dim + PAD;
}
return pass;
}
static enum piglit_result
draw(struct egl_state *state)
{
EGLSurface *pixmap;
EGLint inv;
float red[] = { 0.4, 0.0, 0.0, 1.0 };
float purple[] = { 0.5, 0.0, 0.5, 1.0 };
enum piglit_result result = PIGLIT_PASS;
if (!eglGetConfigAttrib(state->egl_dpy, state->cfg,
EGL_Y_INVERTED_NOK, &inv)) {
fprintf(stderr,
"eglGetConfigAttrib(EGL_Y_INVERTED_NOK) failed\n");
return PIGLIT_FAIL;
}
printf("EGL_Y_INVERTED_NOK: %s\n", inv ? "TRUE" : "FALSE");
pixmap = egl_util_create_pixmap(state, 100, 100, pixmap_attribs);
if (!eglMakeCurrent(state->egl_dpy, pixmap, pixmap, state->ctx)) {
fprintf(stderr, "eglMakeCurrent() failed\n");
piglit_report_result(PIGLIT_FAIL);
}
/* Clear pixmap to purple */
glClearColor(0.5, 0.0, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
if (!eglMakeCurrent(state->egl_dpy,
state->surf, state->surf, state->ctx)) {
fprintf(stderr, "eglMakeCurrent() failed\n");
piglit_report_result(PIGLIT_FAIL);
}
glViewport(0, 0, state->width, state->height);
piglit_ortho_projection(state->width, state->height, GL_FALSE);
glClearColor(0.4, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
eglBindTexImage(state->egl_dpy, pixmap, EGL_BACK_BUFFER);
piglit_draw_rect_tex(20, 20, 100, 100, 0, 0, 1, 1);
if (!piglit_probe_pixel_rgba(10, 10, red) ||
!piglit_probe_pixel_rgba(50, 10, red) ||
!piglit_probe_pixel_rgba(10, 50, red) ||
!piglit_probe_pixel_rgba(50, 50, purple) ||
!piglit_probe_pixel_rgba(110, 110, purple) ||
!piglit_probe_pixel_rgba(130, 130, red))
result = PIGLIT_FAIL;
eglSwapBuffers(state->egl_dpy, state->surf);
return result;
}
static int
test_etc1_rgb8_texture_8x8(const struct etc1_rgb8_texture_8x8 *tex)
{
const GLenum format = GL_ETC1_RGB8_OES;
const GLsizei width = 8, height = 8;
unsigned x, y;
int pass = GL_TRUE;
glCompressedTexImage2D(GL_TEXTURE_2D, 0,
format, width, height, 0, sizeof(tex->data), tex->data);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glEnable(GL_TEXTURE_2D);
piglit_draw_rect_tex(0, 0, width, height, 0.0f, 0.0f, 1.0f, 1.0f);
glDisable(GL_TEXTURE_2D);
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
const GLubyte *rgb = tex->rgb[y * width + x];
float expected[3] = {
rgb[0] / 255.0f,
rgb[1] / 255.0f,
rgb[2] / 255.0f
};
pass = piglit_probe_pixel_rgb(x, y, expected) && pass;
}
}
return pass;
}
static void
draw_rect(int pos)
{
int x, y, w, h;
get_rect_bounds(pos, &x, &y, &w, &h);
piglit_draw_rect_tex(x, y, w, h, 0, 0, 1, 1);
}
/** Draw quad textured with depth image on right side of window */
static void
draw_quad_with_depth_texture(void)
{
GLfloat s1, t1;
if (TexTarget == GL_TEXTURE_2D) {
s1 = t1 = 1.0;
}
else {
s1 = SIZE;
t1 = SIZE;
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glViewport(2 * SIZE, 0, SIZE, SIZE);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1.0);
glBindTexture(TexTarget, DepthTex);
glEnable(TexTarget);
piglit_draw_rect_tex(-1, -1, 2, 2, 0, 0, s1, t1);
glDisable(TexTarget);
}
enum piglit_result
piglit_display(void)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, rgba_tex);
piglit_draw_rect_tex(-1.0, -1.0, 1.0, 2.0,
0.0, 0.0, 1.0, 1.0);
glBindTexture(GL_TEXTURE_2D, other_tex);
piglit_draw_rect_tex(0.0, -1.0, 1.0, 2.0,
0.0, 0.0, 1.0, 1.0);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
int x, y;
GLuint fb, tex;
/* Draw the shader to the fbo. */
fb = create_fbo(WIDTH, HEIGHT, &tex);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glViewport(0, 0, WIDTH, HEIGHT);
glClearColor(1.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(prog);
piglit_draw_rect(-1, -1, 2, 2);
/* Draw the FBO to the screen. */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glViewport(0, 0, piglit_width, piglit_height);
glClearColor(0.0, 0.0, 1.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glBindTexture(GL_TEXTURE_2D, tex);
glEnable(GL_TEXTURE_2D);
glUseProgram(0);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &tex);
glDeleteFramebuffersEXT(1, &fb);
assert(glGetError() == 0);
for (y = 0; y < piglit_height; y++) {
for (x = 0; x < piglit_width; x++) {
float color[3];
color[0] = x / 256.0;
color[1] = y / 256.0;
color[2] = 0;
pass &= piglit_probe_pixel_rgb(x, y, color);
if (!pass)
break;
}
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
float red[4] = {1.0, 0.0, 0.0, 0.0};
float green[4] = {0.0, 1.0, 0.0, 0.0};
GLuint q, texture;
int tex_size = 64;
int i;
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
/* Set up a texture object with green at level 0, red elsewhere */
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
for (i = 0; tex_size / (1 << i) > 0; i++)
fill_level(i, tex_size / (1 << i), i == 0 ? green : red);
glGenQueries(1, &q);
/* Generate query fail. */
glBeginQuery(GL_SAMPLES_PASSED, q);
glEndQuery(GL_SAMPLES_PASSED);
/* Mipmap generation should not be affected by conditional rendering. */
glBeginConditionalRenderNV(q, GL_QUERY_WAIT_NV);
glGenerateMipmapEXT(GL_TEXTURE_2D);
glEndConditionalRenderNV();
/* This should draw level 1, since starting window size is 32
* and texture is 64.
*/
glEnable(GL_TEXTURE_2D);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height,
green);
glutSwapBuffers();
glDeleteQueries(1, &q);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
GLuint tex, fb;
GLenum status;
float green[] = {0, 1, 0, 0};
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
piglit_width, piglit_height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "fbo incomplete (status = 0x%04x)\n", status);
piglit_report_result(PIGLIT_SKIP);
}
glClearColor(1.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_NEVER);
glColor4fv(green);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, green);
glDisable(GL_DEPTH_TEST);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
piglit_draw_rect_tex(0, 0, piglit_width, piglit_height,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
float red[4] = {1.0, 0.0, 0.0, 0.0};
float green[4] = {0.0, 1.0, 0.0, 0.0};
GLuint q, texture;
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
/* Draw bottom half of window to green. */
glColor4fv(green);
piglit_draw_rect(-1, -1, 2, 1);
glColor4f(1, 1, 1, 1);
/* Set up a red texture. */
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
fill_tex(0, piglit_width*2, piglit_height / 2, red);
glGenQueries(1, &q);
/* Generate query fail. */
glBeginQuery(GL_SAMPLES_PASSED, q);
glEndQuery(GL_SAMPLES_PASSED);
/* This should not be affected by conditional rendering. */
glBeginConditionalRenderNV(q, GL_QUERY_WAIT_NV);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, piglit_width, 0, 0, 0, piglit_width, piglit_height / 2);
glEndConditionalRenderNV();
/* Draw the right half of the texture. */
glEnable(GL_TEXTURE_2D);
piglit_draw_rect_tex(-1, 0, 2, 1,
0.5, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height,
green);
glutSwapBuffers();
glDeleteQueries(1, &q);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
pass &= run_all_factor_sets();
if (!piglit_automatic) {
/*
* Draw our three images, separated by some space.
* This will show only the results of the last test.
*/
/* Draw dst */
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);
/* Draw src */
glBindTexture(GL_TEXTURE_2D, src_img.name);
piglit_draw_rect_tex(img_width + 2, 0,
img_width, img_height, 0, 0, 1, 1);
/* Draw exp */
glBindTexture(GL_TEXTURE_2D, exp_img.name);
/* Have to resend the texture to GL to update GL's copy */
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
img_width, img_height, 0,
GL_RGBA, GL_FLOAT, exp_img.data);
piglit_draw_rect_tex(2*(img_width + 2), 0,
img_width, img_height, 0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
piglit_present_results();
}
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
} /* piglit_display */
static void
draw_mipmap(int x, int y, int dim)
{
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
piglit_draw_rect_tex(x, y, dim, dim,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
}
enum piglit_result
piglit_display(void)
{
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glClearColor(0,0,1,0);
glClear(GL_COLOR_BUFFER_BIT);
glAlphaFunc(GL_GEQUAL, 0.5f);
glEnable(GL_ALPHA_TEST);
glUseProgram(prog);
glViewport(0, 0, 64, 64);
piglit_draw_rect(-1, -1, 2, 2);
glDisable(GL_ALPHA_TEST);
/* Visualize it */
glUseProgram(0);
glBindFramebuffer(GL_FRAMEBUFFER, piglit_winsys_fbo);
glViewport(0, 0, 128, 64);
glClearColor(0,0,0.5,0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, color1);
piglit_draw_rect_tex(-1, -1, 1, 2,
0, 0, 1, 1);
glBindTexture(GL_TEXTURE_2D, color2);
piglit_draw_rect_tex(0, -1, 1, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
piglit_present_results();
/* The fragment colors are undefined in this test. So, we can't probe the
* pixels. If test executes to completion, return PIGLIT_PASS.
*/
return PIGLIT_PASS;
}
static void
display_mipmaps(int x, int y)
{
int i;
glEnable(GL_TEXTURE_2D);
/* Disply all the mipmap levels */
for (i = SIZE; i > 0; i /= 2) {
piglit_draw_rect_tex(x, y, i, i,
0, 0, 1, 1);
x += i + 5;
}
}
static void
draw_mipmap(int x, int y, int dim)
{
glViewport(0, 0, piglit_width, piglit_height);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
piglit_draw_rect_tex(x, y, dim, dim,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
}
enum piglit_result
piglit_display(void)
{
unsigned i;
for (i = 0; i < num_tex; i++) {
glBindTexture(GL_TEXTURE_2D, tex[i]);
piglit_draw_rect_tex(-1.0 + ((float) (2 * i) / num_tex), -1.0,
2.0 / num_tex, 2.0,
0.0, 0.0, 1.0, 1.0);
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
int pass;
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glBindTextureUnit(0, name);
piglit_draw_rect_tex(0, 0, 1, 1, 0, 0, 1, 1);
piglit_present_results();
pass = test_getteximage();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static void draw_fbo_1d(int x, int y)
{
glViewport(0, 0, piglit_width, piglit_height);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_1D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
piglit_draw_rect_tex(x, y, BUF_WIDTH, 1,
0, 0, 1, 1);
}
enum piglit_result piglit_display(void)
{
GLboolean pass = GL_TRUE;
float black[] = {0, 0, 0, 0};
float white[] = {1, 1, 1, 1};
GLuint tex;
glClearColor(0.0, 1.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
create_fbo(&tex);
glBindTexture(GL_TEXTURE_2D, tex);
glViewport(0, 0, piglit_width, piglit_height);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
pass = pass && piglit_probe_rect_rgba(0, 0,
piglit_width / 2, piglit_height,
black);
pass = pass && piglit_probe_rect_rgba(piglit_width / 2, 0,
piglit_width / 2, piglit_height,
white);
glDeleteTextures(1, &tex);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
/*
* Texture using thread: draws with successive textures and checks that the
* correct color is drawn. Return NULL on failure, else non-NULL.
*/
static void *
draw_func(void *arg)
{
int count = 0;
int ret;
ret = glXMakeCurrent(dpy, draw_win, draw_ctx);
assert(ret);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
while (!quit && count < num_test) {
struct texture *tex = advance(&count, DRAW);
float expect[] = {
tex->color / 255.,
tex->color / 255.,
tex->color / 255.,
};
assert(tex->user == DRAW);
glBindTexture(GL_TEXTURE_2D, tex->id);
piglit_draw_rect_tex(0, 0, piglit_width, piglit_height,
0, 0, 1, 1);
glXSwapBuffers(dpy, draw_win);
/* first texture not filled so don't check it */
if (count > 0 &&
!piglit_probe_rect_rgb(0, 0, piglit_width,
piglit_height, expect)) {
break;
}
}
if (count < num_test) {
quit = true;
return NULL;
}
return "";
}
static bool
check_rendering_(int width, int height, int line)
{
const int w = width / 2 - 2;
const int h = height / 2 - 2;
bool pass = true;
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glColor3f(1, 1, 1);
/* draw the texture */
piglit_draw_rect_tex(0, 0, width, height, 0, 0, 1, 1);
/* NOTE: don't probe the border pixels of the quadrants just to
* avoid potential off-by one errors.
*/
/* lower-left red */
pass = piglit_probe_rect_rgb(1, 1, w, h, red) && pass;
/* lower-right green */
pass = piglit_probe_rect_rgb(width/2 + 1, 1, w, h, green) && pass;
/* upper-left blue */
pass = piglit_probe_rect_rgb(1, height/2 + 1, w, h, blue) && pass;
/* upper-right white */
pass = piglit_probe_rect_rgb(width/2 + 1, height/2 + 1,
w, h, white) && pass;
piglit_present_results();
if (!pass) {
printf("s3tc-errors failure at line %d\n", line);
}
return pass;
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
glColor4fv(green);
piglit_draw_rect_tex(0.0, 0.0,
(float) piglit_width, (float) piglit_height,
0.0, 0.0, 1.0, 1.0);
pass &= piglit_probe_pixel_rgb(0, 0, black);
pass &= piglit_probe_pixel_rgb(piglit_width - 1, 0, green);
pass &= piglit_probe_pixel_rgb(0, piglit_height - 1, green);
pass &= piglit_probe_pixel_rgb(piglit_width - 1, piglit_height - 1,
black);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static void
draw_level(int x, int y, int level)
{
int loc;
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_LOD, level);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAX_LOD, level);
glUseProgram(prog);
loc = glGetUniformLocation(prog, "tex");
glUniform1i(loc, 0); /* texture unit p */
glViewport(0, 0, piglit_width, piglit_height);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glBindFramebuffer(GL_FRAMEBUFFER, piglit_winsys_fbo);
piglit_draw_rect_tex(x, y, TEX_SIZE, 5, 0, 0, 1, 1);
glUseProgram(0);
}
