557 lines
17 KiB
C
557 lines
17 KiB
C
/*
|
|
* 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_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;
|
|
}
|
|
|
|
|
|
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;
|
|
}
|