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); }