diff options
Diffstat (limited to 'progs/tests/getprocaddress.c')
| -rw-r--r-- | progs/tests/getprocaddress.c | 3741 |
1 files changed, 0 insertions, 3741 deletions
diff --git a/progs/tests/getprocaddress.c b/progs/tests/getprocaddress.c deleted file mode 100644 index f7903d2bf88..00000000000 --- a/progs/tests/getprocaddress.c +++ /dev/null @@ -1,3741 +0,0 @@ -/* - * Copyright (C) 1999-2002 Brian Paul All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -/* - * Test that glXGetProcAddress works. - */ - -#define GLX_GLXEXT_PROTOTYPES - -#include <X11/Xlib.h> -#include <X11/Xutil.h> -#include <GL/gl.h> -#include <GL/glx.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <math.h> - - -typedef void (*generic_func)(); - -#define EQUAL(X, Y) (fabs((X) - (Y)) < 0.001) - -/* This macro simplifies the task of querying an extension function - * pointer and checking to see whether it resolved. - */ -#define DECLARE_GLFUNC_PTR(name,type) \ - type name = (type) glXGetProcAddressARB((const GLubyte *) "gl" #name) - -/******************************************************************** - * Generic helper functions used by the test functions. - */ - -static void CheckGLError(int line, const char *file, const char *function) -{ - int errorCode; - glFinish(); - errorCode = glGetError(); - if (errorCode == GL_NO_ERROR) return; - while (errorCode != GL_NO_ERROR) { - fprintf(stderr, "OpenGL error 0x%x (%s) at line %d of file %s in function %s()\n", - errorCode, - errorCode == GL_INVALID_VALUE? "GL_INVALID_VALUE": - errorCode == GL_INVALID_ENUM? "GL_INVALID_ENUM": - errorCode == GL_INVALID_OPERATION? "GL_INVALID_OPERATION": - errorCode == GL_STACK_OVERFLOW? "GL_STACK_OVERFLOW": - errorCode == GL_STACK_UNDERFLOW? "GL_STACK_UNDERFLOW": - errorCode == GL_OUT_OF_MEMORY? "GL_OUT_OF_MEMORY": - "unknown", - line, file, function); - errorCode = glGetError(); - } - fflush(stderr); -} - -static GLboolean -compare_bytes(const char *errorLabel, GLuint expectedSize, - const GLubyte *expectedData, GLuint actualSize, const GLubyte *actualData) -{ - int i; - - if (expectedSize == actualSize && - memcmp(expectedData, actualData, actualSize) == 0) { - /* All is well */ - return GL_TRUE; - } - - /* Trouble; we don't match. Print out why. */ - fprintf(stderr, "%s: actual data is not as expected\n", errorLabel); - for (i = 0; i <= 1; i++) { - const GLubyte *ptr; - int size; - char *label; - int j; - - switch(i) { - case 0: - label = "expected"; - size = expectedSize; - ptr = expectedData; - break; - case 1: - label = " actual"; - size = actualSize; - ptr = actualData; - break; - } - - fprintf(stderr, " %s: size %d: {", label, size); - for (j = 0; j < size; j++) { - fprintf(stderr, "%s0x%02x", j > 0 ? ", " : "", ptr[j]); - } - fprintf(stderr, "}\n"); - } - - /* We fail if the data is unexpected. */ - return GL_FALSE; -} - - -static GLboolean -compare_ints(const char *errorLabel, GLuint expectedSize, - const GLint *expectedData, GLuint actualSize, const GLint *actualData) -{ - int i; - - if (expectedSize == actualSize && - memcmp(expectedData, actualData, actualSize*sizeof(*expectedData)) == 0) { - /* All is well */ - return GL_TRUE; - } - - /* Trouble; we don't match. Print out why. */ - fprintf(stderr, "%s: actual data is not as expected\n", errorLabel); - for (i = 0; i <= 1; i++) { - const GLint *ptr; - int size; - char *label; - int j; - - switch(i) { - case 0: - label = "expected"; - size = expectedSize; - ptr = expectedData; - break; - case 1: - label = " actual"; - size = actualSize; - ptr = actualData; - break; - } - - fprintf(stderr, " %s: size %d: {", label, size); - for (j = 0; j < size; j++) { - fprintf(stderr, "%s%d", j > 0 ? ", " : "", ptr[j]); - } - fprintf(stderr, "}\n"); - } - - /* We fail if the data is unexpected. */ - return GL_FALSE; -} - -#define MAX_CONVERTED_VALUES 4 -static GLboolean -compare_shorts_to_ints(const char *errorLabel, GLuint expectedSize, - const GLshort *expectedData, GLuint actualSize, const GLint *actualData) -{ - int i; - GLint convertedValues[MAX_CONVERTED_VALUES]; - - if (expectedSize > MAX_CONVERTED_VALUES) { - fprintf(stderr, "%s: too much data [need %d values, have %d values]\n", - errorLabel, expectedSize, MAX_CONVERTED_VALUES); - return GL_FALSE; - } - - for (i = 0; i < expectedSize; i++) { - convertedValues[i] = (GLint) expectedData[i]; - } - - return compare_ints(errorLabel, expectedSize, convertedValues, - actualSize, actualData); -} - -static GLboolean -compare_floats(const char *errorLabel, GLuint expectedSize, - const GLfloat *expectedData, GLuint actualSize, const GLfloat *actualData) -{ - int i; - - if (expectedSize == actualSize && - memcmp(expectedData, actualData, actualSize*sizeof(*expectedData)) == 0) { - /* All is well */ - return GL_TRUE; - } - - /* Trouble; we don't match. Print out why. */ - fprintf(stderr, "%s: actual data is not as expected\n", errorLabel); - for (i = 0; i <= 1; i++) { - const GLfloat *ptr; - int size; - char *label; - int j; - - switch(i) { - case 0: - label = "expected"; - size = expectedSize; - ptr = expectedData; - break; - case 1: - label = " actual"; - size = actualSize; - ptr = actualData; - break; - } - - fprintf(stderr, " %s: size %d: {", label, size); - for (j = 0; j < size; j++) { - fprintf(stderr, "%s%f", j > 0 ? ", " : "", ptr[j]); - } - fprintf(stderr, "}\n"); - } - - /* We fail if the data is unexpected. */ - return GL_FALSE; -} - -static GLboolean -compare_doubles(const char *errorLabel, GLuint expectedSize, - const GLdouble *expectedData, GLuint actualSize, const GLdouble *actualData) -{ - int i; - - if (expectedSize == actualSize || - memcmp(expectedData, actualData, actualSize*sizeof(*expectedData)) == 0) { - /* All is well */ - return GL_TRUE; - } - - /* Trouble; we don't match. Print out why. */ - fprintf(stderr, "%s: actual data is not as expected\n", errorLabel); - for (i = 0; i <= 1; i++) { - const GLdouble *ptr; - int size; - char *label; - int j; - - switch(i) { - case 0: - label = "expected"; - size = expectedSize; - ptr = expectedData; - break; - case 1: - label = " actual"; - size = actualSize; - ptr = actualData; - break; - } - - fprintf(stderr, " %s: size %d: {", label, size); - for (j = 0; j < size; j++) { - fprintf(stderr, "%s%f", j > 0 ? ", " : "", ptr[j]); - } - fprintf(stderr, "}\n"); - } - - /* We fail if the data is unexpected. */ - return GL_FALSE; -} - -/******************************************************************** - * Functions to assist with GL_ARB_texture_compressiong testing - */ - -static GLboolean -check_texture_format_supported(GLenum format) -{ - GLint numFormats; - GLint *formats; - register int i; - - glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, &numFormats); - formats = malloc(numFormats * sizeof(GLint)); - if (formats == NULL) { - fprintf(stderr, "check_texture_format_supported: could not allocate memory for %d GLints\n", - numFormats); - return GL_FALSE; - } - - memset(formats, 0, numFormats * sizeof(GLint)); - glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS_ARB, formats); - - for (i = 0; i < numFormats; i++) { - if (formats[i] == format) { - free(formats); - return GL_TRUE; - } - } - - /* We didn't find the format we were looking for. Give an error. */ -#define FORMAT_NAME(x) (\ - x == GL_COMPRESSED_RGB_FXT1_3DFX ? "GL_COMPRESSED_RGB_FXT1_3DFX" : \ - x == GL_COMPRESSED_RGBA_FXT1_3DFX ? "GL_COMPRESSED_RGBA_FXT1_3DFX" : \ - x == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ? "GL_COMPRESSED_RGB_S3TC_DXT1_EXT" : \ - x == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ? "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT" : \ - x == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ? "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT" : \ - x == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ? "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT" : \ - x == GL_RGB_S3TC ? "GL_RGB_S3TC" : \ - x == GL_RGB4_S3TC ? "GL_RGB4_S3TC" : \ - x == GL_RGBA_S3TC ? "GL_RGBA_S3TC" : \ - x == GL_RGBA4_S3TC ? "GL_RGBA4_S3TC" : \ - "unknown") - fprintf(stderr, "check_texture_format_supported: unsupported format 0x%04x [%s]\n", - format, FORMAT_NAME(format)); - fprintf(stderr, "supported formats:"); - for (i = 0; i < numFormats; i++) { - fprintf(stderr, " 0x%04x [%s]", formats[i], FORMAT_NAME(formats[i])); - } - fprintf(stderr, "\n"); - return GL_FALSE; -} - -/* This helper function compresses an RGBA texture and compares it - * against the expected compressed data. It returns GL_TRUE if all - * went as expected, or GL_FALSE in the case of error. - */ -static GLboolean -check_texture_compression(const char *message, GLenum dimension, - GLint width, GLint height, GLint depth, const GLubyte *texture, - int expectedCompressedSize, const GLubyte *expectedCompressedData) -{ - /* These are the data we query about the texture. */ - GLint isCompressed; - GLenum compressedFormat; - GLint compressedSize; - GLubyte *compressedData; - - /* We need this function pointer to operate. */ - DECLARE_GLFUNC_PTR(GetCompressedTexImageARB, PFNGLGETCOMPRESSEDTEXIMAGEARBPROC); - if (GetCompressedTexImageARB == NULL) { - fprintf(stderr, - "%s: could not query GetCompressedTexImageARB function pointer\n", - message); - return GL_FALSE; - } - - /* Verify that we actually have the GL_COMPRESSED_RGBA_S3TC_DXT3_EXT format available. */ - if (!check_texture_format_supported(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT)) { - return GL_FALSE; - } - - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - /* Set up the base image, requesting that the GL library compress it. */ - switch(dimension) { - case GL_TEXTURE_1D: - glTexImage1D(GL_TEXTURE_1D, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - width, 0, - GL_RGBA, GL_UNSIGNED_BYTE, texture); - break; - case GL_TEXTURE_2D: - glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - width, height, 0, - GL_RGBA, GL_UNSIGNED_BYTE, texture); - break; - case GL_TEXTURE_3D: - glTexImage3D(GL_TEXTURE_3D, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - width, height, depth, 0, - GL_RGBA, GL_UNSIGNED_BYTE, texture); - break; - default: - fprintf(stderr, "%s: unknown dimension 0x%04x.\n", message, dimension); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Make sure the texture is compressed, and pull it out if it is. */ - glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_COMPRESSED_ARB, - &isCompressed); - if (!isCompressed) { - fprintf(stderr, "%s: could not compress GL_COMPRESSED_RGBA_S3TC_DXT3_EXT texture\n", - message); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_INTERNAL_FORMAT, - (GLint *)&compressedFormat); - if (compressedFormat != GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) { - fprintf(stderr, "%s: got internal format 0x%04x, expected GL_COMPRESSED_RGBA_S3TC_DXT3_EXT [0x%04x]\n", - __FUNCTION__, compressedFormat, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, &compressedSize); - compressedData = malloc(compressedSize); - if (compressedData == NULL) { - fprintf(stderr, "%s: could not malloc %d bytes for compressed texture\n", - message, compressedSize); - return GL_FALSE; - } - memset(compressedData, 0, compressedSize); - (*GetCompressedTexImageARB)(dimension, 0, compressedData); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Compare it to the expected compressed data. The compare_bytes() - * call will print out diagnostics in the case of failure. - */ - if (!compare_bytes(message, - expectedCompressedSize, expectedCompressedData, - compressedSize, compressedData)) { - - free(compressedData); - return GL_FALSE; - } - - /* All done. Free our allocated data and return success. */ - free(compressedData); - return GL_TRUE; -} - -/* We'll use one function to exercise 1D, 2D, and 3D textures. */ - -/* The test function for compressed 3D texture images requires several - * different function pointers that have to be queried. This function - * gets all the function pointers it needs itself, and so is suitable for - * use to test any and all of the incorporated functions. - */ - -static GLboolean -exercise_CompressedTextures(GLenum dimension) -{ - /* Set up a basic (uncompressed) texture. We're doing a blue/yellow - * checkerboard. The 8x4/32-pixel board is well-suited to S3TC - * compression, which works on 4x4 blocks of pixels. - */ -#define B 0,0,255,255 -#define Y 255,255,0,255 -#define TEXTURE_WIDTH 16 -#define TEXTURE_HEIGHT 4 -#define TEXTURE_DEPTH 1 - static GLubyte texture[TEXTURE_WIDTH*TEXTURE_HEIGHT*TEXTURE_DEPTH*4] = { - B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, - B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, - Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, - Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, - }; -#undef B -#undef Y - GLubyte uncompressedTexture[TEXTURE_WIDTH*TEXTURE_HEIGHT*TEXTURE_DEPTH*4]; - - /* We'll use this as a texture subimage. */ -#define R 255,0,0,255 -#define G 0,255,0,255 -#define SUBTEXTURE_WIDTH 4 -#define SUBTEXTURE_HEIGHT 4 -#define SUBTEXTURE_DEPTH 1 - static GLubyte subtexture[SUBTEXTURE_WIDTH*SUBTEXTURE_HEIGHT*SUBTEXTURE_DEPTH*4] = { - G, G, R, R, - G, G, R, R, - R, R, G, G, - R, R, G, G, - }; -#undef R -#undef G - - /* These are the expected compressed textures. (In the case of - * a failed comparison, the test program will print out the - * actual compressed data in a format that can be directly used - * here, if desired.) The brave of heart can calculate the compression - * themselves based on the formulae described at: - * http://en.wikipedia.org/wiki/S3_Texture_Compression - * In a nutshell, each group of 16 bytes encodes a 4x4 texture block. - * The first eight bytes of each group are 4-bit alpha values - * for each of the 16 pixels in the texture block. - * The next four bytes in each group are LSB-first RGB565 colors; the - * first two bytes are identified as the color C0, and the next two - * are the color C1. (Two more colors C2 and C3 will be calculated - * from these, but do not appear in the compression data.) The - * last 4 bytes of the group are sixteen 2-bit indices that, for - * each of the 16 pixels in the texture block, select one of the - * colors C0, C1, C2, or C3. - * - * For example, our blue/yellow checkerboard is made up of - * four identical 4x4 blocks. Each of those blocks will - * be encoded as: eight bytes of 0xff (16 alpha values, each 0xf), - * C0 as the RGB565 color yellow (0xffe0), encoded LSB-first; - * C1 as the RGB565 color blue (0x001f), encoded LSB-first; - * and 4 bytes of 16 2-bit color indices reflecting the - * choice of color for each of the 16 pixels: - * 00, 00, 01, 01, = 0x05 - * 00, 00, 01, 01, = 0x05 - * 01, 01, 00, 00, = 0x50 - * 01, 01, 00, 00, = 0x50 - */ - static GLubyte compressedTexture[] = { - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50 - }; - - /* The similar calculations for the 4x4 subtexture are left - * as an exercise for the reader. - */ - static GLubyte compressedSubTexture[] = { - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0x00, 0xf8, 0xe0, 0x07, 0x05, 0x05, 0x50, 0x50, - }; - - /* The combined texture replaces the initial blue/yellow - * block with the green/red block. (I'd wanted to do - * the more interesting exercise of putting the - * green/red block in the middle of the blue/yellow - * texture, which is a non-trivial replacement, but - * the attempt produces GL_INVALID_OPERATION, showing - * that you can only replace whole blocks of - * subimages with S3TC.) The combined texture looks - * like: - * G G R R B B Y Y B B Y Y B B Y Y - * G G R R B B Y Y B B Y Y B B Y Y - * R R G G Y Y B B Y Y B B Y Y B B - * R R G G Y Y B B Y Y B B Y Y B B - * which encodes just like the green/red block followed - * by 3 copies of the yellow/blue block. - */ - static GLubyte compressedCombinedTexture[] = { - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0x00, 0xf8, 0xe0, 0x07, 0x05, 0x05, 0x50, 0x50, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50 - }; - - /* These are the data we query about the texture. */ - GLint queryIsCompressed; - GLenum queryCompressedFormat; - GLint queryCompressedSize; - GLubyte queryCompressedData[sizeof(compressedTexture)]; - - /* Query the function pointers we need. We actually won't need most - * of these (the "dimension" parameter dictates whether we're testing - * 1D, 2D, or 3D textures), but we'll have them all ready just in case. - */ - DECLARE_GLFUNC_PTR(GetCompressedTexImageARB, PFNGLGETCOMPRESSEDTEXIMAGEARBPROC); - DECLARE_GLFUNC_PTR(CompressedTexImage3DARB, PFNGLCOMPRESSEDTEXIMAGE3DARBPROC); - DECLARE_GLFUNC_PTR(CompressedTexSubImage3DARB, PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC); - DECLARE_GLFUNC_PTR(CompressedTexImage2DARB, PFNGLCOMPRESSEDTEXIMAGE2DARBPROC); - DECLARE_GLFUNC_PTR(CompressedTexSubImage2DARB, PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC); - DECLARE_GLFUNC_PTR(CompressedTexImage1DARB, PFNGLCOMPRESSEDTEXIMAGE1DARBPROC); - DECLARE_GLFUNC_PTR(CompressedTexSubImage1DARB, PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC); - - /* If the necessary functions are missing, we can't continue */ - if (GetCompressedTexImageARB == NULL) { - fprintf(stderr, "%s: GetCompressedTexImageARB function is missing\n", - __FUNCTION__); - return GL_FALSE; - } - switch (dimension) { - case GL_TEXTURE_1D: - if (CompressedTexImage1DARB == NULL || CompressedTexSubImage1DARB == NULL) { - fprintf(stderr, "%s: 1D compressed texture functions are missing\n", - __FUNCTION__); - return GL_FALSE; - }; - break; - case GL_TEXTURE_2D: - if (CompressedTexImage2DARB == NULL || CompressedTexSubImage2DARB == NULL) { - fprintf(stderr, "%s: 2D compressed texture functions are missing\n", - __FUNCTION__); - return GL_FALSE; - }; - break; - case GL_TEXTURE_3D: - if (CompressedTexImage3DARB == NULL || CompressedTexSubImage3DARB == NULL) { - fprintf(stderr, "%s: 3D compressed texture functions are missing\n", - __FUNCTION__); - return GL_FALSE; - }; - break; - default: - fprintf(stderr, "%s: unknown texture dimension 0x%04x passed.\n", - __FUNCTION__, dimension); - return GL_FALSE; - } - - /* Check the compression of our base texture image. */ - if (!check_texture_compression("texture compression", dimension, - TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH, texture, - sizeof(compressedTexture), compressedTexture)) { - - /* Something's wrong with texture compression. The function - * above will have printed an appropriate error. - */ - return GL_FALSE; - } - - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Do the same for our texture subimage */ - if (!check_texture_compression("subtexture compression", dimension, - SUBTEXTURE_WIDTH, SUBTEXTURE_HEIGHT, SUBTEXTURE_DEPTH, subtexture, - sizeof(compressedSubTexture), compressedSubTexture)) { - - /* Something's wrong with texture compression. The function - * above will have printed an appropriate error. - */ - return GL_FALSE; - } - - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Send the base compressed texture down to the hardware. */ - switch(dimension) { - case GL_TEXTURE_3D: - (*CompressedTexImage3DARB)(GL_TEXTURE_3D, 0, - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH, 0, - sizeof(compressedTexture), compressedTexture); - break; - - case GL_TEXTURE_2D: - (*CompressedTexImage2DARB)(GL_TEXTURE_2D, 0, - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, - sizeof(compressedTexture), compressedTexture); - break; - - case GL_TEXTURE_1D: - (*CompressedTexImage1DARB)(GL_TEXTURE_1D, 0, - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - TEXTURE_WIDTH, 0, - sizeof(compressedTexture), compressedTexture); - break; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* For grins, query it to make sure it is as expected. */ - glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_COMPRESSED_ARB, - &queryIsCompressed); - if (!queryIsCompressed) { - fprintf(stderr, "%s: compressed texture did not come back as compressed\n", - __FUNCTION__); - return GL_FALSE; - } - glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_INTERNAL_FORMAT, - (GLint *)&queryCompressedFormat); - if (queryCompressedFormat != GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) { - fprintf(stderr, "%s: got internal format 0x%04x, expected GL_COMPRESSED_RGBA_S3TC_DXT3_EXT [0x%04x]\n", - __FUNCTION__, queryCompressedFormat, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT); - return GL_FALSE; - } - glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, - &queryCompressedSize); - if (queryCompressedSize != sizeof(compressedTexture)) { - fprintf(stderr, "%s: compressed 3D texture changed size: expected %lu, actual %d\n", - __FUNCTION__, (unsigned long) sizeof(compressedTexture), queryCompressedSize); - return GL_FALSE; - } - (*GetCompressedTexImageARB)(dimension, 0, queryCompressedData); - if (!compare_bytes( - "exercise_CompressedTextures:doublechecking compressed texture", - sizeof(compressedTexture), compressedTexture, - queryCompressedSize, queryCompressedData)) { - return GL_FALSE; - } - - /* Now apply the texture subimage. The current implementation of - * S3TC requires that subimages be only applied to whole blocks. - */ - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - switch(dimension) { - case GL_TEXTURE_3D: - (*CompressedTexSubImage3DARB)(GL_TEXTURE_3D, 0, - 0, 0, 0, /* offsets */ - SUBTEXTURE_WIDTH, SUBTEXTURE_HEIGHT, SUBTEXTURE_DEPTH, - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - sizeof(compressedSubTexture), compressedSubTexture); - break; - case GL_TEXTURE_2D: - (*CompressedTexSubImage2DARB)(GL_TEXTURE_2D, 0, - 0, 0, /* offsets */ - SUBTEXTURE_WIDTH, SUBTEXTURE_HEIGHT, - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - sizeof(compressedSubTexture), compressedSubTexture); - break; - case GL_TEXTURE_1D: - (*CompressedTexSubImage2DARB)(GL_TEXTURE_2D, 0, - 0, 0, /* offsets */ - SUBTEXTURE_WIDTH, SUBTEXTURE_HEIGHT, - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - sizeof(compressedSubTexture), compressedSubTexture); - break; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query the compressed texture back now, and see that it - * is as expected. - */ - (*GetCompressedTexImageARB)(dimension, 0, queryCompressedData); - if (!compare_bytes("exercise_CompressedTextures:combined texture", - sizeof(compressedCombinedTexture), compressedCombinedTexture, - queryCompressedSize, queryCompressedData)) { - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Just for the exercise, uncompress the texture and pull it out. - * We don't check it because the compression is lossy, so it won't - * compare exactly to the source texture; we just - * want to exercise the code paths that convert it. - */ - glGetTexImage(dimension, 0, GL_RGBA, GL_UNSIGNED_BYTE, uncompressedTexture); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* If we survived this far, we pass. */ - return GL_TRUE; -} - -/************************************************************************** - * Functions to assist with GL_EXT_framebuffer_object and - * GL_EXT_framebuffer_blit testing. - */ - -#define FB_STATUS_NAME(x) (\ - x == GL_FRAMEBUFFER_COMPLETE_EXT ? "GL_FRAMEBUFFER_COMPLETE_EXT" : \ - x == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT" : \ - x == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT" : \ - x == GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT" : \ - x == GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT" : \ - x == GL_FRAMEBUFFER_UNSUPPORTED_EXT ? "GL_FRAMEBUFFER_UNSUPPORTED_EXT" : \ - x == GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT" : \ - x == GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT" : \ - x == GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT" : \ - "unknown") - -static GLboolean -exercise_framebuffer(void) -{ - GLuint framebufferID = 0; - GLuint renderbufferID = 0; - - /* Dimensions of the framebuffer and renderbuffers are arbitrary. - * Since they won't be shown on-screen, we can use whatever we want. - */ - const GLint Width = 100; - const GLint Height = 100; - - /* Every function we use will be referenced through function pointers. - * This will allow this test program to run on OpenGL implementations - * that *don't* implement these extensions (though the implementation - * used to compile them must have up-to-date header files). - */ - DECLARE_GLFUNC_PTR(GenFramebuffersEXT, PFNGLGENFRAMEBUFFERSEXTPROC); - DECLARE_GLFUNC_PTR(IsFramebufferEXT, PFNGLISFRAMEBUFFEREXTPROC); - DECLARE_GLFUNC_PTR(DeleteFramebuffersEXT, PFNGLDELETEFRAMEBUFFERSEXTPROC); - DECLARE_GLFUNC_PTR(BindFramebufferEXT, PFNGLBINDFRAMEBUFFEREXTPROC); - DECLARE_GLFUNC_PTR(GenRenderbuffersEXT, PFNGLGENRENDERBUFFERSEXTPROC); - DECLARE_GLFUNC_PTR(IsRenderbufferEXT, PFNGLISRENDERBUFFEREXTPROC); - DECLARE_GLFUNC_PTR(DeleteRenderbuffersEXT, PFNGLDELETERENDERBUFFERSEXTPROC); - DECLARE_GLFUNC_PTR(BindRenderbufferEXT, PFNGLBINDRENDERBUFFEREXTPROC); - DECLARE_GLFUNC_PTR(FramebufferRenderbufferEXT, PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC); - DECLARE_GLFUNC_PTR(RenderbufferStorageEXT, PFNGLRENDERBUFFERSTORAGEEXTPROC); - DECLARE_GLFUNC_PTR(CheckFramebufferStatusEXT, PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC); - - /* The BlitFramebuffer function comes from a different extension. - * It's possible for an implementation to implement all the above, - * but not BlitFramebuffer; so it's okay if this one comes back - * NULL, as we can still test the rest. - */ - DECLARE_GLFUNC_PTR(BlitFramebufferEXT, PFNGLBLITFRAMEBUFFEREXTPROC); - - /* We cannot test unless we have all the function pointers. */ - if ( - GenFramebuffersEXT == NULL || - IsFramebufferEXT == NULL || - DeleteFramebuffersEXT == NULL || - BindFramebufferEXT == NULL || - GenRenderbuffersEXT == NULL || - IsRenderbufferEXT == NULL || - DeleteRenderbuffersEXT == NULL || - BindRenderbufferEXT == NULL || - FramebufferRenderbufferEXT == NULL || - RenderbufferStorageEXT == NULL || - CheckFramebufferStatusEXT == NULL - ) { - fprintf(stderr, "%s: could not locate all framebuffer functions\n", - __FUNCTION__); - return GL_FALSE; - } - - /* Generate a framebuffer for us to play with. */ - (*GenFramebuffersEXT)(1, &framebufferID); - if (framebufferID == 0) { - fprintf(stderr, "%s: failed to generate a frame buffer ID.\n", - __FUNCTION__); - return GL_FALSE; - } - /* The generated name is not a framebuffer object until bound. */ - (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, framebufferID); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - if (!(*IsFramebufferEXT)(framebufferID)) { - fprintf(stderr, "%s: generated a frame buffer ID 0x%x that wasn't a framebuffer\n", - __FUNCTION__, framebufferID); - (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0); - (*DeleteFramebuffersEXT)(1, &framebufferID); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - { - GLint queriedFramebufferID; - glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &queriedFramebufferID); - if (queriedFramebufferID != framebufferID) { - fprintf(stderr, "%s: bound frame buffer 0x%x, but queried 0x%x\n", - __FUNCTION__, framebufferID, queriedFramebufferID); - (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0); - (*DeleteFramebuffersEXT)(1, &framebufferID); - return GL_FALSE; - } - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Create a color buffer to attach to the frame buffer object, so - * we can actually operate on it. We go through the same basic checks - * with the renderbuffer that we do with the framebuffer. - */ - (*GenRenderbuffersEXT)(1, &renderbufferID); - if (renderbufferID == 0) { - fprintf(stderr, "%s: could not generate a renderbuffer ID\n", - __FUNCTION__); - (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0); - (*DeleteFramebuffersEXT)(1, &framebufferID); - return GL_FALSE; - } - (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, renderbufferID); - if (!(*IsRenderbufferEXT)(renderbufferID)) { - fprintf(stderr, "%s: generated renderbuffer 0x%x is not a renderbuffer\n", - __FUNCTION__, renderbufferID); - (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, 0); - (*DeleteRenderbuffersEXT)(1, &renderbufferID); - (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0); - (*DeleteFramebuffersEXT)(1, &framebufferID); - return GL_FALSE; - } - { - GLint queriedRenderbufferID = 0; - glGetIntegerv(GL_RENDERBUFFER_BINDING_EXT, &queriedRenderbufferID); - if (renderbufferID != queriedRenderbufferID) { - fprintf(stderr, "%s: bound renderbuffer 0x%x, but got 0x%x\n", - __FUNCTION__, renderbufferID, queriedRenderbufferID); - (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, 0); - (*DeleteRenderbuffersEXT)(1, &renderbufferID); - (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0); - (*DeleteFramebuffersEXT)(1, &framebufferID); - return GL_FALSE; - } - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Add the renderbuffer as a color attachment to the current - * framebuffer (which is our generated framebuffer). - */ - (*FramebufferRenderbufferEXT)(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, - GL_RENDERBUFFER_EXT, renderbufferID); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* The renderbuffer will need some dimensions and storage space. */ - (*RenderbufferStorageEXT)(GL_RENDERBUFFER_EXT, GL_RGB, Width, Height); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* That should be everything we need. If we set up to draw and to - * read from our color attachment, we should be "framebuffer complete", - * meaning the framebuffer is ready to go. - */ - glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT); - glReadBuffer(GL_COLOR_ATTACHMENT1_EXT); - { - GLenum status = (*CheckFramebufferStatusEXT)(GL_FRAMEBUFFER_EXT); - if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { - fprintf(stderr, "%s: framebuffer not complete; status = %s [0x%x]\n", - __FUNCTION__, FB_STATUS_NAME(status), status); - glReadBuffer(0); - glDrawBuffer(0); - (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, 0); - (*DeleteRenderbuffersEXT)(1, &renderbufferID); - (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0); - (*DeleteFramebuffersEXT)(1, &framebufferID); - return GL_FALSE; - } - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Define the contents of the frame buffer */ - glClearColor(0.5, 0.5, 0.5, 0.0); - glClear(GL_COLOR_BUFFER_BIT); - - /* If the GL_EXT_framebuffer_blit is supported, attempt a framebuffer - * blit from (5,5)-(10,10) to (90,90)-(95,95). This is *not* an - * error if framebuffer_blit is *not* supported (as we can still - * effectively test the other functions). - */ - if (BlitFramebufferEXT != NULL) { - (*BlitFramebufferEXT)(5, 5, 10, 10, 90, 90, 95, 95, - GL_COLOR_BUFFER_BIT, GL_NEAREST); - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* We could now test to see whether the framebuffer had the desired - * contents. As this is just a touch test, we'll leave that for now. - * Clean up and go home. - */ - glReadBuffer(0); - glDrawBuffer(0); - (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, 0); - (*DeleteRenderbuffersEXT)(1, &renderbufferID); - (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0); - (*DeleteFramebuffersEXT)(1, &framebufferID); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - return GL_TRUE; -} - -/************************************************************************** - * Functions to assist with GL_ARB_shader_objects testing. - */ - -static void -print_info_log(const char *message, GLhandleARB object) -{ - DECLARE_GLFUNC_PTR(GetObjectParameterivARB, PFNGLGETOBJECTPARAMETERIVARBPROC); - DECLARE_GLFUNC_PTR(GetInfoLogARB, PFNGLGETINFOLOGARBPROC); - int logLength, queryLength; - char *log; - - if (GetObjectParameterivARB == NULL) { - fprintf(stderr, "%s: could not get GetObjectParameterivARB address\n", - message); - return; - } - if (GetInfoLogARB == NULL) { - fprintf(stderr, "%s: could not get GetInfoLogARB address\n", - message); - return; - } - - (*GetObjectParameterivARB)(object, GL_OBJECT_INFO_LOG_LENGTH_ARB, - &logLength); - if (logLength == 0) { - fprintf(stderr, "%s: info log length is 0\n", message); - return; - } - log = malloc(logLength); - if (log == NULL) { - fprintf(stderr, "%s: could not malloc %d bytes for info log\n", - message, logLength); - } - else { - (*GetInfoLogARB)(object, logLength, &queryLength, log); - fprintf(stderr, "%s: info log says '%s'\n", - message, log); - } - free(log); -} - -static GLboolean -exercise_uniform_start(const char *fragmentShaderText, const char *uniformName, - GLhandleARB *returnProgram, GLint *returnUniformLocation) -{ - DECLARE_GLFUNC_PTR(CreateShaderObjectARB, PFNGLCREATESHADEROBJECTARBPROC); - DECLARE_GLFUNC_PTR(ShaderSourceARB, PFNGLSHADERSOURCEARBPROC); - DECLARE_GLFUNC_PTR(CompileShaderARB, PFNGLCOMPILESHADERARBPROC); - DECLARE_GLFUNC_PTR(CreateProgramObjectARB, PFNGLCREATEPROGRAMOBJECTARBPROC); - DECLARE_GLFUNC_PTR(AttachObjectARB, PFNGLATTACHOBJECTARBPROC); - DECLARE_GLFUNC_PTR(LinkProgramARB, PFNGLLINKPROGRAMARBPROC); - DECLARE_GLFUNC_PTR(UseProgramObjectARB, PFNGLUSEPROGRAMOBJECTARBPROC); - DECLARE_GLFUNC_PTR(ValidateProgramARB, PFNGLVALIDATEPROGRAMARBPROC); - DECLARE_GLFUNC_PTR(GetUniformLocationARB, PFNGLGETUNIFORMLOCATIONARBPROC); - DECLARE_GLFUNC_PTR(DeleteObjectARB, PFNGLDELETEOBJECTARBPROC); - DECLARE_GLFUNC_PTR(GetObjectParameterivARB, PFNGLGETOBJECTPARAMETERIVARBPROC); - GLhandleARB fs, program; - GLint uniformLocation; - GLint shaderCompiled, programValidated; - - if (CreateShaderObjectARB == NULL || - ShaderSourceARB == NULL || - CompileShaderARB == NULL || - CreateProgramObjectARB == NULL || - AttachObjectARB == NULL || - LinkProgramARB == NULL || - UseProgramObjectARB == NULL || - ValidateProgramARB == NULL || - GetUniformLocationARB == NULL || - DeleteObjectARB == NULL || - GetObjectParameterivARB == NULL || - 0) { - return GL_FALSE; - } - - /* Create the trivial fragment shader and program. For safety - * we'll check to make sure they compile and link correctly. - */ - fs = (*CreateShaderObjectARB)(GL_FRAGMENT_SHADER_ARB); - (*ShaderSourceARB)(fs, 1, &fragmentShaderText, NULL); - (*CompileShaderARB)(fs); - (*GetObjectParameterivARB)(fs, GL_OBJECT_COMPILE_STATUS_ARB, - &shaderCompiled); - if (!shaderCompiled) { - print_info_log("shader did not compile", fs); - (*DeleteObjectARB)(fs); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - program = (*CreateProgramObjectARB)(); - (*AttachObjectARB)(program, fs); - (*LinkProgramARB)(program); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Make sure we're going to run successfully */ - (*ValidateProgramARB)(program); - (*GetObjectParameterivARB)(program, GL_OBJECT_VALIDATE_STATUS_ARB, - &programValidated); - if (!programValidated) {; - print_info_log("program did not validate", program); - (*DeleteObjectARB)(program); - (*DeleteObjectARB)(fs); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - return GL_FALSE; - } - - /* Put the program in place. We're not allowed to assign to uniform - * variables used by the program until the program is put into use. - */ - (*UseProgramObjectARB)(program); - - /* Once the shader is in place, we're free to delete it; this - * won't affect the copy that's part of the program. - */ - (*DeleteObjectARB)(fs); - - /* Find the location index of the uniform variable we declared; - * the caller will ned that to set the value. - */ - uniformLocation = (*GetUniformLocationARB)(program, uniformName); - if (uniformLocation == -1) { - fprintf(stderr, "%s: could not determine uniform location\n", - __FUNCTION__); - (*DeleteObjectARB)(program); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - return GL_FALSE; - } - - /* All done with what we're supposed to do - return the program - * handle and the uniform location to the caller. - */ - *returnProgram = program; - *returnUniformLocation = uniformLocation; - return GL_TRUE; -} - -static void -exercise_uniform_end(GLhandleARB program) -{ - DECLARE_GLFUNC_PTR(UseProgramObjectARB, PFNGLUSEPROGRAMOBJECTARBPROC); - DECLARE_GLFUNC_PTR(DeleteObjectARB, PFNGLDELETEOBJECTARBPROC); - if (UseProgramObjectARB == NULL || DeleteObjectARB == NULL) { - return; - } - - /* Turn off our program by setting the special value 0, and - * then delete the program object. - */ - (*UseProgramObjectARB)(0); - (*DeleteObjectARB)(program); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); -} - -/************************************************************************** - * Exercises for fences - */ -static GLboolean -exercise_fences(void) -{ - DECLARE_GLFUNC_PTR(DeleteFencesNV, PFNGLDELETEFENCESNVPROC); - DECLARE_GLFUNC_PTR(FinishFenceNV, PFNGLFINISHFENCENVPROC); - DECLARE_GLFUNC_PTR(GenFencesNV, PFNGLGENFENCESNVPROC); - DECLARE_GLFUNC_PTR(GetFenceivNV, PFNGLGETFENCEIVNVPROC); - DECLARE_GLFUNC_PTR(IsFenceNV, PFNGLISFENCENVPROC); - DECLARE_GLFUNC_PTR(SetFenceNV, PFNGLSETFENCENVPROC); - DECLARE_GLFUNC_PTR(TestFenceNV, PFNGLTESTFENCENVPROC); - GLuint fence; - GLint fenceStatus, fenceCondition; - int count; - - /* Make sure we have all the function pointers we need. */ - if (GenFencesNV == NULL || - SetFenceNV == NULL || - IsFenceNV == NULL || - GetFenceivNV == NULL || - TestFenceNV == NULL || - FinishFenceNV == NULL || - DeleteFencesNV == NULL) { - fprintf(stderr, "%s: don't have all the fence functions\n", - __FUNCTION__); - return GL_FALSE; - } - - /* Create and set a simple fence. */ - (*GenFencesNV)(1, &fence); - (*SetFenceNV)(fence, GL_ALL_COMPLETED_NV); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Make sure it reads as a fence. */ - if (!(*IsFenceNV)(fence)) { - fprintf(stderr, "%s: set fence is not a fence\n", __FUNCTION__); - (*DeleteFencesNV)(1, &fence); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Try to read back its current status and condition. */ - (*GetFenceivNV)(fence, GL_FENCE_CONDITION_NV, &fenceCondition); - if (fenceCondition != GL_ALL_COMPLETED_NV) { - fprintf(stderr, "%s: expected fence condition 0x%x, got 0x%x\n", - __FUNCTION__, GL_ALL_COMPLETED_NV, fenceCondition); - (*DeleteFencesNV)(1, &fence); - return GL_FALSE; - } - (*GetFenceivNV)(fence, GL_FENCE_STATUS_NV, &fenceStatus); - if (fenceStatus != GL_TRUE && fenceStatus != GL_FALSE) { - fprintf(stderr,"%s: fence status should be GL_TRUE or GL_FALSE, got 0x%x\n", - __FUNCTION__, fenceStatus); - (*DeleteFencesNV)(1, &fence); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Set the fence again, query its status, and wait for it to finish - * two different ways: once by looping on TestFence(), and a - * second time by a simple call to FinishFence(); - */ - (*SetFenceNV)(fence, GL_ALL_COMPLETED_NV); - glFlush(); - count = 1; - while (!(*TestFenceNV)(fence)) { - count++; - if (count == 0) { - break; - } - } - if (count == 0) { - fprintf(stderr, "%s: fence never returned true\n", __FUNCTION__); - (*DeleteFencesNV)(1, &fence); - return GL_FALSE; - } - (*SetFenceNV)(fence, GL_ALL_COMPLETED_NV); - (*FinishFenceNV)(fence); - if ((*TestFenceNV)(fence) != GL_TRUE) { - fprintf(stderr, "%s: finished fence does not have status GL_TRUE\n", - __FUNCTION__); - (*DeleteFencesNV)(1, &fence); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* All done. Delete the fence and return. */ - (*DeleteFencesNV)(1, &fence); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - return GL_TRUE; -} - -/************************************************************************** - * Exercises for buffer objects - */ -enum Map_Buffer_Usage{ Use_Map_Buffer, Use_Map_Buffer_Range}; -static GLboolean -exercise_buffer_objects(enum Map_Buffer_Usage usage) -{ -#define BUFFER_DATA_SIZE 1024 - GLuint bufferID; - GLint bufferMapped; - static GLubyte data[BUFFER_DATA_SIZE] = {0}; - float *dataPtr = NULL; - const char *extensions = (const char *) glGetString(GL_EXTENSIONS); - - /* Get the function pointers we need. These are from - * GL_ARB_vertex_buffer_object and are required in all - * cases. - */ - DECLARE_GLFUNC_PTR(GenBuffersARB, PFNGLGENBUFFERSARBPROC); - DECLARE_GLFUNC_PTR(BindBufferARB, PFNGLBINDBUFFERARBPROC); - DECLARE_GLFUNC_PTR(BufferDataARB, PFNGLBUFFERDATAARBPROC); - DECLARE_GLFUNC_PTR(MapBufferARB, PFNGLMAPBUFFERARBPROC); - DECLARE_GLFUNC_PTR(UnmapBufferARB, PFNGLUNMAPBUFFERARBPROC); - DECLARE_GLFUNC_PTR(DeleteBuffersARB, PFNGLDELETEBUFFERSARBPROC); - DECLARE_GLFUNC_PTR(GetBufferParameterivARB, PFNGLGETBUFFERPARAMETERIVARBPROC); - - /* These are from GL_ARB_map_buffer_range, and are optional - * unless we're given Use_Map_Buffer_Range. Note that they do *not* - * have the standard "ARB" suffixes; this is because the extension - * was introduced *after* a superset was standardized in OpenGL 3.0. - * (The extension really only exists to allow the functionality on - * devices that cannot implement a full OpenGL 3.0 driver.) - */ - DECLARE_GLFUNC_PTR(FlushMappedBufferRange, PFNGLFLUSHMAPPEDBUFFERRANGEPROC); - DECLARE_GLFUNC_PTR(MapBufferRange, PFNGLMAPBUFFERRANGEPROC); - - /* This is from APPLE_flush_buffer_range, and is optional even if - * we're given Use_Map_Buffer_Range. Test it before using it. - */ - DECLARE_GLFUNC_PTR(BufferParameteriAPPLE, PFNGLBUFFERPARAMETERIAPPLEPROC); - if (!strstr("GL_APPLE_flush_buffer_range", extensions)) { - BufferParameteriAPPLE = NULL; - } - - /* Make sure we have all the function pointers we need. */ - if (GenBuffersARB == NULL || - BindBufferARB == NULL || - BufferDataARB == NULL || - MapBufferARB == NULL || - UnmapBufferARB == NULL || - DeleteBuffersARB == NULL || - GetBufferParameterivARB == NULL) { - fprintf(stderr, "%s: missing basic MapBuffer functions\n", __FUNCTION__); - return GL_FALSE; - } - if (usage == Use_Map_Buffer_Range) { - if (FlushMappedBufferRange == NULL || MapBufferRange == NULL) { - fprintf(stderr, "%s: missing MapBufferRange functions\n", __FUNCTION__); - return GL_FALSE; - } - } - - /* Create and define a buffer */ - (*GenBuffersARB)(1, &bufferID); - (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, bufferID); - (*BufferDataARB)(GL_ARRAY_BUFFER_ARB, BUFFER_DATA_SIZE, data, - GL_DYNAMIC_DRAW_ARB); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* If we're using MapBufferRange, and if the BufferParameteriAPPLE - * function is present, use it before mapping. This particular - * use is a no-op, intended just to exercise the entry point. - */ - if (usage == Use_Map_Buffer_Range && BufferParameteriAPPLE != NULL) { - (*BufferParameteriAPPLE)(GL_ARRAY_BUFFER_ARB, - GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE); - } - - /* Map it, and make sure it's mapped. */ - switch(usage) { - case Use_Map_Buffer: - dataPtr = (float *) (*MapBufferARB)( - GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB); - break; - case Use_Map_Buffer_Range: - dataPtr = (float *)(*MapBufferRange)(GL_ARRAY_BUFFER_ARB, - 4, 16, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); - break; - } - if (dataPtr == NULL) { - fprintf(stderr, "%s: %s returned NULL\n", __FUNCTION__, - usage == Use_Map_Buffer ? "MapBuffer" : "MapBufferRange"); - (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, 0); - (*DeleteBuffersARB)(1, &bufferID); - return GL_FALSE; - } - (*GetBufferParameterivARB)(GL_ARRAY_BUFFER_ARB, GL_BUFFER_MAPPED_ARB, - &bufferMapped); - if (!bufferMapped) { - fprintf(stderr, "%s: buffer should be mapped but isn't\n", __FUNCTION__); - (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, 0); - (*DeleteBuffersARB)(1, &bufferID); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Write something to it, just to make sure we don't segfault. */ - *dataPtr = 1.5; - - /* Unmap to show we're finished with the buffer. Note that if we're - * using MapBufferRange, we first have to flush the range we modified. - */ - if (usage == Use_Map_Buffer_Range) { - (*FlushMappedBufferRange)(GL_ARRAY_BUFFER_ARB, 0, 16); - } - if (!(*UnmapBufferARB)(GL_ARRAY_BUFFER_ARB)) { - fprintf(stderr, "%s: UnmapBuffer failed\n", __FUNCTION__); - (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, 0); - (*DeleteBuffersARB)(1, &bufferID); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* All done. */ - (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, 0); - (*DeleteBuffersARB)(1, &bufferID); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - return GL_TRUE; - -#undef BUFFER_DATA_SIZE -} - -/************************************************************************** - * Exercises for occlusion query - */ -static GLboolean -exercise_occlusion_query(void) -{ - GLuint queryObject; - GLint queryReady; - GLuint querySampleCount; - GLint queryCurrent; - GLint queryCounterBits; - - /* Get the function pointers we need. These are from - * GL_ARB_vertex_buffer_object and are required in all - * cases. - */ - DECLARE_GLFUNC_PTR(GenQueriesARB, PFNGLGENQUERIESARBPROC); - DECLARE_GLFUNC_PTR(BeginQueryARB, PFNGLBEGINQUERYARBPROC); - DECLARE_GLFUNC_PTR(GetQueryivARB, PFNGLGETQUERYIVARBPROC); - DECLARE_GLFUNC_PTR(EndQueryARB, PFNGLENDQUERYARBPROC); - DECLARE_GLFUNC_PTR(IsQueryARB, PFNGLISQUERYARBPROC); - DECLARE_GLFUNC_PTR(GetQueryObjectivARB, PFNGLGETQUERYOBJECTIVARBPROC); - DECLARE_GLFUNC_PTR(GetQueryObjectuivARB, PFNGLGETQUERYOBJECTUIVARBPROC); - DECLARE_GLFUNC_PTR(DeleteQueriesARB, PFNGLDELETEQUERIESARBPROC); - - /* Make sure we have all the function pointers we need. */ - if (GenQueriesARB == NULL || - BeginQueryARB == NULL || - GetQueryivARB == NULL || - EndQueryARB == NULL || - IsQueryARB == NULL || - GetQueryObjectivARB == NULL || - GetQueryObjectuivARB == NULL || - DeleteQueriesARB == NULL) { - fprintf(stderr, "%s: don't have all the Query functions\n", __FUNCTION__); - return GL_FALSE; - } - - /* Create a query object, and start a query. */ - (*GenQueriesARB)(1, &queryObject); - (*BeginQueryARB)(GL_SAMPLES_PASSED_ARB, queryObject); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* While we're in the query, check the functions that are supposed - * to return which query we're in and how many bits of resolution - * we get. - */ - (*GetQueryivARB)(GL_SAMPLES_PASSED_ARB, GL_CURRENT_QUERY_ARB, &queryCurrent); - if (queryCurrent != queryObject) { - fprintf(stderr, "%s: current query 0x%x != set query 0x%x\n", - __FUNCTION__, queryCurrent, queryObject); - (*EndQueryARB)(GL_SAMPLES_PASSED_ARB); - (*DeleteQueriesARB)(1, &queryObject); - return GL_FALSE; - } - (*GetQueryivARB)(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB, - &queryCounterBits); - if (queryCounterBits < 1) { - fprintf(stderr, "%s: query counter bits is too small (%d)\n", - __FUNCTION__, queryCounterBits); - (*EndQueryARB)(GL_SAMPLES_PASSED_ARB); - (*DeleteQueriesARB)(1, &queryObject); - return GL_FALSE; - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Finish up the query. Since we didn't draw anything, the result - * should be 0 passed samples. - */ - (*EndQueryARB)(GL_SAMPLES_PASSED_ARB); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Routine existence test */ - if (!(*IsQueryARB)(queryObject)) { - fprintf(stderr, "%s: query object 0x%x fails existence test\n", - __FUNCTION__, queryObject); - (*DeleteQueriesARB)(1, &queryObject); - return GL_FALSE; - } - - /* Loop until the query is ready, then get back the result. We use - * the signed query for the boolean value of whether the result is - * available, but the unsigned query to actually pull the result; - * this is just to test both entrypoints, but in a real query you may - * need the extra bit of resolution. - */ - queryReady = GL_FALSE; - do { - (*GetQueryObjectivARB)(queryObject, GL_QUERY_RESULT_AVAILABLE_ARB, - &queryReady); - } while (!queryReady); - (*GetQueryObjectuivARB)(queryObject, GL_QUERY_RESULT_ARB, &querySampleCount); - (*DeleteQueriesARB)(1, &queryObject); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* If sample count isn't 0, something's funny. */ - if (querySampleCount > 0) { - fprintf(stderr, "%s: expected query result of 0, got %ud\n", - __FUNCTION__, querySampleCount); - return GL_FALSE; - } - - /* Here, all is well. */ - return GL_TRUE; -} - -/************************************************************************** - * The following functions are used to check that the named OpenGL function - * actually does what it's supposed to do. - * The naming of these functions is significant. The getprocaddress.py script - * scans this file and extracts these function names. - */ - -static GLboolean -test_WeightPointerARB(generic_func func) -{ - /* Assume we have at least 2 vertex units (or this extension makes - * no sense), and establish a set of 2-element vector weights. - * We use floats that can be represented exactly in binary - * floating point formats so we can compare correctly later. - * We also make sure the 0th entry matches the default weights, - * so we can restore the default easily. - */ -#define USE_VERTEX_UNITS 2 -#define USE_WEIGHT_INDEX 3 - static GLfloat weights[] = { - 1.0, 0.0, - 0.875, 0.125, - 0.75, 0.25, - 0.625, 0.375, - 0.5, 0.5, - 0.375, 0.625, - 0.25, 0.75, - 0.125, 0.875, - 0.0, 1.0, - }; - GLint numVertexUnits; - GLfloat *currentWeights; - int i; - int errorCount = 0; - - PFNGLWEIGHTPOINTERARBPROC WeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC) func; - - /* Make sure we have at least two vertex units */ - glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &numVertexUnits); - if (numVertexUnits < USE_VERTEX_UNITS) { - fprintf(stderr, "%s: need %d vertex units, got %d\n", - __FUNCTION__, USE_VERTEX_UNITS, numVertexUnits); - return GL_FALSE; - } - - /* Make sure we allocate enough room to query all the current weights */ - currentWeights = (GLfloat *)malloc(numVertexUnits * sizeof(GLfloat)); - if (currentWeights == NULL) { - fprintf(stderr, "%s: couldn't allocate room for %d floats\n", - __FUNCTION__, numVertexUnits); - return GL_FALSE; - } - - /* Set up the pointer, enable the state, and try to send down a - * weight vector (we'll arbitrarily send index 2). - */ - (*WeightPointerARB)(USE_VERTEX_UNITS, GL_FLOAT, 0, weights); - glEnableClientState(GL_WEIGHT_ARRAY_ARB); - glArrayElement(USE_WEIGHT_INDEX); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Verify that it changed the current state. */ - glGetFloatv(GL_CURRENT_WEIGHT_ARB, currentWeights); - for (i = 0; i < numVertexUnits; i++) { - if (i < USE_VERTEX_UNITS) { - /* This is one of the units we explicitly set. */ - if (currentWeights[i] != weights[USE_VERTEX_UNITS*USE_WEIGHT_INDEX + i]) { - fprintf(stderr, "%s: current weight at index %d is %f, should be %f\n", - __FUNCTION__, i, currentWeights[i], - weights[USE_VERTEX_UNITS*USE_WEIGHT_INDEX + i]); - errorCount++; - } - } - else { - /* All other weights should be 0. */ - if (currentWeights[i] != 0.0) { - fprintf(stderr, "%s: current weight at index %d is %f, should be %f\n", - __FUNCTION__, i, 0.0, - weights[USE_VERTEX_UNITS*USE_WEIGHT_INDEX + i]); - errorCount++; - } - } - } - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Restore the old state. We know the default set of weights is in - * index 0. - */ - glArrayElement(0); - glDisableClientState(GL_WEIGHT_ARRAY_ARB); - (*WeightPointerARB)(0, GL_FLOAT, 0, NULL); - free(currentWeights); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* We're fine if we didn't get any mismatches. */ - if (errorCount == 0) { - return GL_TRUE; - } - else { - return GL_FALSE; - } -} - -/* Wrappers on the exercise_occlusion_query function */ -static GLboolean -test_GenQueriesARB(generic_func func) -{ - (void) func; - return exercise_occlusion_query(); -} -static GLboolean -test_BeginQueryARB(generic_func func) -{ - (void) func; - return exercise_occlusion_query(); -} -static GLboolean -test_GetQueryivARB(generic_func func) -{ - (void) func; - return exercise_occlusion_query(); -} -static GLboolean -test_EndQueryARB(generic_func func) -{ - (void) func; - return exercise_occlusion_query(); -} -static GLboolean -test_IsQueryARB(generic_func func) -{ - (void) func; - return exercise_occlusion_query(); -} -static GLboolean -test_GetQueryObjectivARB(generic_func func) -{ - (void) func; - return exercise_occlusion_query(); -} -static GLboolean -test_GetQueryObjectuivARB(generic_func func) -{ - (void) func; - return exercise_occlusion_query(); -} -static GLboolean -test_DeleteQueriesARB(generic_func func) -{ - (void) func; - return exercise_occlusion_query(); -} - -/* Wrappers on the exercise_buffer_objects() function */ -static GLboolean -test_GenBuffersARB(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer); -} -static GLboolean -test_BindBufferARB(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer); -} -static GLboolean -test_BufferDataARB(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer); -} -static GLboolean -test_MapBufferARB(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer); -} -static GLboolean -test_UnmapBufferARB(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer); -} -static GLboolean -test_DeleteBuffersARB(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer); -} -static GLboolean -test_GetBufferParameterivARB(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer); -} -static GLboolean -test_FlushMappedBufferRange(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer_Range); -} -static GLboolean -test_MapBufferRange(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer_Range); -} -static GLboolean -test_BufferParameteriAPPLE(generic_func func) -{ - (void) func; - return exercise_buffer_objects(Use_Map_Buffer_Range); -} - -/* Wrappers on the exercise_framebuffer() function */ -static GLboolean -test_BindFramebufferEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_BindRenderbufferEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_CheckFramebufferStatusEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_DeleteFramebuffersEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_DeleteRenderbuffersEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_FramebufferRenderbufferEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_GenFramebuffersEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_GenRenderbuffersEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_IsFramebufferEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_IsRenderbufferEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_RenderbufferStorageEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} -static GLboolean -test_BlitFramebufferEXT(generic_func func) -{ - (void) func; - return exercise_framebuffer(); -} - -/* These are wrappers on the exercise_CompressedTextures function. - * Unfortunately, we cannot test the 1D counterparts, because the - * texture compressions available all support 2D and higher only. - */ -static GLboolean -test_CompressedTexImage2DARB(generic_func func) -{ - (void) func; - return exercise_CompressedTextures(GL_TEXTURE_2D); -} -static GLboolean -test_CompressedTexSubImage2DARB(generic_func func) -{ - (void) func; - return exercise_CompressedTextures(GL_TEXTURE_2D); -} -static GLboolean -test_CompressedTexImage3DARB(generic_func func) -{ - (void) func; - /*return exercise_CompressedTextures(GL_TEXTURE_3D);*/ - return GL_TRUE; -} -static GLboolean -test_CompressedTexSubImage3DARB(generic_func func) -{ - (void) func; - /*return exercise_CompressedTextures(GL_TEXTURE_3D);*/ - return GL_TRUE; -} -static GLboolean -test_GetCompressedTexImageARB(generic_func func) -{ - (void) func; - /*return exercise_CompressedTextures(GL_TEXTURE_3D);*/ - return GL_TRUE; -} - -/* Wrappers on exercise_fences(). */ -static GLboolean -test_DeleteFencesNV(generic_func func) -{ - (void) func; - return exercise_fences(); -} -static GLboolean -test_GenFencesNV(generic_func func) -{ - (void) func; - return exercise_fences(); -} -static GLboolean -test_SetFenceNV(generic_func func) -{ - (void) func; - return exercise_fences(); -} -static GLboolean -test_TestFenceNV(generic_func func) -{ - (void) func; - return exercise_fences(); -} -static GLboolean -test_FinishFenceNV(generic_func func) -{ - (void) func; - return exercise_fences(); -} -static GLboolean -test_GetFenceivNV(generic_func func) -{ - (void) func; - return exercise_fences(); -} -static GLboolean -test_IsFenceNV(generic_func func) -{ - (void) func; - return exercise_fences(); -} - -/* A bunch of glUniform*() tests */ -static GLboolean -test_Uniform1iv(generic_func func) -{ - PFNGLUNIFORM1IVARBPROC Uniform1ivARB = (PFNGLUNIFORM1IVARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform int uniformColor;" - "void main() {gl_FragColor.r = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLint uniform[1] = {1}; - GLint queriedUniform[1]; - - if (GetUniformivARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is an integer - * so we must set it using integer versions - * of the Uniform* functions. The "1" means we're setting - * one vector's worth of information. - */ - (*Uniform1ivARB)(uniformLocation, 1, uniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformivARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_ints(__FUNCTION__, 1, uniform, 1, queriedUniform); -} - -static GLboolean -test_Uniform1i(generic_func func) -{ - PFNGLUNIFORM1IARBPROC Uniform1iARB = (PFNGLUNIFORM1IARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform int uniformColor;" - "void main() {gl_FragColor.r = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLint uniform[1] = {1}; - GLint queriedUniform[4]; - - if (GetUniformivARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is an integer - * so we must set it using integer versions - * of the Uniform* functions. - */ - (*Uniform1iARB)(uniformLocation, uniform[0]); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformivARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_ints(__FUNCTION__, 1, uniform, 1, queriedUniform); -} - -static GLboolean -test_Uniform1fv(generic_func func) -{ - PFNGLUNIFORM1FVARBPROC Uniform1fvARB = (PFNGLUNIFORM1FVARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform float uniformColor;" - "void main() {gl_FragColor.r = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLfloat uniform[1] = {1.1}; - GLfloat queriedUniform[1]; - - if (GetUniformfvARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is a float - * so we must set it using float versions - * of the Uniform* functions. The "1" means we're setting - * one vector's worth of information. - */ - (*Uniform1fvARB)(uniformLocation, 1, uniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformfvARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_floats(__FUNCTION__, 1, uniform, 1, queriedUniform); -} - -static GLboolean -test_Uniform1f(generic_func func) -{ - PFNGLUNIFORM1FARBPROC Uniform1fARB = (PFNGLUNIFORM1FARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform float uniformColor;" - "void main() {gl_FragColor.r = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLfloat uniform[1] = {1.1}; - GLfloat queriedUniform[1]; - - if (GetUniformfvARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is a float - * so we must set it using float versions - * of the Uniform* functions. - */ - (*Uniform1fARB)(uniformLocation, uniform[0]); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformfvARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_floats(__FUNCTION__, 1, uniform, 1, queriedUniform); -} - -static GLboolean -test_Uniform2iv(generic_func func) -{ - PFNGLUNIFORM2IVARBPROC Uniform2ivARB = (PFNGLUNIFORM2IVARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform ivec2 uniformColor;" - "void main() {gl_FragColor.rg = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLint uniform[2] = {1,2}; - GLint queriedUniform[2]; - - if (GetUniformivARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is an integer - * vector 2 (ivec2), so we must set it using integer versions - * of the Uniform* functions. The "1" means we're setting - * one vector's worth of information. - */ - (*Uniform2ivARB)(uniformLocation, 1, uniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformivARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_ints(__FUNCTION__, 2, uniform, 2, queriedUniform); -} - -static GLboolean -test_Uniform2i(generic_func func) -{ - PFNGLUNIFORM2IARBPROC Uniform2iARB = (PFNGLUNIFORM2IARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform ivec2 uniformColor;" - "void main() {gl_FragColor.rg = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLint uniform[2] = {1,2}; - GLint queriedUniform[4]; - - if (GetUniformivARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is an integer - * vector 2 (ivec2), so we must set it using integer versions - * of the Uniform* functions. - */ - (*Uniform2iARB)(uniformLocation, uniform[0], uniform[1]); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformivARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_ints(__FUNCTION__, 2, uniform, 2, queriedUniform); -} - -static GLboolean -test_Uniform2fv(generic_func func) -{ - PFNGLUNIFORM2FVARBPROC Uniform2fvARB = (PFNGLUNIFORM2FVARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform vec2 uniformColor;" - "void main() {gl_FragColor.rg = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLfloat uniform[2] = {1.1,2.2}; - GLfloat queriedUniform[2]; - - if (GetUniformfvARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is a float - * vector 2 (vec2), so we must set it using float versions - * of the Uniform* functions. The "1" means we're setting - * one vector's worth of information. - */ - (*Uniform2fvARB)(uniformLocation, 1, uniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformfvARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_floats(__FUNCTION__, 2, uniform, 2, queriedUniform); -} - -static GLboolean -test_Uniform2f(generic_func func) -{ - PFNGLUNIFORM2FARBPROC Uniform2fARB = (PFNGLUNIFORM2FARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform vec2 uniformColor;" - "void main() {gl_FragColor.rg = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLfloat uniform[2] = {1.1,2.2}; - GLfloat queriedUniform[2]; - - if (GetUniformfvARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is a float - * vector 2 (vec2), so we must set it using float versions - * of the Uniform* functions. - */ - (*Uniform2fARB)(uniformLocation, uniform[0], uniform[1]); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformfvARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_floats(__FUNCTION__, 2, uniform, 2, queriedUniform); -} - -static GLboolean -test_Uniform3iv(generic_func func) -{ - PFNGLUNIFORM3IVARBPROC Uniform3ivARB = (PFNGLUNIFORM3IVARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform ivec3 uniformColor;" - "void main() {gl_FragColor.rgb = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLint uniform[3] = {1,2,3}; - GLint queriedUniform[3]; - - if (GetUniformivARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is an integer - * vector 3 (ivec3), so we must set it using integer versions - * of the Uniform* functions. The "1" means we're setting - * one vector's worth of information. - */ - (*Uniform3ivARB)(uniformLocation, 1, uniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformivARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_ints(__FUNCTION__, 3, uniform, 3, queriedUniform); -} - -static GLboolean -test_Uniform3i(generic_func func) -{ - PFNGLUNIFORM3IARBPROC Uniform3iARB = (PFNGLUNIFORM3IARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform ivec3 uniformColor;" - "void main() {gl_FragColor.rgb = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLint uniform[3] = {1,2,3}; - GLint queriedUniform[4]; - - if (GetUniformivARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is an integer - * vector 3 (ivec3), so we must set it using integer versions - * of the Uniform* functions. - */ - (*Uniform3iARB)(uniformLocation, uniform[0], uniform[1], uniform[2]); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformivARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_ints(__FUNCTION__, 3, uniform, 3, queriedUniform); -} - -static GLboolean -test_Uniform3fv(generic_func func) -{ - PFNGLUNIFORM3FVARBPROC Uniform3fvARB = (PFNGLUNIFORM3FVARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform vec3 uniformColor;" - "void main() {gl_FragColor.rgb = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLfloat uniform[3] = {1.1,2.2,3.3}; - GLfloat queriedUniform[3]; - - if (GetUniformfvARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is a float - * vector 3 (vec3), so we must set it using float versions - * of the Uniform* functions. The "1" means we're setting - * one vector's worth of information. - */ - (*Uniform3fvARB)(uniformLocation, 1, uniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformfvARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_floats(__FUNCTION__, 3, uniform, 3, queriedUniform); -} - -static GLboolean -test_Uniform3f(generic_func func) -{ - PFNGLUNIFORM3FARBPROC Uniform3fARB = (PFNGLUNIFORM3FARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform vec3 uniformColor;" - "void main() {gl_FragColor.rgb = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLfloat uniform[3] = {1.1,2.2,3.3}; - GLfloat queriedUniform[3]; - - if (GetUniformfvARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is a float - * vector 3 (vec3), so we must set it using float versions - * of the Uniform* functions. - */ - (*Uniform3fARB)(uniformLocation, uniform[0], uniform[1], uniform[2]); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformfvARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_floats(__FUNCTION__, 3, uniform, 3, queriedUniform); -} - -static GLboolean -test_Uniform4iv(generic_func func) -{ - PFNGLUNIFORM4IVARBPROC Uniform4ivARB = (PFNGLUNIFORM4IVARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform ivec4 uniformColor; void main() {gl_FragColor = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLint uniform[4] = {1,2,3,4}; - GLint queriedUniform[4]; - - if (GetUniformivARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is an integer - * vector (ivec4), so we must set it using integer versions - * of the Uniform* functions. The "1" means we're setting - * one vector's worth of information. - */ - (*Uniform4ivARB)(uniformLocation, 1, uniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformivARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_ints(__FUNCTION__, 4, uniform, 4, queriedUniform); -} - -static GLboolean -test_Uniform4i(generic_func func) -{ - PFNGLUNIFORM4IARBPROC Uniform4iARB = (PFNGLUNIFORM4IARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform ivec4 uniformColor; void main() {gl_FragColor = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLint uniform[4] = {1,2,3,4}; - GLint queriedUniform[4]; - - if (GetUniformivARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is an integer - * vector (ivec4), so we must set it using integer versions - * of the Uniform* functions. - */ - (*Uniform4iARB)(uniformLocation, uniform[0], uniform[1], uniform[2], - uniform[3]); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformivARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_ints(__FUNCTION__, 4, uniform, 4, queriedUniform); -} - -static GLboolean -test_Uniform4fv(generic_func func) -{ - PFNGLUNIFORM4FVARBPROC Uniform4fvARB = (PFNGLUNIFORM4FVARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform vec4 uniformColor; void main() {gl_FragColor = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLfloat uniform[4] = {1.1,2.2,3.3,4.4}; - GLfloat queriedUniform[4]; - - if (GetUniformfvARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is a float - * vector (vec4), so we must set it using float versions - * of the Uniform* functions. The "1" means we're setting - * one vector's worth of information. - */ - (*Uniform4fvARB)(uniformLocation, 1, uniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformfvARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_floats(__FUNCTION__, 4, uniform, 4, queriedUniform); -} - -static GLboolean -test_Uniform4f(generic_func func) -{ - PFNGLUNIFORM4FARBPROC Uniform4fARB = (PFNGLUNIFORM4FARBPROC) func; - DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC); - - /* This is a trivial fragment shader that sets the color of the - * fragment to the uniform value passed in. - */ - static const char *fragmentShaderText = - "uniform vec4 uniformColor; void main() {gl_FragColor = uniformColor;}"; - static const char *uniformName = "uniformColor"; - - GLhandleARB program; - GLint uniformLocation; - const GLfloat uniform[4] = {1.1,2.2,3.3,4.4}; - GLfloat queriedUniform[4]; - - if (GetUniformfvARB == NULL) { - return GL_FALSE; - } - - /* Call a helper function to compile up the shader and give - * us back the validated program and uniform location. - * If it fails, something's wrong and we can't continue. - */ - if (!exercise_uniform_start(fragmentShaderText, uniformName, - &program, &uniformLocation)) { - return GL_FALSE; - } - - /* Set the value of the program uniform. Note that you must - * use a compatible type. Our uniform above is an integer - * vector (ivec4), so we must set it using integer versions - * of the Uniform* functions. - */ - (*Uniform4fARB)(uniformLocation, uniform[0], uniform[1], uniform[2], - uniform[3]); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Query it back */ - (*GetUniformfvARB)(program, uniformLocation, queriedUniform); - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - /* Clean up before we check to see whether it came back unscathed */ - exercise_uniform_end(program); - - /* Now check to see whether the uniform came back as expected. This - * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed. - */ - return compare_floats(__FUNCTION__, 4, uniform, 4, queriedUniform); -} - -static GLboolean -test_ActiveTextureARB(generic_func func) -{ - PFNGLACTIVETEXTUREARBPROC activeTexture = (PFNGLACTIVETEXTUREARBPROC) func; - GLint t; - GLboolean pass; - (*activeTexture)(GL_TEXTURE1_ARB); - glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &t); - pass = (t == GL_TEXTURE1_ARB); - (*activeTexture)(GL_TEXTURE0_ARB); /* restore default */ - return pass; -} - - -static GLboolean -test_SecondaryColor3fEXT(generic_func func) -{ - PFNGLSECONDARYCOLOR3FEXTPROC secColor3f = (PFNGLSECONDARYCOLOR3FEXTPROC) func; - GLfloat color[4]; - GLboolean pass; - (*secColor3f)(1.0, 1.0, 0.0); - glGetFloatv(GL_CURRENT_SECONDARY_COLOR_EXT, color); - pass = (color[0] == 1.0 && color[1] == 1.0 && color[2] == 0.0); - (*secColor3f)(0.0, 0.0, 0.0); /* restore default */ - return pass; -} - - -static GLboolean -test_ActiveStencilFaceEXT(generic_func func) -{ - PFNGLACTIVESTENCILFACEEXTPROC activeFace = (PFNGLACTIVESTENCILFACEEXTPROC) func; - GLint face; - GLboolean pass; - (*activeFace)(GL_BACK); - glGetIntegerv(GL_ACTIVE_STENCIL_FACE_EXT, &face); - pass = (face == GL_BACK); - (*activeFace)(GL_FRONT); /* restore default */ - return pass; -} - - -static GLboolean -test_VertexAttrib1fvARB(generic_func func) -{ - PFNGLVERTEXATTRIB1FVARBPROC vertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) func; - PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); - - const GLfloat v[1] = {25.0}; - const GLfloat def[1] = {0}; - GLfloat res[4]; - GLboolean pass; - (*vertexAttrib1fvARB)(6, v); - (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); - pass = (res[0] == 25.0 && res[1] == 0.0 && res[2] == 0.0 && res[3] == 1.0); - (*vertexAttrib1fvARB)(6, def); - return pass; -} - -static GLboolean -test_VertexAttrib1dvARB(generic_func func) -{ - PFNGLVERTEXATTRIB1DVARBPROC vertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC) func; - PFNGLGETVERTEXATTRIBDVARBPROC getVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvARB"); - - const GLdouble v[1] = {25.0}; - const GLdouble def[1] = {0}; - GLdouble res[4]; - GLboolean pass; - (*vertexAttrib1dvARB)(6, v); - (*getVertexAttribdvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); - pass = (res[0] == 25.0 && res[1] == 0.0 && res[2] == 0.0 && res[3] == 1.0); - (*vertexAttrib1dvARB)(6, def); - return pass; -} - -static GLboolean -test_VertexAttrib1svARB(generic_func func) -{ - PFNGLVERTEXATTRIB1SVARBPROC vertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC) func; - PFNGLGETVERTEXATTRIBIVARBPROC getVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivARB"); - - const GLshort v[1] = {25.0}; - const GLshort def[1] = {0}; - GLint res[4]; - GLboolean pass; - (*vertexAttrib1svARB)(6, v); - (*getVertexAttribivARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); - pass = (res[0] == 25 && res[1] == 0 && res[2] == 0 && res[3] == 1); - (*vertexAttrib1svARB)(6, def); - return pass; -} - -static GLboolean -test_VertexAttrib4NubvARB(generic_func func) -{ - PFNGLVERTEXATTRIB4NUBVARBPROC vertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) func; - PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); - - const GLubyte v[4] = {255, 0, 255, 0}; - const GLubyte def[4] = {0, 0, 0, 255}; - GLfloat res[4]; - GLboolean pass; - (*vertexAttrib4NubvARB)(6, v); - (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); - pass = (res[0] == 1.0 && res[1] == 0.0 && res[2] == 1.0 && res[3] == 0.0); - (*vertexAttrib4NubvARB)(6, def); - return pass; -} - - -static GLboolean -test_VertexAttrib4NuivARB(generic_func func) -{ - PFNGLVERTEXATTRIB4NUIVARBPROC vertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) func; - PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); - - const GLuint v[4] = {0xffffffff, 0, 0xffffffff, 0}; - const GLuint def[4] = {0, 0, 0, 0xffffffff}; - GLfloat res[4]; - GLboolean pass; - (*vertexAttrib4NuivARB)(6, v); - (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); - pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 0.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0)); - (*vertexAttrib4NuivARB)(6, def); - return pass; -} - - -static GLboolean -test_VertexAttrib4ivARB(generic_func func) -{ - PFNGLVERTEXATTRIB4IVARBPROC vertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) func; - PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); - - const GLint v[4] = {1, 2, -3, 4}; - const GLint def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - GLboolean pass; - (*vertexAttrib4ivARB)(6, v); - (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); - pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 2.0) && EQUAL(res[2], -3.0) && EQUAL(res[3], 4.0)); - (*vertexAttrib4ivARB)(6, def); - return pass; -} - - -static GLboolean -test_VertexAttrib4NsvARB(generic_func func) -{ - PFNGLVERTEXATTRIB4NSVARBPROC vertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) func; - PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); - - const GLshort v[4] = {0, 32767, 32767, 0}; - const GLshort def[4] = {0, 0, 0, 32767}; - GLfloat res[4]; - GLboolean pass; - (*vertexAttrib4NsvARB)(6, v); - (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); - pass = (EQUAL(res[0], 0.0) && EQUAL(res[1], 1.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0)); - (*vertexAttrib4NsvARB)(6, def); - return pass; -} - -static GLboolean -test_VertexAttrib4NusvARB(generic_func func) -{ - PFNGLVERTEXATTRIB4NUSVARBPROC vertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) func; - PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); - - const GLushort v[4] = {0xffff, 0, 0xffff, 0}; - const GLushort def[4] = {0, 0, 0, 0xffff}; - GLfloat res[4]; - GLboolean pass; - (*vertexAttrib4NusvARB)(6, v); - (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); - pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 0.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0)); - (*vertexAttrib4NusvARB)(6, def); - return pass; -} - -static GLboolean -test_VertexAttrib1sNV(generic_func func) -{ - PFNGLVERTEXATTRIB1SNVPROC vertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 0, 0, 1}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttrib1sNV)(6, v[0]); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib1sNV)(6, def[0]); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib1fNV(generic_func func) -{ - PFNGLVERTEXATTRIB1FNVPROC vertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 0.0, 0.0, 1.0}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttrib1fNV)(6, v[0]); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib1fNV)(6, def[0]); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib1dNV(generic_func func) -{ - PFNGLVERTEXATTRIB1DNVPROC vertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 0.0, 0.0, 1.0}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttrib1dNV)(6, v[0]); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib1dNV)(6, def[0]); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib2sNV(generic_func func) -{ - PFNGLVERTEXATTRIB2SNVPROC vertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 4, 0, 1}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttrib2sNV)(6, v[0], v[1]); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib2sNV)(6, def[0], def[1]); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib2fNV(generic_func func) -{ - PFNGLVERTEXATTRIB2FNVPROC vertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 4.25, 0.0, 1.0}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttrib2fNV)(6, v[0], v[1]); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib2fNV)(6, def[0], def[1]); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib2dNV(generic_func func) -{ - PFNGLVERTEXATTRIB2DNVPROC vertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 4.25, 0.0, 1.0}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttrib2dNV)(6, v[0], v[1]); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib2dNV)(6, def[0], def[1]); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib3sNV(generic_func func) -{ - PFNGLVERTEXATTRIB3SNVPROC vertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 4, 7, 1}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttrib3sNV)(6, v[0], v[1], v[2]); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib3sNV)(6, def[0], def[1], def[2]); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib3fNV(generic_func func) -{ - PFNGLVERTEXATTRIB3FNVPROC vertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 4.25, 7.125, 1.0}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttrib3fNV)(6, v[0], v[1], v[2]); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib3fNV)(6, def[0], def[1], def[2]); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib3dNV(generic_func func) -{ - PFNGLVERTEXATTRIB3DNVPROC vertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 4.25, 7.125, 1.0}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttrib3dNV)(6, v[0], v[1], v[2]); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib3dNV)(6, def[0], def[1], def[2]); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib4sNV(generic_func func) -{ - PFNGLVERTEXATTRIB4SNVPROC vertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 4, 7, 5}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttrib4sNV)(6, v[0], v[1], v[2], v[3]); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib4sNV)(6, def[0], def[1], def[2], def[3]); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib4fNV(generic_func func) -{ - PFNGLVERTEXATTRIB4FNVPROC vertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 4.25, 7.125, 5.0625}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttrib4fNV)(6, v[0], v[1], v[2], v[3]); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib4fNV)(6, def[0], def[1], def[2], def[3]); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib4dNV(generic_func func) -{ - PFNGLVERTEXATTRIB4DNVPROC vertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 4.25, 7.125, 5.0625}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttrib4dNV)(6, v[0], v[1], v[2], v[3]); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib4dNV)(6, def[0], def[1], def[2], def[3]); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib4ubNV(generic_func func) -{ - PFNGLVERTEXATTRIB4UBNVPROC vertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLubyte v[4] = {255, 0, 255, 0}; - const GLubyte def[4] = {0, 0, 0, 255}; - GLfloat res[4]; - /* There's no byte-value query; so we use the float-value query. - * Bytes are interpreted as steps between 0 and 1, so the - * expected float values will be 0.0 for byte value 0 and 1.0 for - * byte value 255. - */ - GLfloat expectedResults[4] = {1.0, 0.0, 1.0, 0.0}; - (*vertexAttrib4ubNV)(6, v[0], v[1], v[2], v[3]); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib4ubNV)(6, def[0], def[1], def[2], def[3]); - return compare_floats(__FUNCTION__, 4, expectedResults, 4, res); -} - -static GLboolean -test_VertexAttrib1fvNV(generic_func func) -{ - PFNGLVERTEXATTRIB1FVNVPROC vertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 0.0, 0.0, 1.0}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttrib1fvNV)(6, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib1fvNV)(6, def); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib1dvNV(generic_func func) -{ - PFNGLVERTEXATTRIB1DVNVPROC vertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 0.0, 0.0, 1.0}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttrib1dvNV)(6, v); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib1dvNV)(6, def); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib2svNV(generic_func func) -{ - PFNGLVERTEXATTRIB2SVNVPROC vertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 4, 0, 1}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttrib2svNV)(6, v); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib2svNV)(6, def); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib2fvNV(generic_func func) -{ - PFNGLVERTEXATTRIB2FVNVPROC vertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 4.25, 0.0, 1.0}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttrib2fvNV)(6, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib2fvNV)(6, def); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib2dvNV(generic_func func) -{ - PFNGLVERTEXATTRIB2DVNVPROC vertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 4.25, 0.0, 1.0}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttrib2dvNV)(6, v); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib2dvNV)(6, def); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib3svNV(generic_func func) -{ - PFNGLVERTEXATTRIB3SVNVPROC vertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 4, 7, 1}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttrib3svNV)(6, v); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib3svNV)(6, def); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib3fvNV(generic_func func) -{ - PFNGLVERTEXATTRIB3FVNVPROC vertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 4.25, 7.125, 1.0}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttrib3fvNV)(6, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib3fvNV)(6, def); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib3dvNV(generic_func func) -{ - PFNGLVERTEXATTRIB3DVNVPROC vertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 4.25, 7.125, 1.0}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttrib3dvNV)(6, v); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib3dvNV)(6, def); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib4svNV(generic_func func) -{ - PFNGLVERTEXATTRIB4SVNVPROC vertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 4, 7, 5}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttrib4svNV)(6, v); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib4svNV)(6, def); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib4fvNV(generic_func func) -{ - PFNGLVERTEXATTRIB4FVNVPROC vertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 4.25, 7.125, 5.0625}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttrib4fvNV)(6, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib4fvNV)(6, def); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib4dvNV(generic_func func) -{ - PFNGLVERTEXATTRIB4DVNVPROC vertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 4.25, 7.125, 5.0625}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttrib4dvNV)(6, v); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib4dvNV)(6, def); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttrib4ubvNV(generic_func func) -{ - PFNGLVERTEXATTRIB4UBVNVPROC vertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLubyte v[4] = {255, 0, 255, 0}; - const GLubyte def[4] = {0, 0, 0, 255}; - GLfloat res[4]; - /* There's no byte-value query; so we use the float-value query. - * Bytes are interpreted as steps between 0 and 1, so the - * expected float values will be 0.0 for byte value 0 and 1.0 for - * byte value 255. - */ - GLfloat expectedResults[4] = {1.0, 0.0, 1.0, 0.0}; - (*vertexAttrib4ubvNV)(6, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttrib4ubvNV)(6, def); - return compare_floats(__FUNCTION__, 4, expectedResults, 4, res); -} - -static GLboolean -test_VertexAttribs1fvNV(generic_func func) -{ - PFNGLVERTEXATTRIBS1FVNVPROC vertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 0.0, 0.0, 1.0}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttribs1fvNV)(6, 1, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs1fvNV)(6, 1, def); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs1dvNV(generic_func func) -{ - PFNGLVERTEXATTRIBS1DVNVPROC vertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 0.0, 0.0, 1.0}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttribs1dvNV)(6, 1, v); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs1dvNV)(6, 1, def); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs2svNV(generic_func func) -{ - PFNGLVERTEXATTRIBS2SVNVPROC vertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 4, 0, 1}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttribs2svNV)(6, 1, v); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs2svNV)(6, 1, def); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs2fvNV(generic_func func) -{ - PFNGLVERTEXATTRIBS2FVNVPROC vertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 4.25, 0.0, 1.0}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttribs2fvNV)(6, 1, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs2fvNV)(6, 1, def); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs2dvNV(generic_func func) -{ - PFNGLVERTEXATTRIBS2DVNVPROC vertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 4.25, 0.0, 1.0}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttribs2dvNV)(6, 1, v); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs2dvNV)(6, 1, def); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs3svNV(generic_func func) -{ - PFNGLVERTEXATTRIBS3SVNVPROC vertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 4, 7, 1}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttribs3svNV)(6, 1, v); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs3svNV)(6, 1, def); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs3fvNV(generic_func func) -{ - PFNGLVERTEXATTRIBS3FVNVPROC vertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 4.25, 7.125, 1.0}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttribs3fvNV)(6, 1, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs3fvNV)(6, 1, def); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs3dvNV(generic_func func) -{ - PFNGLVERTEXATTRIBS3DVNVPROC vertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 4.25, 7.125, 1.0}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttribs3dvNV)(6, 1, v); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs3dvNV)(6, 1, def); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs4svNV(generic_func func) -{ - PFNGLVERTEXATTRIBS4SVNVPROC vertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC) func; - PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV"); - - const GLshort v[4] = {2, 4, 7, 5}; - const GLshort def[4] = {0, 0, 0, 1}; - GLint res[4]; - (*vertexAttribs4svNV)(6, 1, v); - (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs4svNV)(6, 1, def); - return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs4fvNV(generic_func func) -{ - PFNGLVERTEXATTRIBS4FVNVPROC vertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLfloat v[4] = {2.5, 4.25, 7.125, 5.0625}; - const GLfloat def[4] = {0, 0, 0, 1}; - GLfloat res[4]; - (*vertexAttribs4fvNV)(6, 1, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs4fvNV)(6, 1, def); - return compare_floats(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs4dvNV(generic_func func) -{ - PFNGLVERTEXATTRIBS4DVNVPROC vertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC) func; - PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV"); - - const GLdouble v[4] = {2.5, 4.25, 7.125, 5.0625}; - const GLdouble def[4] = {0, 0, 0, 1}; - GLdouble res[4]; - (*vertexAttribs4dvNV)(6, 1, v); - (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs4dvNV)(6, 1, def); - return compare_doubles(__FUNCTION__, 4, v, 4, res); -} - -static GLboolean -test_VertexAttribs4ubvNV(generic_func func) -{ - PFNGLVERTEXATTRIBS4UBVNVPROC vertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC) func; - PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); - - const GLubyte v[4] = {255, 0, 255, 0}; - const GLubyte def[4] = {0, 0, 0, 255}; - GLfloat res[4]; - /* There's no byte-value query; so we use the float-value query. - * Bytes are interpreted as steps between 0 and 1, so the - * expected float values will be 0.0 for byte value 0 and 1.0 for - * byte value 255. - */ - GLfloat expectedResults[4] = {1.0, 0.0, 1.0, 0.0}; - (*vertexAttribs4ubvNV)(6, 1, v); - (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); - (*vertexAttribs4ubvNV)(6, 1, def); - return compare_floats(__FUNCTION__, 4, expectedResults, 4, res); -} - -static GLboolean -test_StencilFuncSeparateATI(generic_func func) -{ -#ifdef GL_ATI_separate_stencil - PFNGLSTENCILFUNCSEPARATEATIPROC stencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC) func; - GLint frontFunc, backFunc; - GLint frontRef, backRef; - GLint frontMask, backMask; - (*stencilFuncSeparateATI)(GL_LESS, GL_GREATER, 2, 0xa); - glGetIntegerv(GL_STENCIL_FUNC, &frontFunc); - glGetIntegerv(GL_STENCIL_BACK_FUNC, &backFunc); - glGetIntegerv(GL_STENCIL_REF, &frontRef); - glGetIntegerv(GL_STENCIL_BACK_REF, &backRef); - glGetIntegerv(GL_STENCIL_VALUE_MASK, &frontMask); - glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &backMask); - if (frontFunc != GL_LESS || - backFunc != GL_GREATER || - frontRef != 2 || - backRef != 2 || - frontMask != 0xa || - backMask != 0xa) - return GL_FALSE; -#endif - return GL_TRUE; -} - -static GLboolean -test_StencilFuncSeparate(generic_func func) -{ -#ifdef GL_VERSION_2_0 - PFNGLSTENCILFUNCSEPARATEPROC stencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) func; - GLint frontFunc, backFunc; - GLint frontRef, backRef; - GLint frontMask, backMask; - (*stencilFuncSeparate)(GL_BACK, GL_GREATER, 2, 0xa); - glGetIntegerv(GL_STENCIL_FUNC, &frontFunc); - glGetIntegerv(GL_STENCIL_BACK_FUNC, &backFunc); - glGetIntegerv(GL_STENCIL_REF, &frontRef); - glGetIntegerv(GL_STENCIL_BACK_REF, &backRef); - glGetIntegerv(GL_STENCIL_VALUE_MASK, &frontMask); - glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &backMask); - if (frontFunc != GL_ALWAYS || - backFunc != GL_GREATER || - frontRef != 0 || - backRef != 2 || - frontMask == 0xa || /* might be 0xff or ~0 */ - backMask != 0xa) - return GL_FALSE; -#endif - return GL_TRUE; -} - -static GLboolean -test_StencilOpSeparate(generic_func func) -{ -#ifdef GL_VERSION_2_0 - PFNGLSTENCILOPSEPARATEPROC stencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) func; - GLint frontFail, backFail; - GLint frontZFail, backZFail; - GLint frontZPass, backZPass; - (*stencilOpSeparate)(GL_BACK, GL_INCR, GL_DECR, GL_INVERT); - glGetIntegerv(GL_STENCIL_FAIL, &frontFail); - glGetIntegerv(GL_STENCIL_BACK_FAIL, &backFail); - glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &frontZFail); - glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &backZFail); - glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &frontZPass); - glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &backZPass); - if (frontFail != GL_KEEP || - backFail != GL_INCR || - frontZFail != GL_KEEP || - backZFail != GL_DECR || - frontZPass != GL_KEEP || - backZPass != GL_INVERT) - return GL_FALSE; -#endif - return GL_TRUE; -} - -static GLboolean -test_StencilMaskSeparate(generic_func func) -{ -#ifdef GL_VERSION_2_0 - PFNGLSTENCILMASKSEPARATEPROC stencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) func; - GLint frontMask, backMask; - (*stencilMaskSeparate)(GL_BACK, 0x1b); - glGetIntegerv(GL_STENCIL_WRITEMASK, &frontMask); - glGetIntegerv(GL_STENCIL_BACK_WRITEMASK, &backMask); - if (frontMask == 0x1b || - backMask != 0x1b) - return GL_FALSE; -#endif - return GL_TRUE; -} - - -/* - * The following file is auto-generated with Python. - */ -#include "getproclist.h" - - - -static int -extension_supported(const char *haystack, const char *needle) -{ - const char *p = strstr(haystack, needle); - if (p) { - /* found string, make sure next char is space or zero */ - const int len = strlen(needle); - if (p[len] == ' ' || p[len] == 0) - return 1; - else - return 0; - } - else - return 0; -} - - -/* Run all the known extension function tests, if the extension is supported. - * Return a count of how many failed. - */ -static int -check_functions( const char *extensions ) -{ - struct name_test_pair *entry; - int failures = 0, passes = 0, untested = 0; - int totalFail = 0, totalPass = 0, totalUntested = 0, totalUnsupported = 0; - int doTests = 0; - const char *version = (const char *) glGetString(GL_VERSION); - - /* The functions list will have "real" entries (consisting of - * a GL function name and a pointer to an exercise function for - * that GL function), and "group" entries (indicated as - * such by having a "-" as the first character of the name). - * "Group" names always start with the "-" character, and can - * be numeric (e.g. "-1.0", "-2.1"), indicating that a particular - * OpenGL version is required for the following functions; or can be - * an extension name (e.g. "-GL_ARB_multitexture") that means - * that the named extension is required for the following functions. - */ - for (entry = functions; entry->name; entry++) { - /* Check if this is a group indicator */ - if (entry->name[0] == '-') { - /* A group indicator; check if it's an OpenGL version group */ - if (entry->name[1] == '1') { - /* check GL version 1.x */ - if (version[0] == '1' && - version[1] == '.' && - version[2] >= entry->name[3]) - doTests = 1; - else - doTests = 0; - } - else if (entry->name[1] == '2') { - if (version[0] == '2' && - version[1] == '.' && - version[2] >= entry->name[3]) - doTests = 1; - else - doTests = 0; - } - else { - /* check if the named extension is available */ - doTests = extension_supported(extensions, entry->name+1); - } - - /* doTests is now set if we're starting an OpenGL version - * group, and the running OpenGL version is at least the - * version required; or if we're starting an OpenGL extension - * group, and the extension is supported. - */ - if (doTests) - printf("Testing %s functions\n", entry->name + 1); - - /* Each time we hit a title function, reset the function - * counts. - */ - failures = 0; - passes = 0; - untested = 0; - } - else if (doTests) { - /* Here, we know we're trying to exercise a function for - * a supported extension. See whether we have a test for - * it, and try to run it. - */ - generic_func funcPtr = (generic_func) glXGetProcAddressARB((const GLubyte *) entry->name); - if (funcPtr) { - if (entry->test) { - GLboolean b; - printf(" Validating %s:", entry->name); - b = (*entry->test)(funcPtr); - if (b) { - printf(" Pass\n"); - passes++; - totalPass++; - } - else { - printf(" FAIL!!!\n"); - failures++; - totalFail++; - } - } - else { - untested++; - totalUntested++; - } - } - else { - printf(" glXGetProcAddress(%s) failed!\n", entry->name); - failures++; - totalFail++; - } - } - else { - /* Here, we have a function that belongs to a group that - * is known to be unsupported. - */ - totalUnsupported++; - } - - /* Make sure a poor test case doesn't leave any lingering - * OpenGL errors. - */ - CheckGLError(__LINE__, __FILE__, __FUNCTION__); - - if (doTests && (!(entry+1)->name || (entry+1)->name[0] == '-')) { - if (failures > 0) { - printf(" %d failed.\n", failures); - } - if (passes > 0) { - printf(" %d passed.\n", passes); - } - if (untested > 0) { - printf(" %d untested.\n", untested); - } - } - } - - printf("-----------------------------\n"); - printf("Total: %d pass %d fail %d untested %d unsupported %d total\n", - totalPass, totalFail, totalUntested, totalUnsupported, - totalPass + totalFail + totalUntested + totalUnsupported); - - return totalFail; -} - - -/* Return an error code */ -#define ERROR_NONE 0 -#define ERROR_NO_VISUAL 1 -#define ERROR_NO_CONTEXT 2 -#define ERROR_NO_MAKECURRENT 3 -#define ERROR_FAILED 4 - -static int -print_screen_info(Display *dpy, int scrnum, Bool allowDirect) -{ - Window win; - int attribSingle[] = { - GLX_RGBA, - GLX_RED_SIZE, 1, - GLX_GREEN_SIZE, 1, - GLX_BLUE_SIZE, 1, - GLX_STENCIL_SIZE, 1, - None }; - int attribDouble[] = { - GLX_RGBA, - GLX_RED_SIZE, 1, - GLX_GREEN_SIZE, 1, - GLX_BLUE_SIZE, 1, - GLX_STENCIL_SIZE, 1, - GLX_DOUBLEBUFFER, - None }; - - XSetWindowAttributes attr; - unsigned long mask; - Window root; - GLXContext ctx; - XVisualInfo *visinfo; - int width = 100, height = 100; - int failures; - - root = RootWindow(dpy, scrnum); - - visinfo = glXChooseVisual(dpy, scrnum, attribSingle); - if (!visinfo) { - visinfo = glXChooseVisual(dpy, scrnum, attribDouble); - if (!visinfo) { - fprintf(stderr, "Error: couldn't find RGB GLX visual\n"); - return ERROR_NO_VISUAL; - } - } - - attr.background_pixel = 0; - attr.border_pixel = 0; - attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); - attr.event_mask = StructureNotifyMask | ExposureMask; - mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; - win = XCreateWindow(dpy, root, 0, 0, width, height, - 0, visinfo->depth, InputOutput, - visinfo->visual, mask, &attr); - - ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect ); - if (!ctx) { - fprintf(stderr, "Error: glXCreateContext failed\n"); - XDestroyWindow(dpy, win); - return ERROR_NO_CONTEXT; - } - - if (!glXMakeCurrent(dpy, win, ctx)) { - fprintf(stderr, "Error: glXMakeCurrent failed\n"); - glXDestroyContext(dpy, ctx); - XDestroyWindow(dpy, win); - return ERROR_NO_MAKECURRENT; - } - - failures = check_functions( (const char *) glGetString(GL_EXTENSIONS) ); - glXDestroyContext(dpy, ctx); - XDestroyWindow(dpy, win); - - return (failures == 0 ? ERROR_NONE : ERROR_FAILED); -} - -int -main(int argc, char *argv[]) -{ - char *displayName = NULL; - Display *dpy; - int returnCode; - - dpy = XOpenDisplay(displayName); - if (!dpy) { - fprintf(stderr, "Error: unable to open display %s\n", displayName); - return -1; - } - - returnCode = print_screen_info(dpy, 0, GL_TRUE); - - XCloseDisplay(dpy); - - return returnCode; -} |