summaryrefslogtreecommitdiffstats
path: root/progs/tests/getprocaddress.c
diff options
context:
space:
mode:
Diffstat (limited to 'progs/tests/getprocaddress.c')
-rw-r--r--progs/tests/getprocaddress.c530
1 files changed, 530 insertions, 0 deletions
diff --git a/progs/tests/getprocaddress.c b/progs/tests/getprocaddress.c
new file mode 100644
index 00000000000..8b000d234a3
--- /dev/null
+++ b/progs/tests/getprocaddress.c
@@ -0,0 +1,530 @@
+/*
+ * 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)
+
+/**
+ * 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 signficant. The getprocaddress.py script
+ * scans this file and extracts these function names.
+ */
+
+
+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_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_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];
+ GLboolean pass;
+ (*vertexAttrib4ubNV)(6, v[0], v[1], v[2], v[3]);
+ (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
+ pass = (res[0] == 1.0 && res[1] == 0.0 && res[2] == 1.0 && res[3] == 0.0);
+ (*vertexAttrib4ubNV)(6, def[0], def[1], def[2], def[3]);
+ return pass;
+}
+
+
+static GLboolean
+test_VertexAttrib2sNV(generic_func func)
+{
+ PFNGLVERTEXATTRIB2SNVPROC vertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC) func;
+ PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");
+
+ const GLshort v[2] = {2, -4,};
+ const GLshort def[2] = {0, 0};
+ GLfloat res[4];
+ GLboolean pass;
+ (*vertexAttrib2sNV)(6, v[0], v[1]);
+ (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
+ pass = (EQUAL(res[0], 2) && EQUAL(res[1], -4) && EQUAL(res[2], 0) && res[3] == 1.0);
+ (*vertexAttrib2sNV)(6, def[0], def[1]);
+ return pass;
+}
+
+
+static GLboolean
+test_VertexAttrib3fNV(generic_func func)
+{
+ PFNGLVERTEXATTRIB3FNVPROC vertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC) func;
+ PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");
+
+ const GLfloat v[3] = {0.2, 0.4, 0.8};
+ const GLfloat def[3] = {0, 0, 0};
+ GLfloat res[4];
+ GLboolean pass;
+ (*vertexAttrib3fNV)(6, v[0], v[1], v[2]);
+ (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
+ pass = (EQUAL(res[0], 0.2) && EQUAL(res[1], 0.4) && EQUAL(res[2], 0.8) && res[3] == 1.0);
+ (*vertexAttrib3fNV)(6, def[0], def[1], def[2]);
+ return pass;
+}
+
+
+static GLboolean
+test_VertexAttrib4dvNV(generic_func func)
+{
+ PFNGLVERTEXATTRIB4DVNVPROC vertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC) func;
+ PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");
+
+ const GLdouble v[4] = {0.2, 0.4, 0.8, 1.2};
+ const GLdouble def[4] = {0, 0, 0, 1};
+ GLfloat res[4];
+ GLboolean pass;
+ (*vertexAttrib4dvNV)(6, v);
+ (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
+ pass = (EQUAL(res[0], 0.2) && EQUAL(res[1], 0.4) && EQUAL(res[2], 0.8) && EQUAL(res[3], 1.2));
+ (*vertexAttrib4dvNV)(6, def);
+ return pass;
+}
+
+
+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;
+}
+
+
+static void
+check_functions( const char *extensions )
+{
+ struct name_test_pair *entry;
+ int failures = 0, passes = 0;
+ int totalFail = 0, totalPass = 0;
+ int doTests;
+
+ for (entry = functions; entry->name; entry++) {
+ if (entry->name[0] == '-') {
+ const char *version = (const char *) glGetString(GL_VERSION);
+ 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);
+ }
+ if (doTests)
+ printf("Testing %s functions\n", entry->name + 1);
+ totalFail += failures;
+ totalPass += passes;
+ failures = 0;
+ passes = 0;
+ }
+ else if (doTests) {
+ 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++;
+ }
+ else {
+ printf(" FAIL!!!\n");
+ failures++;
+ }
+ }
+ else {
+ passes++;
+ }
+ }
+ else {
+ printf(" glXGetProcAddress(%s) failed!\n", entry->name);
+ failures++;
+ }
+ }
+
+ 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);
+ }
+ }
+ }
+ totalFail += failures;
+ totalPass += passes;
+
+ printf("-----------------------------\n");
+ printf("Total: %d pass %d fail\n", totalPass, totalFail);
+}
+
+
+
+static void
+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;
+
+ 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;
+ }
+ }
+
+ 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;
+ }
+
+ if (glXMakeCurrent(dpy, win, ctx)) {
+ check_functions( (const char *) glGetString(GL_EXTENSIONS) );
+ }
+ else {
+ fprintf(stderr, "Error: glXMakeCurrent failed\n");
+ }
+
+ glXDestroyContext(dpy, ctx);
+ XDestroyWindow(dpy, win);
+}
+
+
+int
+main(int argc, char *argv[])
+{
+ char *displayName = NULL;
+ Display *dpy;
+
+ dpy = XOpenDisplay(displayName);
+ if (!dpy) {
+ fprintf(stderr, "Error: unable to open display %s\n", displayName);
+ return -1;
+ }
+
+ print_screen_info(dpy, 0, GL_TRUE);
+
+ XCloseDisplay(dpy);
+
+ return 0;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-29 04:31:39 +0000