static void
print_limits(void)
{
struct token_name {
GLuint count;
GLenum token;
const char *name;
};
static const struct token_name limits[] = {
{ 1, GL_MAX_ATTRIB_STACK_DEPTH, "GL_MAX_ATTRIB_STACK_DEPTH" },
{ 1, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH" },
{ 1, GL_MAX_CLIP_PLANES, "GL_MAX_CLIP_PLANES" },
{ 1, GL_MAX_COLOR_MATRIX_STACK_DEPTH, "GL_MAX_COLOR_MATRIX_STACK_DEPTH" },
{ 1, GL_MAX_ELEMENTS_VERTICES, "GL_MAX_ELEMENTS_VERTICES" },
{ 1, GL_MAX_ELEMENTS_INDICES, "GL_MAX_ELEMENTS_INDICES" },
{ 1, GL_MAX_EVAL_ORDER, "GL_MAX_EVAL_ORDER" },
{ 1, GL_MAX_LIGHTS, "GL_MAX_LIGHTS" },
{ 1, GL_MAX_LIST_NESTING, "GL_MAX_LIST_NESTING" },
{ 1, GL_MAX_MODELVIEW_STACK_DEPTH, "GL_MAX_MODELVIEW_STACK_DEPTH" },
{ 1, GL_MAX_NAME_STACK_DEPTH, "GL_MAX_NAME_STACK_DEPTH" },
{ 1, GL_MAX_PIXEL_MAP_TABLE, "GL_MAX_PIXEL_MAP_TABLE" },
{ 1, GL_MAX_PROJECTION_STACK_DEPTH, "GL_MAX_PROJECTION_STACK_DEPTH" },
{ 1, GL_MAX_TEXTURE_STACK_DEPTH, "GL_MAX_TEXTURE_STACK_DEPTH" },
{ 1, GL_MAX_TEXTURE_SIZE, "GL_MAX_TEXTURE_SIZE" },
{ 1, GL_MAX_3D_TEXTURE_SIZE, "GL_MAX_3D_TEXTURE_SIZE" },
{ 1, GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB" },
{ 1, GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV" },
{ 1, GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB" },
{ 1, GL_MAX_TEXTURE_UNITS_ARB, "GL_MAX_TEXTURE_UNITS_ARB" },
{ 1, GL_MAX_TEXTURE_LOD_BIAS_EXT, "GL_MAX_TEXTURE_LOD_BIAS_EXT" },
{ 1, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT" },
{ 2, GL_MAX_VIEWPORT_DIMS, "GL_MAX_VIEWPORT_DIMS" },
{ 2, GL_ALIASED_LINE_WIDTH_RANGE, "GL_ALIASED_LINE_WIDTH_RANGE" },
{ 2, GL_SMOOTH_LINE_WIDTH_RANGE, "GL_SMOOTH_LINE_WIDTH_RANGE" },
{ 2, GL_ALIASED_POINT_SIZE_RANGE, "GL_ALIASED_POINT_SIZE_RANGE" },
{ 2, GL_SMOOTH_POINT_SIZE_RANGE, "GL_SMOOTH_POINT_SIZE_RANGE" },
{ 0, (GLenum) 0, NULL }
};
GLint i, max[2];
printf("OpenGL limits:\n");
for (i = 0; limits[i].count; i++) {
glGetIntegerv(limits[i].token, max);
if (glGetError() == GL_NONE) {
if (limits[i].count == 1)
printf(" %s = %d\n", limits[i].name, max[0]);
else /* XXX fix if we ever query something with more than 2 values */
printf(" %s = %d, %d\n", limits[i].name, max[0], max[1]);
}
}
/* these don't fit into the above mechanism, unfortunately */
glGetConvolutionParameteriv(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_WIDTH, max);
glGetConvolutionParameteriv(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_HEIGHT, max+1);
if (glGetError() == GL_NONE) {
printf(" GL_MAX_CONVOLUTION_WIDTH/HEIGHT = %d, %d\n", max[0], max[1]);
}
}
int __glXDisp_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
{
GLenum pname;
GLint compsize;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLint answerBuffer[200];
char *answer;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
pname = *(GLenum *)(pc + 4);
compsize = __glGetConvolutionParameteriv_size(pname);
if (compsize < 0) compsize = 0;
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
__glXClearErrorOccured();
glGetConvolutionParameteriv(
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
(GLint *) answer
);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(0);
__GLX_SEND_HEADER();
} else if (compsize == 1) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(1);
__GLX_PUT_INT();
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize*4);
__GLX_PUT_SIZE(compsize);
__GLX_SEND_HEADER();
__GLX_SEND_INT_ARRAY(compsize);
}
return Success;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetConvolutionParameteriv(JNIEnv *env, jclass clazz, jint target, jint pname, jlong params, jlong function_pointer) {
GLint *params_address = (GLint *)(intptr_t)params;
glGetConvolutionParameterivPROC glGetConvolutionParameteriv = (glGetConvolutionParameterivPROC)((intptr_t)function_pointer);
glGetConvolutionParameteriv(target, pname, params_address);
}
static int
GetConvolutionFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag)
{
GLint compsize;
GLenum format, type, target;
GLboolean swapBytes;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
__GLX_DECLARE_SWAP_VARIABLES;
char *answer, answerBuffer[200];
GLint width = 0, height = 0;
xGLXSingleReply reply = { 0, };
cx = __glXForceCurrent(cl, tag, &error);
if (!cx) {
return error;
}
__GLX_SWAP_INT(pc + 0);
__GLX_SWAP_INT(pc + 4);
__GLX_SWAP_INT(pc + 8);
format = *(GLenum *) (pc + 4);
type = *(GLenum *) (pc + 8);
target = *(GLenum *) (pc + 0);
swapBytes = *(GLboolean *) (pc + 12);
glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
if (target == GL_CONVOLUTION_2D) {
height = 1;
}
else {
glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
}
/*
* The two queries above might fail if we're in a state where queries
* are illegal, but then width and height would still be zero anyway.
*/
compsize = __glGetTexImage_size(target, 1, format, type, width, height, 1);
if (compsize < 0)
return BadLength;
glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
__GLX_GET_ANSWER_BUFFER(answer, cl, compsize, 1);
__glXClearErrorOccured();
glGetConvolutionFilter(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
*(GLenum *) (pc + 8), answer);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SWAP_REPLY_HEADER();
}
else {
__GLX_BEGIN_REPLY(compsize);
__GLX_SWAP_REPLY_HEADER();
__GLX_SWAP_INT(&width);
__GLX_SWAP_INT(&height);
((xGLXGetConvolutionFilterReply *) &reply)->width = width;
((xGLXGetConvolutionFilterReply *) &reply)->height = height;
__GLX_SEND_VOID_ARRAY(compsize);
}
return Success;
}
/**
* Print interesting OpenGL implementation limits.
*/
static void
print_limits(const char *extensions)
{
struct token_name {
GLuint count;
GLenum token;
const char *name;
};
static const struct token_name limits[] = {
{ 1, GL_MAX_ATTRIB_STACK_DEPTH, "GL_MAX_ATTRIB_STACK_DEPTH" },
{ 1, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH" },
{ 1, GL_MAX_CLIP_PLANES, "GL_MAX_CLIP_PLANES" },
{ 1, GL_MAX_COLOR_MATRIX_STACK_DEPTH, "GL_MAX_COLOR_MATRIX_STACK_DEPTH" },
{ 1, GL_MAX_ELEMENTS_VERTICES, "GL_MAX_ELEMENTS_VERTICES" },
{ 1, GL_MAX_ELEMENTS_INDICES, "GL_MAX_ELEMENTS_INDICES" },
{ 1, GL_MAX_EVAL_ORDER, "GL_MAX_EVAL_ORDER" },
{ 1, GL_MAX_LIGHTS, "GL_MAX_LIGHTS" },
{ 1, GL_MAX_LIST_NESTING, "GL_MAX_LIST_NESTING" },
{ 1, GL_MAX_MODELVIEW_STACK_DEPTH, "GL_MAX_MODELVIEW_STACK_DEPTH" },
{ 1, GL_MAX_NAME_STACK_DEPTH, "GL_MAX_NAME_STACK_DEPTH" },
{ 1, GL_MAX_PIXEL_MAP_TABLE, "GL_MAX_PIXEL_MAP_TABLE" },
{ 1, GL_MAX_PROJECTION_STACK_DEPTH, "GL_MAX_PROJECTION_STACK_DEPTH" },
{ 1, GL_MAX_TEXTURE_STACK_DEPTH, "GL_MAX_TEXTURE_STACK_DEPTH" },
{ 1, GL_MAX_TEXTURE_SIZE, "GL_MAX_TEXTURE_SIZE" },
{ 1, GL_MAX_3D_TEXTURE_SIZE, "GL_MAX_3D_TEXTURE_SIZE" },
{ 2, GL_MAX_VIEWPORT_DIMS, "GL_MAX_VIEWPORT_DIMS" },
{ 2, GL_ALIASED_LINE_WIDTH_RANGE, "GL_ALIASED_LINE_WIDTH_RANGE" },
{ 2, GL_SMOOTH_LINE_WIDTH_RANGE, "GL_SMOOTH_LINE_WIDTH_RANGE" },
{ 2, GL_ALIASED_POINT_SIZE_RANGE, "GL_ALIASED_POINT_SIZE_RANGE" },
{ 2, GL_SMOOTH_POINT_SIZE_RANGE, "GL_SMOOTH_POINT_SIZE_RANGE" },
#if defined(GL_ARB_texture_cube_map)
{ 1, GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB" },
#endif
#if defined(GLX_NV_texture_rectangle)
{ 1, GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV" },
#endif
#if defined(GL_ARB_texture_compression)
{ 1, GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB" },
#endif
#if defined(GL_ARB_multitexture)
{ 1, GL_MAX_TEXTURE_UNITS_ARB, "GL_MAX_TEXTURE_UNITS_ARB" },
#endif
#if defined(GL_EXT_texture_lod_bias)
{ 1, GL_MAX_TEXTURE_LOD_BIAS_EXT, "GL_MAX_TEXTURE_LOD_BIAS_EXT" },
#endif
#if defined(GL_EXT_texture_filter_anisotropic)
{ 1, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT" },
#endif
#if defined(GL_ARB_draw_buffers)
{ 1, GL_MAX_DRAW_BUFFERS_ARB, "GL_MAX_DRAW_BUFFERS_ARB" },
#endif
{ 0, (GLenum) 0, NULL }
};
GLint i, max[2];
printf("OpenGL limits:\n");
for (i = 0; limits[i].count; i++) {
glGetIntegerv(limits[i].token, max);
if (glGetError() == GL_NO_ERROR) {
if (limits[i].count == 1)
printf(" %s = %d\n", limits[i].name, max[0]);
else /* XXX fix if we ever query something with more than 2 values */
printf(" %s = %d, %d\n", limits[i].name, max[0], max[1]);
}
}
/* these don't fit into the above mechanism, unfortunately */
glGetConvolutionParameteriv(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_WIDTH, max);
glGetConvolutionParameteriv(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_HEIGHT, max+1);
if (glGetError() == GL_NONE) {
printf(" GL_MAX_CONVOLUTION_WIDTH/HEIGHT = %d, %d\n", max[0], max[1]);
}
#if defined(GL_ARB_vertex_program)
if (strstr(extensions, "GL_ARB_vertex_program")) {
print_program_limits(GL_VERTEX_PROGRAM_ARB);
}
#endif
#if defined(GL_ARB_fragment_program)
if (strstr(extensions, "GL_ARB_fragment_program")) {
print_program_limits(GL_FRAGMENT_PROGRAM_ARB);
}
#endif
#if defined(GL_ARB_vertex_shader)
if (strstr(extensions, "GL_ARB_vertex_shader")) {
print_shader_limits(GL_VERTEX_SHADER_ARB);
}
#endif
#if defined(GL_ARB_fragment_shader)
if (strstr(extensions, "GL_ARB_fragment_shader")) {
print_shader_limits(GL_FRAGMENT_SHADER_ARB);
}
#endif
}