int
__glXDispSwap_GetPolygonStipple(__GLXclientState * cl, GLbyte * pc)
{
GLboolean lsbFirst;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLubyte answerBuffer[200];
char *answer;
xGLXSingleReply reply = { 0, };
__GLX_DECLARE_SWAP_VARIABLES;
REQUEST_FIXED_SIZE(xGLXSingleReq, 4);
__GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
lsbFirst = *(GLboolean *) (pc + 0);
glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
__GLX_GET_ANSWER_BUFFER(answer, cl, 128, 1);
__glXClearErrorOccured();
glGetPolygonStipple((GLubyte *) answer);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SWAP_REPLY_HEADER();
__GLX_SEND_HEADER();
}
else {
__GLX_BEGIN_REPLY(128);
__GLX_SWAP_REPLY_HEADER();
__GLX_SEND_HEADER();
__GLX_SEND_BYTE_ARRAY(128);
}
return Success;
}
enum piglit_result
test_polygon_stip(void *null)
{
int use_unpack = 0;
int use_pack = 0;
GLuint unpack_pb[1];
GLuint pack_pb[1];
GLubyte t1[32 * 32 / 8];
GLubyte t2[32 * 32 / 8];
GLubyte *pbo_mem = NULL;
int i, j;
GLfloat white[3] = { 1.0, 1.0, 1.0 };
GLfloat black[3] = { 0.0, 0.0, 0.0 };
GLfloat buf[WINSIZE * WINSIZE * 3];
bool pass = true;
GLfloat expected[WINSIZE * WINSIZE * 3];
GLfloat tolerance[4];
piglit_compute_probe_tolerance(GL_RGB, &tolerance[0]);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
for (use_unpack = 0; use_unpack < 2; use_unpack++) {
for (use_pack = 0; use_pack < 2; use_pack++) {
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
if (use_unpack) {
glGenBuffersARB(1, unpack_pb);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
unpack_pb[0]);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
32 * 32 / 8, NULL,
GL_STREAM_DRAW);
pbo_mem = (GLubyte *) glMapBufferARB(
GL_PIXEL_UNPACK_BUFFER_ARB,
GL_WRITE_ONLY);
}
else {
pbo_mem = t1;
}
/* Fill in the stipple pattern */
for (i = 0; i < 32 * 32 / 8; i++) {
pbo_mem[i] = 0xAA; /* Checkerboard */
}
if (use_unpack) {
glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
glPolygonStipple(NULL);
}
else {
glPolygonStipple(pbo_mem);
}
/* Read back the stipple pattern */
if (use_pack) {
glGenBuffersARB(1, pack_pb);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
pack_pb[0]);
glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB,
32 * 32 / 8, NULL,
GL_STREAM_DRAW);
glGetPolygonStipple(NULL);
pbo_mem = (GLubyte *) glMapBufferARB(
GL_PIXEL_PACK_BUFFER_ARB,
GL_READ_ONLY);
}
else {
glGetPolygonStipple(t2);
pbo_mem = t2;
}
for (i = 0; i < 32 * 32 / 8; i++) {
if (pbo_mem[i] != 0xAA) {
REPORT_FAILURE("glGetPolygonStipple failed");
return PIGLIT_FAIL;
}
}
if (use_unpack) {
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
glDeleteBuffersARB(1, unpack_pb);
}
if (use_pack) {
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
glDeleteBuffersARB(1, pack_pb);
}
glEnable(GL_POLYGON_STIPPLE);
glColor4f(1.0, 1.0, 1.0, 0.0);
glBegin(GL_POLYGON);
glVertex2f(0, 0);
glVertex2f(10, 0);
glVertex2f(10, 10);
glVertex2f(0, 10);
glEnd();
glDisable(GL_POLYGON_STIPPLE);
/* Check the result */
glReadPixels(0, 0, WINSIZE, WINSIZE, GL_RGB, GL_FLOAT, buf);
for (j = 0; j < WINSIZE; j++) {
for (i = 0; i < WINSIZE; i++) {
int idx = (j * WINSIZE + i) * 3;
if (!(i & 1) && i < 10 && j < 10) {
expected[idx + 0] = white[0];
expected[idx + 1] = white[1];
expected[idx + 2] = white[2];
}
else {
expected[idx + 0] = black[0];
expected[idx + 1] = black[1];
expected[idx + 2] = black[2];
}
}
}
pass &= piglit_compare_images_color(0, 0, WINSIZE,
WINSIZE, 3,
tolerance,
expected, buf);
}
}
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
M(void, glGetPolygonStipple, jobject mask) {
glGetPolygonStipple(BUFF(GLubyte, mask));
}
