void GL::Texture::copyImage1D(TextureTarget target, GLint level, InternalFormat internalFormat,
GLint x, GLint y,
GLsizei width, GLint border)
{
glCopyTexImage1D(GLenum(target), level, GLint(internalFormat),
x, y,
width, border);
}
void Texture::copyImage1D( GLint x, GLint y, GLsizei width )
{
KVS_ASSERT( m_target == GL_TEXTURE_1D );
KVS_ASSERT( this->isBound() );
const GLint level = 0; // level-of-detail number
const GLint border = 0; // border width (0 or 1)
KVS_GL_CALL( glCopyTexImage1D( m_target, level, m_internal_format, x, y, width, border ) );
}
void __glXDisp_CopyTexImage1D(GLbyte *pc)
{
glCopyTexImage1D(
*(GLenum *)(pc + 0),
*(GLint *)(pc + 4),
*(GLenum *)(pc + 8),
*(GLint *)(pc + 12),
*(GLint *)(pc + 16),
*(GLsizei *)(pc + 20),
*(GLint *)(pc + 24)
);
}
void CTexture::InitCopy(int x, int y, int nWidth, int nHeight, bool bClamp)
{
Cleanup();
m_nType = (nHeight == 1) ? GL_TEXTURE_1D : GL_TEXTURE_2D;
glGenTextures(1, &m_nID);
Bind();
glTexParameteri(m_nType, GL_TEXTURE_WRAP_S, bClamp ? GL_CLAMP : GL_REPEAT);
glTexParameteri(m_nType, GL_TEXTURE_WRAP_T, bClamp ? GL_CLAMP : GL_REPEAT);
glTexParameteri(m_nType, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(m_nType, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
switch(m_nType)
{
case GL_TEXTURE_1D:
glCopyTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, x, y, nWidth, 0);
break;
case GL_TEXTURE_2D:
glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, x, y, nWidth, nHeight, 0);
break;
}
}
/**
* 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;
}
// For GLX, we implement wglBindTexARB() as a copy operation.
// We copy the pbuffer image to the currently bound texture.
// If there's any rendering to the pbuffer before the wglReleaseTexImage()
// call, the results are undefined (and permitted by the extension spec).
//
// The spec says that glTexImage and glCopyTexImage calls which effect
// the pbuffer/texture should not be allowed, but we do not enforce that.
//
// The spec says that when a pbuffer is released from the texture that
// the contents do not have to be preserved. But that's what will happen
// since we're copying here.
bool
bindTexImage(Drawable *pBuffer, int iBuffer) {
GLint readBufSave;
GLint width, height;
assert(pBuffer->pbuffer);
// Save the current drawing surface and bind the pbuffer surface
GLXDrawable prevDrawable = glXGetCurrentDrawable();
GLXContext prevContext = glXGetCurrentContext();
GlxDrawable *glxPBuffer = static_cast<GlxDrawable *>(pBuffer);
glXMakeCurrent(display, glxPBuffer->drawable, prevContext);
glGetIntegerv(GL_READ_BUFFER, &readBufSave);
assert(iBuffer == GL_FRONT_LEFT ||
iBuffer == GL_BACK_LEFT ||
iBuffer == GL_FRONT_RIGHT ||
iBuffer == GL_BACK_RIGHT ||
iBuffer == GL_AUX0);
// set src buffer
glReadBuffer(iBuffer);
// Just copy image from pbuffer to texture
switch (pBuffer->pbInfo.texTarget) {
case GL_TEXTURE_1D:
glGetTexLevelParameteriv(GL_TEXTURE_1D, pBuffer->mipmapLevel,
GL_TEXTURE_WIDTH, &width);
if (width == pBuffer->width) {
// replace existing texture
glCopyTexSubImage1D(GL_TEXTURE_1D,
pBuffer->mipmapLevel,
0, // xoffset
0, 0, // x, y
pBuffer->width);
} else {
// define initial texture
glCopyTexImage1D(GL_TEXTURE_1D,
pBuffer->mipmapLevel,
pBuffer->pbInfo.texFormat,
0, 0, // x, y
pBuffer->width, 0);
}
break;
case GL_TEXTURE_2D:
glGetTexLevelParameteriv(GL_TEXTURE_2D, pBuffer->mipmapLevel,
GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(GL_TEXTURE_2D, pBuffer->mipmapLevel,
GL_TEXTURE_HEIGHT, &height);
if (width == pBuffer->width && height == pBuffer->height) {
// replace existing texture
glCopyTexSubImage2D(GL_TEXTURE_2D,
pBuffer->mipmapLevel,
0, 0, // xoffset, yoffset
0, 0, // x, y
pBuffer->width, pBuffer->height);
} else {
// define initial texture
glCopyTexImage2D(GL_TEXTURE_2D,
pBuffer->mipmapLevel,
pBuffer->pbInfo.texFormat,
0, 0, // x, y
pBuffer->width, pBuffer->height, 0);
}
break;
case GL_TEXTURE_CUBE_MAP:
{
const GLenum target =
GL_TEXTURE_CUBE_MAP_POSITIVE_X + pBuffer->cubeFace;
glGetTexLevelParameteriv(target, pBuffer->mipmapLevel,
GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(target, pBuffer->mipmapLevel,
GL_TEXTURE_HEIGHT, &height);
if (width == pBuffer->width && height == pBuffer->height) {
// replace existing texture
glCopyTexSubImage2D(target,
pBuffer->mipmapLevel,
0, 0, // xoffset, yoffset
0, 0, // x, y
pBuffer->width, pBuffer->height);
} else {
// define new texture
glCopyTexImage2D(target,
pBuffer->mipmapLevel,
pBuffer->pbInfo.texFormat,
0, 0, // x, y
pBuffer->width, pBuffer->height, 0);
}
}
break;
default:
; // no op
}
// restore
glReadBuffer(readBufSave);
// rebind previous drawing surface
glXMakeCurrent(display, prevDrawable, prevContext);
return true;
}
/** Test target params to glTexImage functions */
static GLboolean
test_targets(void)
{
/* all of these should generate GL_INVALID_ENUM */
glTexImage1D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 0, GL_RGBA, GL_FLOAT, NULL);
if (!verify_error("glTexImage1D", GL_INVALID_ENUM))
return GL_FALSE;
glTexImage2D(GL_TEXTURE_3D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_FLOAT, NULL);
if (!verify_error("glTexImage2D", GL_INVALID_ENUM))
return GL_FALSE;
glTexImage3D(GL_TEXTURE_1D, 0, GL_RGBA, 16, 16, 16, 0, GL_RGBA, GL_FLOAT, NULL);
if (!verify_error("glTexImage3D", GL_INVALID_ENUM))
return GL_FALSE;
glTexSubImage1D(GL_TEXTURE_2D, 0, 6, 10, GL_RGBA, GL_FLOAT, NULL);
if (!verify_error("glTexSubImage1D", GL_INVALID_ENUM))
return GL_FALSE;
glTexSubImage1D(GL_PROXY_TEXTURE_1D, 0, 6, 10, GL_RGBA, GL_FLOAT, NULL);
if (!verify_error("glTexSubImage1D", GL_INVALID_ENUM))
return GL_FALSE;
glTexSubImage2D(GL_PROXY_TEXTURE_2D, 0, 6, 6, 10, 10, GL_RGBA, GL_FLOAT, NULL);
if (!verify_error("glTexSubImage1D", GL_INVALID_ENUM))
return GL_FALSE;
glTexSubImage3D(GL_PROXY_TEXTURE_2D, 0, 6, 6, 6, 10, 10, 10, GL_RGBA, GL_FLOAT, NULL);
if (!verify_error("glTexSubImage3D", GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexImage1D(GL_PROXY_TEXTURE_1D, 0, GL_RGBA, 4, 4, 16, 0);
if (!verify_error("glCopyTexImage1D", GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, 4, 4, 16, 16, 0);
if (!verify_error("glCopyTexImage2D", GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexImage2D(GL_TEXTURE_1D, 0, GL_RGBA, 4, 4, 16, 16, 0);
if (!verify_error("glCopyTexImage2D", GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexSubImage1D(GL_PROXY_TEXTURE_1D, 0, 4, 4, 6, 10);
if (!verify_error("glCopyTexSubImage1D", GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexSubImage2D(GL_PROXY_TEXTURE_2D, 0, 4, 4, 6, 6, 10, 10);
if (!verify_error("glCopyTexSubImage2D", GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexSubImage3D(GL_PROXY_TEXTURE_3D, 0, 4, 4, 4, 6, 6, 10, 10);
if (!verify_error("glCopyTexSubImage2D", GL_INVALID_ENUM))
return GL_FALSE;
return GL_TRUE;
}
M(void, glCopyTexImage1D, jint target, jint level, jint internalformat, jint x, jint y, jint width, jint border) {
glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
PIGLIT_GL_TEST_CONFIG_END
/** Test target params to glTexImage functions */
static GLboolean
test_targets(void)
{
/* all of these should generate GL_INVALID_ENUM */
glTexImage1D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 0, GL_RGBA, GL_FLOAT, NULL);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glTexImage2D(GL_TEXTURE_3D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_FLOAT, NULL);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glTexImage3D(GL_TEXTURE_1D, 0, GL_RGBA, 16, 16, 16, 0, GL_RGBA, GL_FLOAT, NULL);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glTexSubImage1D(GL_TEXTURE_2D, 0, 6, 10, GL_RGBA, GL_FLOAT, NULL);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glTexSubImage1D(GL_PROXY_TEXTURE_1D, 0, 6, 10, GL_RGBA, GL_FLOAT, NULL);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glTexSubImage2D(GL_PROXY_TEXTURE_2D, 0, 6, 6, 10, 10, GL_RGBA, GL_FLOAT, NULL);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glTexSubImage3D(GL_PROXY_TEXTURE_2D, 0, 6, 6, 6, 10, 10, 10, GL_RGBA, GL_FLOAT, NULL);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexImage1D(GL_PROXY_TEXTURE_1D, 0, GL_RGBA, 4, 4, 16, 0);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, 4, 4, 16, 16, 0);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexImage2D(GL_TEXTURE_1D, 0, GL_RGBA, 4, 4, 16, 16, 0);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexSubImage1D(GL_PROXY_TEXTURE_1D, 0, 4, 4, 6, 10);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexSubImage2D(GL_PROXY_TEXTURE_2D, 0, 4, 4, 6, 6, 10, 10);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
glCopyTexSubImage3D(GL_PROXY_TEXTURE_3D, 0, 4, 4, 4, 6, 6, 10, 10);
if (!piglit_check_gl_error(GL_INVALID_ENUM))
return GL_FALSE;
return GL_TRUE;
}
void gl4es_glCopyMultiTexImage1D(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {
text(glCopyTexImage1D(target, level, internalformat, x, y, width, border));
}
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);
}
/////////////////////////////////////////////////////////
// Render
//
void GEMglCopyTexImage1D :: render(GemState *state) {
glCopyTexImage1D (target, level, internalFormat, x, y, width, border);
}
