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_STENCIL_TEST);
glStencilFunc(GL_NEVER, 0xd0, 0xff);
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_STENCIL_TEST);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
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;
}
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)
{
GLubyte stencil_rect[20 * 20];
int i;
GLboolean pass = GL_TRUE;
static float red[] = {1.0, 0.0, 0,0, 0.0};
static float black[] = {0.0, 0.0, 0,0, 0.0};
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glClearStencil(0);
glClearDepth(1.0);
glClearColor(0.0, 0.0, 0.0, 0.0);
glDisable(GL_DITHER);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 20);
for (i=0; i<20*20; i++)
if (i < 20*20/2)
stencil_rect[i] = 1;
else
stencil_rect[i] = 0;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_LESS, 0, (GLuint)~0);
glRasterPos2i(50, 50);
glDrawPixels(20, 20, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, stencil_rect);
glColor3f(1.0, 0.0, 0.0);
glRectf(50, 50, 50+20, 50+20);
glDisable(GL_STENCIL_TEST);
pass &= piglit_probe_rect_rgb(50, 50, 20, 10, red);
pass &= piglit_probe_rect_rgb(50, 60, 20, 10, black);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static enum piglit_result test_clear(void)
{
GLuint cb;
GLenum status;
float green[3] = {0, 1, 0};
enum piglit_result res;
/* Add a colorbuffer. */
glGenRenderbuffersEXT(1, &cb);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, cb);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, BUF_SIZE, BUF_SIZE);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER_EXT, cb);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
glReadBuffer(GL_COLOR_ATTACHMENT0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("FBO incomplete status 0x%X\n", status);
piglit_report_result(PIGLIT_FAIL); /* RGBA8 must succeed. */
}
glClearDepth(0.75);
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glColor3fv(green);
glDepthFunc(GL_LEQUAL);
piglit_draw_rect_z(0.499, -1, -1, 1, 2); /* 0.75 converted to clip space is 0.5. */
glDepthFunc(GL_GEQUAL);
piglit_draw_rect_z(0.501, 0, -1, 1, 2);
glColor3f(1, 1, 1);
glDisable(GL_DEPTH_TEST);
res = piglit_probe_rect_rgb(0, 0, BUF_SIZE, BUF_SIZE, green) ? PIGLIT_PASS : PIGLIT_FAIL;
/* Display the colorbuffer. */
if (!piglit_automatic) {
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
glBlitFramebufferEXT(0, 0, BUF_SIZE, BUF_SIZE, 0, 0, BUF_SIZE, BUF_SIZE,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
glDeleteRenderbuffersEXT(1, &cb);
return res;
}
enum piglit_result
draw(Display *dpy)
{
GLXContext ctx;
GLboolean pass = GL_TRUE;
static float red[] = {1.0, 0.0, 0.0, 0.0};
static float green[] = {0.0, 1.0, 0.0, 0.0};
ctx = piglit_get_glx_context(dpy, visinfo);
glXMakeCurrent(dpy, win_one, ctx);
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
glClearColor(1.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glXSwapBuffers(dpy, win_one);
glClearColor(0.0, 1.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
CopySubBuffer(dpy, win_one,
piglit_width / 4,
piglit_height / 4,
piglit_width / 2,
piglit_height / 2);
glReadBuffer(GL_FRONT);
pass &= piglit_probe_rect_rgb(0, 0, piglit_width / 4, piglit_height / 4,
red);
pass &= piglit_probe_rect_rgb(piglit_width / 4, piglit_width / 4,
piglit_width / 2, piglit_height / 2,
green);
glXMakeCurrent(dpy, None, NULL);
glXDestroyContext(dpy, ctx);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result piglit_display(void)
{
static const float green[] = { 0.0, 1.0, 0.0, 1.0 };
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(prog140);
piglit_draw_rect(-1.0f, -1.0f, 1.0f, 2.0f);
piglit_probe_rect_rgb(0, 0,
piglit_width / 2, piglit_height,
green);
if (prog150 != 0) {
glUseProgram(prog150);
piglit_draw_rect(0.0f, -1.0f, 1.0f, 2.0f);
piglit_probe_rect_rgb(piglit_width / 2, 0,
piglit_width / 2, piglit_height,
green);
}
piglit_present_results();
return PIGLIT_PASS;
}
void
piglit_init(int argc, char **argv)
{
GLboolean pass = GL_TRUE;
static float green[] = {0.0, 1.0, 0.0, 0.0};
glClearAccum(0, 1, 0, 0);
glClear(GL_ACCUM_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glAccum(GL_RETURN, 1.0);
pass &= piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, green);
if (pass)
piglit_report_result(PIGLIT_PASS);
else
piglit_report_result(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 "";
}
void
piglit_init(int argc, char **argv)
{
int i, j;
bool pass = true;
GLuint fbo, texture;
float colorData[2][10*10*3];
/* fill in colorData */
for(j = 0; j < 2; j++)
for(i = 0; i < 10*10; i++) {
colorData[j][i*3+0] = color[j][0];
colorData[j][i*3+1] = color[j][1];
colorData[j][i*3+2] = color[j][2];
}
/* Create the Source framebuffer object */
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_3D, texture);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 10, 10, 2, 0, GL_RGB,
GL_FLOAT, colorData);
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferTexture3D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_3D, texture, 0, 0);
if(!piglit_check_gl_error(GL_NO_ERROR)) {
piglit_report_result(PIGLIT_FAIL);
}
/* piglit_probe_rect_rgb internally calls ReadPixel(). Check that
* the color probed is the same as the Zero layer of the texture.
*/
pass = piglit_probe_rect_rgb(0, 0, 10, 10, color[0]) && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
/* draw a quad with depth varying from 1.0 at the left side to -1.0 at
* the right side (NDC) */
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
glViewport(0, 0, TEX_WIDTH, TEX_HEIGHT);
glUseProgram(0);
glClearDepth(1.0f);
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glBegin(GL_TRIANGLE_STRIP);
glVertex3f(-1.0f, -1.0f, 1.0f);
glVertex3f( 1.0f, -1.0f, -1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);
glEnd();
glDisable(GL_DEPTH_TEST);
/* sample depth and write color to the default framebuffer
* so we can look at it */
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, piglit_winsys_fbo);
glClearColor(0.2, 0.2, 0.2, 0.2);
glClear(GL_COLOR_BUFFER_BIT);
glViewport(0, 0, TEX_WIDTH, TEX_HEIGHT);
glUseProgram(prog);
piglit_draw_rect(-1, -1, 2, 2);
pass = piglit_probe_rect_rgb(0, 0, TEX_WIDTH, TEX_HEIGHT, green) && pass;
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
glViewport(0, 0, 64, 64);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, ms_fbo);
glUseProgram(draw_prog);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, piglit_winsys_fbo);
glUseProgram(test_prog);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
pass = piglit_probe_rect_rgb(0, 0, 64, 64, green) && pass;
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
int i;
bool pass = true;
unsigned zero = 0;
/* Setup program and initial buffer contents */
glBindBuffer(GL_ARRAY_BUFFER, bufs[0]);
glBufferData(GL_ARRAY_BUFFER, 4, &zero, GL_STREAM_COPY);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufs[1]);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 4, &zero, GL_STREAM_COPY);
glUseProgram(prog);
glClear(GL_COLOR_BUFFER_BIT);
glPointSize(16);
/* Draw 16 times, swapping transform feedback and uniform data
* so that transform feedback output is fed back to uniform
* input.
*/
for (i = 0; i < 16; ++i) {
glBindBufferBase(GL_UNIFORM_BUFFER, 0, bufs[i % 2]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0,
bufs[(i + 1) % 2]);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, 1);
glEndTransformFeedback();
}
/* Check that the proper gradient was drawn */
for (i = 0; i < 16; ++i) {
float expected_color[3] = {i/16.0, (16 - i)/16.0, i/16.0 };
pass = piglit_probe_rect_rgb(16 * i, 0, 16, 16,
expected_color) && pass;
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
bool
probe_texture_layered_rgb(GLuint texture, int x, int y,
int z, int w, int h, int d, const float *expected)
{
int k;
GLuint fbo;
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
for(k = 0; k < d; k++ ) {
glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
texture, 0, k+z);
if(!piglit_probe_rect_rgb(0, 0, w, h, &expected[k*3])) {
printf("Layer: %i\n", k);
return false;
}
}
return true;
}
static GLboolean
run_subtest(GLuint vs, GLuint fs, int max_xfb_varyings,
int max_varyings, const char **xfb_varyings)
{
GLboolean pass = GL_TRUE;
int row, col;
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
for (row = 0; row < max_xfb_varyings; row++) {
pass = draw(vs, fs, row + 1, max_varyings, xfb_varyings);
if (!pass) {
goto end;
}
}
for (row = 0; row < max_xfb_varyings; row++) {
for (col = 0; col < max_varyings - row; col++) {
GLboolean ok;
float green[3] = {0.0, 1.0, 0.0};
ok = piglit_probe_rect_rgb(coord_from_index(col),
coord_from_index(row),
10, 10,
green);
if (!ok) {
printf(" Failure with %d vec4 varyings"
" captured and offset %d\n",
row + 1, col);
pass = GL_FALSE;
goto end;
}
}
}
end:
return pass;
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
GLuint tex0, tex1, fb;
GLenum status;
float green[] = {0, 1, 0, 0};
float blue[] = {0, 0, 1, 0};
const GLenum attachments[] = {
GL_COLOR_ATTACHMENT0_EXT,
GL_COLOR_ATTACHMENT1_EXT,
};
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
tex0 = attach_texture(0);
tex1 = attach_texture(1);
glDrawBuffersARB(2, attachments);
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);
}
/* Clear to blue. The first buffer will have no blending and
* get overwritten green, and the second will be blended ZERO,
* ONE leaving the blue in place.
*/
glClearColor(0.0, 0.0, 1.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glBlendFunc(GL_ZERO, GL_ONE);
glDisableIndexedEXT(GL_BLEND, 0);
glEnableIndexedEXT(GL_BLEND, 1);
glColor4fv(green);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glDisable(GL_BLEND);
/* Draw the two textures to halves of the window. */
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBindTexture(GL_TEXTURE_2D, tex0);
piglit_draw_rect_tex(0, 0,
piglit_width / 2, piglit_height,
0, 0, 1, 1);
glBindTexture(GL_TEXTURE_2D, tex1);
piglit_draw_rect_tex(piglit_width / 2, 0,
piglit_width, piglit_height,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &tex0);
glDeleteTextures(1, &tex1);
glDeleteFramebuffersEXT(1, &fb);
pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/2,
piglit_height, green);
pass = pass && piglit_probe_rect_rgb(piglit_width/2, 0, piglit_width/2,
piglit_height, blue);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
/* a tight epsilon isn't important for this test */
const GLfloat epsilon = 4.0 / piglit_width;
static const GLfloat white[4] = { 1, 1, 1, 1 };
static const GLfloat green[4] = { 0, 1, 0, 1 };
static const GLfloat red[4] = { 1, 0, 0, 1 };
GLfloat *buf;
bool pass = true;
int i, j;
float zLeft, zRight;
/* For both glDrawPixels and the polygon rendering below we
* use a range of Z values in [0, 1] where 0=near and 1=far.
* So object Z coords are the same as normalized depth coords.
*/
zLeft = epsilon;
zRight = 1.0 - epsilon;
/* create image of Z values increasing from left to right */
buf = (GLfloat *)
malloc(piglit_width * piglit_height * sizeof(GLfloat));
for (j = 0; j < piglit_height; j++) {
for (i = 0; i < piglit_width; i++) {
float z = i / (float) (piglit_width - 1);
z = zLeft + z * (zRight - zLeft);
buf[j * piglit_width + i] = z;
}
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* glDrawPixels the Z gradient image */
glColor4fv(white);
glWindowPos2i(0, 0);
glDrawPixels(piglit_width, piglit_height,
GL_DEPTH_COMPONENT, GL_FLOAT, buf);
free(buf);
/* draw a red quad behind the Z gradient - it should not be visible */
glColor4fv(red);
draw_z_gradient(zLeft + epsilon, zRight + epsilon);
if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, white)) {
printf("Quad behind test failed\n");
pass = false;
}
/* draw green quad in front of the Z gradient - it should be visible */
glColor4fv(green);
draw_z_gradient(zLeft - epsilon, zRight - epsilon);
if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, green)) {
printf("Quad in front test failed\n");
pass = false;
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
bool
testFramebufferBlitLayered(int x, int y, bool srcLayered, bool dstLayered)
{
bool pass = true;
GLuint srcFBO, dstFBO;
GLuint srcTex, dstTex;
GLenum fbStatus;
/* Set up source fbo */
glGenFramebuffers(1, &srcFBO);
glBindFramebuffer(GL_FRAMEBUFFER, srcFBO);
piglit_check_gl_error(GL_NO_ERROR);
if (srcLayered) {
srcTex = create_bind_texture(GL_TEXTURE_3D, true);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
srcTex, 0);
} else {
srcTex = create_bind_texture(GL_TEXTURE_2D, true);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, srcTex, 0);
}
/* Check source framebuffer status */
fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (fbStatus != GL_FRAMEBUFFER_COMPLETE) {
printf("testFramebufferBlitLayered srcFBO Status: %s\n",
piglit_get_gl_enum_name(fbStatus));
return false;
}
/* Set up dstt fbo */
glGenFramebuffers(1, &dstFBO);
glBindFramebuffer(GL_FRAMEBUFFER, dstFBO);
if (dstLayered) {
dstTex = create_bind_texture(GL_TEXTURE_3D, false);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
dstTex, 0);
} else {
dstTex = create_bind_texture(GL_TEXTURE_2D, false);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, dstTex, 0);
}
/* Check destination framebuffer status */
fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (fbStatus != GL_FRAMEBUFFER_COMPLETE) {
printf("testFramebufferBlitLayered dstFBO Status: %s\n",
piglit_get_gl_enum_name(fbStatus));
return false;
}
/* Check for if any errors have occured */
if (!piglit_check_gl_error(GL_NO_ERROR)) {
printf("Error setting up framebuffers for test.\n");
return false;
}
/* Blit from source to destination framebuffers */
glBindFramebuffer(GL_READ_FRAMEBUFFER, srcFBO);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dstFBO);
glBlitFramebuffer(0, 0, texWidth, texHeight,
0, 0, texWidth, texHeight,
GL_COLOR_BUFFER_BIT, GL_LINEAR);
/* Display the results */
display_texture(x, y, srcTex, srcLayered ? texDepth : 1);
display_texture(x + texWidth, y, dstTex, dstLayered ? texDepth : 1);
/* Check for pass condition */
if (dstLayered) {
pass = piglit_probe_rect_rgb(x + texWidth, y,
texWidth, texHeight, srcColors[0]) && pass;
pass = piglit_probe_rect_rgb(x + texWidth, y + texHeight,
texWidth, texHeight, dstColors[1]) && pass;
} else {
pass = piglit_probe_rect_rgb(x + texWidth, y, texWidth,
texDepth * texHeight, srcColors[0]) && pass;
}
/* Clean up */
glBindFramebuffer(GL_FRAMEBUFFER, piglit_winsys_fbo);
glDeleteFramebuffers(1, &srcFBO);
glDeleteFramebuffers(1, &dstFBO);
glDeleteTextures(1, &srcTex);
glDeleteTextures(1, &dstTex);
/* Check for if any errors have occured */
if (!piglit_check_gl_error(GL_NO_ERROR)) {
printf("Error setting up framebuffers for test.\n");
return false;
}
return pass;
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
GLuint tex0, tex1, fb;
GLenum status;
float white[] = {1, 1, 1, 1};
float green[] = {0, 1, 0, 0};
float blue[] = {0, 0, 1, 0};
const GLenum attachments[] = {
GL_COLOR_ATTACHMENT0_EXT,
GL_COLOR_ATTACHMENT1_EXT,
};
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
tex0 = attach_texture(0);
tex1 = attach_texture(1);
glDrawBuffersARB(2, attachments);
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);
}
/* Clear to black */
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
/* Mask only green in RT 0, blue in RT 1, then try to draw in white */
glColorMaskIndexedEXT(0, GL_FALSE, GL_TRUE, GL_FALSE, GL_FALSE);
glColorMaskIndexedEXT(1, GL_FALSE, GL_FALSE, GL_TRUE, GL_FALSE);
if (test_clear) {
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
} else {
glColor4fv(white);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
/* Draw the two textures to halves of the window. */
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBindTexture(GL_TEXTURE_2D, tex0);
piglit_draw_rect_tex(0, 0,
piglit_width / 2, piglit_height,
0, 0, 1, 1);
glBindTexture(GL_TEXTURE_2D, tex1);
piglit_draw_rect_tex(piglit_width / 2, 0,
piglit_width, piglit_height,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &tex0);
glDeleteTextures(1, &tex1);
glDeleteFramebuffersEXT(1, &fb);
pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/2,
piglit_height, green);
pass = pass && piglit_probe_rect_rgb(piglit_width/2, 0, piglit_width/2,
piglit_height, blue);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
int y, size;
GLuint tex, fb;
const float red[] = {1, 0, 0, 0};
const float green[] = {0, 1, 0, 0};
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
TEX_WIDTH, TEX_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);
assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) ==
GL_FRAMEBUFFER_COMPLETE_EXT);
/* For each power of two size we test, draw red to it, draw it to
* the framebuffer, then draw green to it and draw it to the
* framebuffer.
*
* Hopefully between these we'll catch any flushing fail.
*/
y = 0;
for (size = TEX_WIDTH; size > 0; size /= 2) {
glDisable(GL_TEXTURE_2D);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glColor4fv(red);
piglit_ortho_projection(TEX_WIDTH, TEX_HEIGHT, GL_FALSE);
piglit_draw_rect(0, y, size, size);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
piglit_draw_rect_tex(0, y, size, size, 0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glColor4fv(green);
piglit_ortho_projection(TEX_WIDTH, TEX_HEIGHT, GL_FALSE);
piglit_draw_rect(0, y, size, size);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
piglit_draw_rect_tex(0, y, size, size, 0, 0, 1, 1);
y += size + 5;
}
glDeleteFramebuffersEXT(1, &fb);
glDeleteTextures(1, &tex);
y = 0;
for (size = TEX_WIDTH; size > 0; size /= 2) {
pass = pass && piglit_probe_rect_rgb(0, y, size, size, green);
y += size + 5;
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
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;
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
static float red[] = {1.0, 0.0, 0.0, 0.0};
static float green[] = {0.0, 1.0, 0.0, 0.0};
static float blue[] = {0.0, 0.0, 1.0, 0.0};
/* whole window gray -- none should be visible */
glClearColor(0.5, 0.5, 0.5, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
/* Clear stencil to 0, which will be drawn green */
glClearStencil(0);
glClear(GL_STENCIL_BUFFER_BIT);
/* quad at 10, 10 that will be drawn blue. */
glEnable(GL_SCISSOR_TEST);
glScissor(10, 10, 10, 10);
glClearStencil(1);
glClear(GL_STENCIL_BUFFER_BIT);
/* 0-sized quad at 10, 30 that shouldn't be drawn (red) */
glScissor(10, 30, 0, 0);
glClearStencil(2);
glClear(GL_STENCIL_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_STENCIL_TEST);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
/* First quad -- stencil == 0 gets green */
glStencilFunc(GL_EQUAL, 0, ~0);
glColor4fv(green);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
/* Second quad -- stencil == 1 gets blue */
glStencilFunc(GL_EQUAL, 1, ~0);
glColor4fv(blue);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
/* Last quad -- stencil == 2 gets red (shouldn't occur!) */
glStencilFunc(GL_EQUAL, 2, ~0);
glColor4fv(red);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
pass &= piglit_probe_rect_rgb(0, 0, piglit_width, 10, green);
pass &= piglit_probe_rect_rgb(0, 10, 10, 10, green);
pass &= piglit_probe_rect_rgb(10, 10, 10, 10, blue);
pass &= piglit_probe_rect_rgb(20, 10, piglit_width-20, 10, green);
pass &= piglit_probe_rect_rgb(0, 20, piglit_width, piglit_height - 20,
green);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
int i;
static float red[] = {1.0, 0.0, 0.0, 0.0};
static float green[] = {0.0, 1.0, 0.0, 0.0};
static float blue[] = {0.0, 0.0, 1.0, 0.0};
static float square[100];
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
/* whole window gray -- none should be visible */
glClearColor(0.5, 0.5, 0.5, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
/* Clear stencil to 0, which will be drawn red */
glClearStencil(0);
glClear(GL_STENCIL_BUFFER_BIT);
/* quad at 10, 10 that will be drawn green. */
for (i = 0; i < 100; i++)
square[i] = 1.0;
glRasterPos2i(10, 10);
glDrawPixels(10, 10, GL_STENCIL_INDEX, GL_FLOAT, square);
/* quad at 30, 10 that will be drawn blue. */
for (i = 0; i < 100; i++)
square[i] = 2.0;
glRasterPos2i(30, 10);
glDrawPixels(10, 10, GL_STENCIL_INDEX, GL_FLOAT, square);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_STENCIL_TEST);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
/* First quad -- stencil == 0 gets red */
glStencilFunc(GL_EQUAL, 0, ~0);
glColor4fv(red);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
/* Second quad -- stencil == 1 gets green */
glStencilFunc(GL_EQUAL, 1, ~0);
glColor4fv(green);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
/* Last quad -- stencil == 2 gets blue */
glStencilFunc(GL_EQUAL, 2, ~0);
glColor4fv(blue);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
assert(glGetError() == 0);
pass &= piglit_probe_rect_rgb(0, 0, piglit_width, 10, red);
pass &= piglit_probe_rect_rgb(0, 10, 10, 10, red);
pass &= piglit_probe_rect_rgb(10, 10, 10, 10, green);
pass &= piglit_probe_rect_rgb(20, 10, 10, 10, red);
pass &= piglit_probe_rect_rgb(30, 10, 10, 10, blue);
pass &= piglit_probe_rect_rgb(40, 10, piglit_width-40, 10, red);
pass &= piglit_probe_rect_rgb(0, 20, piglit_width, piglit_height - 20,
red);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
enum piglit_result
piglit_display(void)
{
GLint max_components;
int max_varyings, row, col;
int max_xfb_varyings = 0;
GLint max_xfb_components;
GLboolean pass = GL_TRUE, warned = GL_FALSE;
GLuint vs, fs;
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glGetIntegerv(GL_MAX_VARYING_FLOATS, &max_components);
max_varyings = max_components / 4;
printf("GL_MAX_VARYING_FLOATS = %i\n", max_components);
if (max_varyings > MAX_VARYING) {
printf("test not designed to handle >%d varying vec4s.\n"
"(implementation reports %d components)\n",
max_components, MAX_VARYING);
max_varyings = MAX_VARYING;
warned = GL_TRUE;
}
glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,
&max_xfb_components);
max_xfb_varyings = MIN2(max_xfb_components / 4, max_varyings);
printf("GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = %i\n",
max_xfb_components);
vs = get_vs(max_varyings);
fs = get_fs(max_varyings);
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
for (row = 0; row < max_xfb_varyings; row++) {
pass = draw(vs, fs, row + 1, max_xfb_varyings) && pass;
}
for (row = 0; row < max_varyings; row++) {
for (col = 0; col < max_varyings - row; col++) {
GLboolean ok;
float green[3] = {0.0, 1.0, 0.0};
ok = piglit_probe_rect_rgb(coord_from_index(col),
coord_from_index(row),
10, 10,
green);
if (!ok) {
printf(" Failure with %d vec4 varyings"
" captured and offset %d\n",
row + 1, col);
pass = GL_FALSE;
break;
}
}
}
piglit_present_results();
if (!pass)
return PIGLIT_FAIL;
if (warned)
return PIGLIT_WARN;
else
return PIGLIT_PASS;
}
/**
* Common code for framebuffer and FBO tests.
*/
static GLboolean
test_srgb(void)
{
GLboolean pass = GL_TRUE;
GLboolean srgb_capable;
float green[] = {0, 0.3, 0, 0};
float expected_green[4];
float expected_blend[4];
/*
* Note: the window-system framebuffer may or may not be sRGB capable.
* But the user-created FBO should be sRGB capable.
*/
glGetBooleanv(GL_FRAMEBUFFER_SRGB_CAPABLE_EXT, &srgb_capable);
glDisable(GL_BLEND);
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_FRAMEBUFFER_SRGB_EXT);
glColor4fv(green);
/*
* First square: draw green square without sRGB and no blending
*/
piglit_draw_rect(0, 0, 20, 20);
/*
* Second square: draw a green square with sRGB enabled and no blending
*/
glEnable(GL_FRAMEBUFFER_SRGB_EXT);
piglit_draw_rect(20, 0, 20, 20);
/*
* Third square: draw green square, then blend/add another on top of it
*/
glEnable(GL_FRAMEBUFFER_SRGB_EXT);
piglit_draw_rect(40, 0, 20, 20);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
piglit_draw_rect(40, 0, 20, 20);
glDisable(GL_BLEND);
glDisable(GL_FRAMEBUFFER_SRGB_EXT);
/*
* Check first square.
*/
if (!piglit_probe_rect_rgb(0, 0, 20, 20, green))
pass = GL_FALSE;
/* check pixel path */
glEnable(GL_FRAMEBUFFER_SRGB_EXT);
if (!piglit_probe_rect_rgb(0, 0, 20, 20, green))
pass = GL_FALSE;
glDisable(GL_FRAMEBUFFER_SRGB_EXT);
/*
* Check second square
*/
memcpy(expected_green, green, sizeof(float) * 4);
if (srgb_capable)
expected_green[1] = piglit_linear_to_srgb(green[1]);
if (!piglit_probe_rect_rgb(20, 0, 20, 20, expected_green))
pass = GL_FALSE;
/* check it doesn't affect the pixel path */
glEnable(GL_FRAMEBUFFER_SRGB_EXT);
if (!piglit_probe_rect_rgb(20, 0, 20, 20, expected_green))
pass = GL_FALSE;
glDisable(GL_FRAMEBUFFER_SRGB_EXT);
/*
* Check third square
*/
memcpy(expected_blend, green, sizeof(float) * 4);
if (srgb_capable)
expected_blend[1] = piglit_linear_to_srgb(green[1] * 2.0);
else
expected_blend[1] = green[1] * 2.0;
if (!piglit_probe_rect_rgb(40, 0, 20, 20, expected_blend))
pass = GL_FALSE;
return pass;
}
static GLboolean test_layer_drawing(int start_x, int start_y, float *expected)
{
return piglit_probe_rect_rgb(start_x, start_y, BUF_WIDTH, BUF_HEIGHT,
expected);
}
enum piglit_result
test_clearing(void)
{
static const GLfloat purple[] = {1.0, 0.0, 1.0};
static const GLfloat blue[] = {0.0, 0.0, 1.0};
static const GLfloat green[] = {0.0, 1.0, 0.0};
GLenum err;
GLboolean pass = GL_TRUE;
while (glGetError() != GL_NO_ERROR)
;
/* Front buffer. */
glDrawBuffer(GL_FRONT);
glClearBufferfv(GL_COLOR, 0, purple);
err = glGetError();
if (err) {
printf("%s: glClearBufferfv(GL_FRONT) generated error 0x%x.\n", Prog, err);
return PIGLIT_FAIL;
}
glReadBuffer(GL_FRONT);
if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, purple)) {
printf(" from glClearBufferfv(GL_FRONT) failed.\n");
pass = GL_FALSE;
}
/* Back buffer. */
glDrawBuffer(GL_BACK);
glClearBufferfv(GL_COLOR, 0, blue);
err = glGetError();
if (err) {
printf("%s: glClearBufferfv(GL_BACK) generated error 0x%x.\n", Prog, err);
return PIGLIT_FAIL;
}
glReadBuffer(GL_BACK);
if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, blue)) {
printf(" from glClearBufferfv(GL_BACK) failed.\n");
pass = GL_FALSE;
}
/* Front and back buffer. */
glDrawBuffer(GL_FRONT_AND_BACK);
glClearBufferfv(GL_COLOR, 0, green);
err = glGetError();
if (err) {
printf("%s: glClearBufferfv(GL_FRONT_AND_BACK) generated error 0x%x.\n", Prog, err);
return PIGLIT_FAIL;
}
glReadBuffer(GL_FRONT);
if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, green)) {
printf(" the front buffer from glClearBufferfv(GL_FRONT_AND_BACK) failed.\n");
pass = GL_FALSE;
}
glReadBuffer(GL_BACK);
if (!piglit_probe_rect_rgb(0, 0, piglit_width, piglit_height, green)) {
printf(" the back buffer from glClearBufferfv(GL_FRONT_AND_BACK) failed.\n");
pass = GL_FALSE;
}
/* Depth & Stencil */
glClearBufferfi(GL_DEPTH_STENCIL, 0, 0.5, 3);
err = glGetError();
if (err) {
printf("%s: glClearBufferfi() generated error 0x%x.\n", Prog, err);
return PIGLIT_FAIL;
}
if (!piglit_probe_rect_depth(0, 0, piglit_width, piglit_height, 0.5)) {
printf(" from glClearBufferfi() failed.\n");
pass = GL_FALSE;
}
if (!piglit_probe_rect_stencil(0, 0, piglit_width, piglit_height, 3)) {
printf(" from glClearBufferfi() failed.\n");
pass = GL_FALSE;
}
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static enum piglit_result
run_multisample_test(struct texture_format *src_format,
struct texture_format *dst_format)
{
bool pass = true;
int fbo_width, fbo_height;
GLuint fbo, rb, src_tex, dst_tex, res_tex;
static const GLfloat verts[] = {
0.0, 0.0,
0.0, 1.0,
1.0, 1.0,
1.0, 1.0,
1.0, 0.0,
0.0, 0.0
};
/* Upload the source, destination, and expected result */
src_tex = piglit_multisample_texture(GL_TEXTURE_2D_MULTISAMPLE, 0,
src_format->internal_format,
TEX_SIZE, TEX_SIZE, 1, samples,
src_format->format,
src_format->data_type, src_data);
dst_tex = piglit_multisample_texture(GL_TEXTURE_2D_MULTISAMPLE, 0,
dst_format->internal_format,
TEX_SIZE, TEX_SIZE, 1, samples,
dst_format->format,
dst_format->data_type, dst_data);
res_tex = piglit_multisample_texture(GL_TEXTURE_2D_MULTISAMPLE, 0,
dst_format->internal_format,
TEX_SIZE, TEX_SIZE, 1, samples,
dst_format->format,
dst_format->data_type, res_data);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* If any of these are zero, but there was no error, then it must
* not be renderable, so we just skip without even reporting the
* subtest.
*/
if ((src_tex == 0 || dst_tex == 0 || res_tex == 0) && pass)
return PIGLIT_SKIP;
glCopyImageSubData(src_tex, GL_TEXTURE_2D_MULTISAMPLE, 0,
TEX_SIZE / 4, TEX_SIZE / 4, 0,
dst_tex, GL_TEXTURE_2D_MULTISAMPLE, 0,
TEX_SIZE / 4, TEX_SIZE / 4, 0,
TEX_SIZE / 2, TEX_SIZE / 2, 1);
pass &= piglit_check_gl_error(GL_NO_ERROR);
glCopyImageSubData(dst_tex, GL_TEXTURE_2D_MULTISAMPLE, 0,
0, TEX_SIZE / 2, 0,
dst_tex, GL_TEXTURE_2D_MULTISAMPLE, 0,
TEX_SIZE / 2, 0, 0,
TEX_SIZE / 2, TEX_SIZE / 2, 1);
pass &= piglit_check_gl_error(GL_NO_ERROR);
if (piglit_automatic) {
fbo_width = TEX_SIZE;
fbo_height = TEX_SIZE;
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glGenRenderbuffers(1, &rb);
glBindRenderbuffer(GL_RENDERBUFFER, rb);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA,
fbo_width, fbo_height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, rb);
} else {
fbo_width = piglit_width;
fbo_height = piglit_height;
glBindFramebuffer(GL_FRAMEBUFFER, piglit_winsys_fbo);
}
pass &= piglit_check_gl_error(GL_NO_ERROR);
glViewport(0, 0, fbo_width, fbo_height);
glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
/* Now we use a comparison shader to check to see if the
* destination matches the expected result.
*/
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, dst_tex);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, res_tex);
load_compare_program(dst_format);
pass &= piglit_check_gl_error(GL_NO_ERROR);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, verts);
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisableVertexAttribArray(0);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* If the destination texture matches the expected result, we
* should get green. If not, we get red and this test fails.
*/
pass &= piglit_probe_rect_rgb(0, 0, fbo_width, fbo_height, green);
glDeleteTextures(1, &src_tex);
glDeleteTextures(1, &dst_tex);
glDeleteTextures(1, &res_tex);
if (!piglit_automatic)
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
static GLboolean
srgb_tex_test(int srgb_format)
{
GLboolean pass = GL_TRUE;
float green[] = {0, 0.3, 0.0, 0};
float expected_green[4];
float expected_srgb_green[4];
GLuint tex;
GLboolean have_decode;
have_decode = piglit_is_extension_supported("GL_EXT_texture_sRGB_decode");
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
fill_level(0, green);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
piglit_draw_rect_tex(0, 0, 20, 20, 0, 0, 1, 1);
if (have_decode) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT,
GL_SKIP_DECODE_EXT);
piglit_draw_rect_tex(20, 0, 20, 20, 0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT,
GL_DECODE_EXT);
piglit_draw_rect_tex(40, 0, 20, 20, 0, 0, 1, 1);
}
memcpy(expected_green, green, sizeof(float) * 4);
memcpy(expected_srgb_green, green, sizeof(float) * 4);
expected_srgb_green[1] = nonlinear_to_linear(255.0*green[1]);
if (!piglit_probe_rect_rgb(0, 0, 20, 20, expected_srgb_green))
pass = GL_FALSE;
if (have_decode) {
if (!piglit_probe_rect_rgb(20, 0, 20, 20, expected_green))
pass = GL_FALSE;
if (!piglit_probe_rect_rgb(40, 0, 20, 20, expected_srgb_green))
pass = GL_FALSE;
}
glDeleteTextures(1, &tex);
piglit_present_results();
return pass;
}
static GLboolean
test_mipmap_drawing(int start_x, int start_y, int dim, const float *expected)
{
return piglit_probe_rect_rgb(start_x, start_y, dim, dim, expected);
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
int x, y;
GLuint tex, fb;
float blue[] = {1, 0, 0, 0};
float green[] = {0, 1, 0, 0};
bool draw_green;
float *draw_colors[] = {blue, green};
float w_screen = 2.0f * TEX_WIDTH / piglit_width;
float h_screen = 2.0f * TEX_HEIGHT / piglit_height;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
TEX_WIDTH, TEX_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);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
assert(glGetError() == 0);
assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) ==
GL_FRAMEBUFFER_COMPLETE_EXT);
draw_green = true;
for (y = 0; y <= piglit_height - TEX_HEIGHT; y += TEX_HEIGHT) {
float y_screen = -1.0 + 2.0 * ((float)y / piglit_height);
for (x = 0; x <= piglit_width - TEX_WIDTH; x += TEX_WIDTH) {
float x_screen = -1.0 + 2.0 * ((float)x / piglit_width);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glDisable(GL_TEXTURE_2D);
glColor4fv(draw_colors[draw_green]);
piglit_draw_rect(-1, -1, 2, 2);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_2D);
piglit_draw_rect_tex(x_screen, y_screen,
w_screen, h_screen,
0, 0,
1, 1);
draw_green = !draw_green;
}
/* Make it a checkerboard. */
draw_green = !draw_green;
}
glDeleteFramebuffersEXT(1, &fb);
glDeleteTextures(1, &tex);
draw_green = true;
for (y = 0; y <= piglit_height - TEX_HEIGHT; y += TEX_HEIGHT) {
for (x = 0; x <= piglit_width - TEX_WIDTH; x += TEX_WIDTH) {
float *expected = draw_colors[draw_green];
pass = pass && piglit_probe_rect_rgb(x, y,
TEX_WIDTH,
TEX_HEIGHT,
expected);
draw_green = !draw_green;
}
draw_green = !draw_green;
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
