diff options
Diffstat (limited to 'extra/mesa/mesa-21.3.7-add_xdemos-1.patch')
| -rw-r--r-- | extra/mesa/mesa-21.3.7-add_xdemos-1.patch | 3197 |
1 files changed, 0 insertions, 3197 deletions
diff --git a/extra/mesa/mesa-21.3.7-add_xdemos-1.patch b/extra/mesa/mesa-21.3.7-add_xdemos-1.patch deleted file mode 100644 index 6b41e57..0000000 --- a/extra/mesa/mesa-21.3.7-add_xdemos-1.patch +++ /dev/null @@ -1,3197 +0,0 @@ -Submitted By: DJ Lucas <dj@linuxfromscratch.org> - based on previous patches submitted - by Armin K and Fernando de Oliveira -Date: 2020-10-16 -Initial Package Version: 19.0.4 -Upstream Status: Not applicable. -Origin: Self. -Description: This patch adds two OpenGL demos, glxinfo and - glxgears and respective man pages. - -diff -Naurp mesa-20.2.1-orig/src/glx/meson.build mesa-20.2.1/src/glx/meson.build ---- mesa-20.2.1-orig/src/glx/meson.build 2020-10-14 12:19:10.623185200 -0500 -+++ mesa-20.2.1/src/glx/meson.build 2020-10-15 23:06:45.823362439 -0500 -@@ -165,6 +165,8 @@ libgl = shared_library( - install : true, - ) - -+subdir('xdemos') -+ - if with_tests - subdir('tests') - endif -diff -Naurp mesa-20.2.1-orig/src/glx/xdemos/glinfo_common.c mesa-20.2.1/src/glx/xdemos/glinfo_common.c ---- mesa-20.2.1-orig/src/glx/xdemos/glinfo_common.c 1969-12-31 18:00:00.000000000 -0600 -+++ mesa-20.2.1/src/glx/xdemos/glinfo_common.c 2020-10-15 23:06:45.826695773 -0500 -@@ -0,0 +1,800 @@ -+/* -+ * Copyright (C) 1999-2014 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. -+ */ -+ -+#include <assert.h> -+#include <ctype.h> -+#include <stdio.h> -+#include <stdlib.h> -+#include <string.h> -+#include "glinfo_common.h" -+ -+#ifdef _WIN32 -+#define snprintf _snprintf -+#endif -+ -+ -+/** -+ * Return the GL enum name for a numeric value. -+ * We really only care about the compressed texture formats for now. -+ */ -+static const char * -+enum_name(GLenum val) -+{ -+ static const struct { -+ const char *name; -+ GLenum val; -+ } enums [] = { -+ { "GL_COMPRESSED_ALPHA", 0x84E9 }, -+ { "GL_COMPRESSED_LUMINANCE", 0x84EA }, -+ { "GL_COMPRESSED_LUMINANCE_ALPHA", 0x84EB }, -+ { "GL_COMPRESSED_INTENSITY", 0x84EC }, -+ { "GL_COMPRESSED_RGB", 0x84ED }, -+ { "GL_COMPRESSED_RGBA", 0x84EE }, -+ { "GL_COMPRESSED_TEXTURE_FORMATS", 0x86A3 }, -+ { "GL_COMPRESSED_RGB", 0x84ED }, -+ { "GL_COMPRESSED_RGBA", 0x84EE }, -+ { "GL_COMPRESSED_TEXTURE_FORMATS", 0x86A3 }, -+ { "GL_COMPRESSED_ALPHA", 0x84E9 }, -+ { "GL_COMPRESSED_LUMINANCE", 0x84EA }, -+ { "GL_COMPRESSED_LUMINANCE_ALPHA", 0x84EB }, -+ { "GL_COMPRESSED_INTENSITY", 0x84EC }, -+ { "GL_COMPRESSED_SRGB", 0x8C48 }, -+ { "GL_COMPRESSED_SRGB_ALPHA", 0x8C49 }, -+ { "GL_COMPRESSED_SLUMINANCE", 0x8C4A }, -+ { "GL_COMPRESSED_SLUMINANCE_ALPHA", 0x8C4B }, -+ { "GL_COMPRESSED_RED", 0x8225 }, -+ { "GL_COMPRESSED_RG", 0x8226 }, -+ { "GL_COMPRESSED_RED_RGTC1", 0x8DBB }, -+ { "GL_COMPRESSED_SIGNED_RED_RGTC1", 0x8DBC }, -+ { "GL_COMPRESSED_RG_RGTC2", 0x8DBD }, -+ { "GL_COMPRESSED_SIGNED_RG_RGTC2", 0x8DBE }, -+ { "GL_COMPRESSED_RGB8_ETC2", 0x9274 }, -+ { "GL_COMPRESSED_SRGB8_ETC2", 0x9275 }, -+ { "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", 0x9276 }, -+ { "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", 0x9277 }, -+ { "GL_COMPRESSED_RGBA8_ETC2_EAC", 0x9278 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", 0x9279 }, -+ { "GL_COMPRESSED_R11_EAC", 0x9270 }, -+ { "GL_COMPRESSED_SIGNED_R11_EAC", 0x9271 }, -+ { "GL_COMPRESSED_RG11_EAC", 0x9272 }, -+ { "GL_COMPRESSED_SIGNED_RG11_EAC", 0x9273 }, -+ { "GL_COMPRESSED_ALPHA_ARB", 0x84E9 }, -+ { "GL_COMPRESSED_LUMINANCE_ARB", 0x84EA }, -+ { "GL_COMPRESSED_LUMINANCE_ALPHA_ARB", 0x84EB }, -+ { "GL_COMPRESSED_INTENSITY_ARB", 0x84EC }, -+ { "GL_COMPRESSED_RGB_ARB", 0x84ED }, -+ { "GL_COMPRESSED_RGBA_ARB", 0x84EE }, -+ { "GL_COMPRESSED_TEXTURE_FORMATS_ARB", 0x86A3 }, -+ { "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB", 0x8E8C }, -+ { "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB", 0x8E8D }, -+ { "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB", 0x8E8E }, -+ { "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB", 0x8E8F }, -+ { "GL_COMPRESSED_RGBA_ASTC_4x4_KHR", 0x93B0 }, -+ { "GL_COMPRESSED_RGBA_ASTC_5x4_KHR", 0x93B1 }, -+ { "GL_COMPRESSED_RGBA_ASTC_5x5_KHR", 0x93B2 }, -+ { "GL_COMPRESSED_RGBA_ASTC_6x5_KHR", 0x93B3 }, -+ { "GL_COMPRESSED_RGBA_ASTC_6x6_KHR", 0x93B4 }, -+ { "GL_COMPRESSED_RGBA_ASTC_8x5_KHR", 0x93B5 }, -+ { "GL_COMPRESSED_RGBA_ASTC_8x6_KHR", 0x93B6 }, -+ { "GL_COMPRESSED_RGBA_ASTC_8x8_KHR", 0x93B7 }, -+ { "GL_COMPRESSED_RGBA_ASTC_10x5_KHR", 0x93B8 }, -+ { "GL_COMPRESSED_RGBA_ASTC_10x6_KHR", 0x93B9 }, -+ { "GL_COMPRESSED_RGBA_ASTC_10x8_KHR", 0x93BA }, -+ { "GL_COMPRESSED_RGBA_ASTC_10x10_KHR", 0x93BB }, -+ { "GL_COMPRESSED_RGBA_ASTC_12x10_KHR", 0x93BC }, -+ { "GL_COMPRESSED_RGBA_ASTC_12x12_KHR", 0x93BD }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR", 0x93D0 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR", 0x93D1 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR", 0x93D2 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR", 0x93D3 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR", 0x93D4 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR", 0x93D5 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR", 0x93D6 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR", 0x93D7 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR", 0x93D8 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR", 0x93D9 }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR", 0x93DA }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR", 0x93DB }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR", 0x93DC }, -+ { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR", 0x93DD }, -+ { "GL_COMPRESSED_RGB_FXT1_3DFX", 0x86B0 }, -+ { "GL_COMPRESSED_RGBA_FXT1_3DFX", 0x86B1 }, -+ { "GL_COMPRESSED_LUMINANCE_LATC1_EXT", 0x8C70 }, -+ { "GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT", 0x8C71 }, -+ { "GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT", 0x8C72 }, -+ { "GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT", 0x8C73 }, -+ { "GL_COMPRESSED_RED_RGTC1_EXT", 0x8DBB }, -+ { "GL_COMPRESSED_SIGNED_RED_RGTC1_EXT", 0x8DBC }, -+ { "GL_COMPRESSED_RED_GREEN_RGTC2_EXT", 0x8DBD }, -+ { "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT", 0x8DBE }, -+ { "GL_COMPRESSED_RGB_S3TC_DXT1_EXT", 0x83F0 }, -+ { "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT", 0x83F1 }, -+ { "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT", 0x83F2 }, -+ { "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT", 0x83F3 }, -+ { "GL_COMPRESSED_SRGB_EXT", 0x8C48 }, -+ { "GL_COMPRESSED_SRGB_ALPHA_EXT", 0x8C49 }, -+ { "GL_COMPRESSED_SLUMINANCE_EXT", 0x8C4A }, -+ { "GL_COMPRESSED_SLUMINANCE_ALPHA_EXT", 0x8C4B }, -+ { "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT", 0x8C4C }, -+ { "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT", 0x8C4D }, -+ { "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT", 0x8C4E }, -+ { "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT", 0x8C4F }, -+ { "GL_PALETTE4_RGB8_OES", 0x8B90 }, -+ { "GL_PALETTE4_RGBA8_OES", 0x8B91 }, -+ { "GL_PALETTE4_R5_G6_B5_OES", 0x8B92 }, -+ { "GL_PALETTE4_RGBA4_OES", 0x8B93 }, -+ { "GL_PALETTE4_RGB5_A1_OES", 0x8B94 }, -+ { "GL_PALETTE8_RGB8_OES", 0x8B95 }, -+ { "GL_PALETTE8_RGBA8_OES", 0x8B96 }, -+ { "GL_PALETTE8_R5_G6_B5_OES", 0x8B97 }, -+ { "GL_PALETTE8_RGBA4_OES", 0x8B98 }, -+ { "GL_PALETTE8_RGB5_A1_OES", 0x8B99 } -+ }; -+ const int n = sizeof(enums) / sizeof(enums[0]); -+ static char buffer[100]; -+ int i; -+ for (i = 0; i < n; i++) { -+ if (enums[i].val == val) { -+ return enums[i].name; -+ } -+ } -+ /* enum val not found, just print hexadecimal value into static buffer */ -+ snprintf(buffer, sizeof(buffer), "0x%x", val); -+ return buffer; -+} -+ -+ -+/* -+ * qsort callback for string comparison. -+ */ -+static int -+compare_string_ptr(const void *p1, const void *p2) -+{ -+ return strcmp(* (char * const *) p1, * (char * const *) p2); -+} -+ -+/* -+ * Print a list of extensions, with word-wrapping. -+ */ -+void -+print_extension_list(const char *ext, GLboolean singleLine) -+{ -+ char **extensions; -+ int num_extensions; -+ const char *indentString = " "; -+ const int indent = 4; -+ const int max = 79; -+ int width, i, j, k; -+ -+ if (!ext || !ext[0]) -+ return; -+ -+ /* count the number of extensions, ignoring successive spaces */ -+ num_extensions = 0; -+ j = 1; -+ do { -+ if ((ext[j] == ' ' || ext[j] == 0) && ext[j - 1] != ' ') { -+ ++num_extensions; -+ } -+ } while(ext[j++]); -+ -+ /* copy individual extensions to an array */ -+ extensions = malloc(num_extensions * sizeof *extensions); -+ if (!extensions) { -+ fprintf(stderr, "Error: malloc() failed\n"); -+ exit(1); -+ } -+ i = j = k = 0; -+ while (1) { -+ if (ext[j] == ' ' || ext[j] == 0) { -+ /* found end of an extension name */ -+ const int len = j - i; -+ -+ if (len) { -+ assert(k < num_extensions); -+ -+ extensions[k] = malloc(len + 1); -+ if (!extensions[k]) { -+ fprintf(stderr, "Error: malloc() failed\n"); -+ exit(1); -+ } -+ -+ memcpy(extensions[k], ext + i, len); -+ extensions[k][len] = 0; -+ -+ ++k; -+ }; -+ -+ i += len + 1; -+ -+ if (ext[j] == 0) { -+ break; -+ } -+ } -+ j++; -+ } -+ assert(k == num_extensions); -+ -+ /* sort extensions alphabetically */ -+ qsort(extensions, num_extensions, sizeof extensions[0], compare_string_ptr); -+ -+ /* print the extensions */ -+ width = indent; -+ printf("%s", indentString); -+ for (k = 0; k < num_extensions; ++k) { -+ const int len = strlen(extensions[k]); -+ if ((!singleLine) && (width + len > max)) { -+ /* start a new line */ -+ printf("\n"); -+ width = indent; -+ printf("%s", indentString); -+ } -+ /* print the extension name */ -+ printf("%s", extensions[k]); -+ -+ /* either we're all done, or we'll continue with next extension */ -+ width += len + 1; -+ -+ if (singleLine) { -+ printf("\n"); -+ width = indent; -+ printf("%s", indentString); -+ } -+ else if (k < (num_extensions -1)) { -+ printf(", "); -+ width += 2; -+ } -+ } -+ printf("\n"); -+ -+ for (k = 0; k < num_extensions; ++k) { -+ free(extensions[k]); -+ } -+ free(extensions); -+} -+ -+ -+ -+ -+/** -+ * Get list of OpenGL extensions using core profile's glGetStringi(). -+ */ -+char * -+build_core_profile_extension_list(const struct ext_functions *extfuncs) -+{ -+ GLint i, n, totalLen; -+ char *buffer; -+ -+ glGetIntegerv(GL_NUM_EXTENSIONS, &n); -+ -+ /* compute totalLen */ -+ totalLen = 0; -+ for (i = 0; i < n; i++) { -+ const char *ext = (const char *) extfuncs->GetStringi(GL_EXTENSIONS, i); -+ if (ext) -+ totalLen += strlen(ext) + 1; /* plus a space */ -+ } -+ -+ if (!totalLen) -+ return NULL; -+ -+ buffer = malloc(totalLen + 1); -+ if (buffer) { -+ int pos = 0; -+ for (i = 0; i < n; i++) { -+ const char *ext = (const char *) extfuncs->GetStringi(GL_EXTENSIONS, i); -+ strcpy(buffer + pos, ext); -+ pos += strlen(ext); -+ buffer[pos++] = ' '; -+ } -+ buffer[pos] = '\0'; -+ } -+ return buffer; -+} -+ -+ -+/** Is extension 'ext' supported? */ -+GLboolean -+extension_supported(const char *ext, const char *extensionsList) -+{ -+ while (1) { -+ const char *p = strstr(extensionsList, ext); -+ if (p) { -+ /* check that next char is a space or end of string */ -+ int extLen = strlen(ext); -+ if (p[extLen] == 0 || p[extLen] == ' ') { -+ return 1; -+ } -+ else { -+ /* We found a superset string, keep looking */ -+ extensionsList += extLen; -+ } -+ } -+ else { -+ break; -+ } -+ } -+ return 0; -+} -+ -+ -+/** -+ * Is verNum >= verString? -+ * \param verString such as "2.1", "3.0", etc. -+ * \param verNum such as 20, 21, 30, 31, 32, etc. -+ */ -+static GLboolean -+version_supported(const char *verString, int verNum) -+{ -+ int v; -+ -+ if (!verString || -+ !isdigit(verString[0]) || -+ verString[1] != '.' || -+ !isdigit(verString[2])) { -+ return GL_FALSE; -+ } -+ -+ v = (verString[0] - '0') * 10 + (verString[2] - '0'); -+ -+ return verNum >= v; -+} -+ -+ -+struct token_name -+{ -+ GLenum token; -+ const char *name; -+}; -+ -+ -+static void -+print_shader_limit_list(const struct token_name *lim) -+{ -+ GLint max[1]; -+ unsigned i; -+ -+ for (i = 0; lim[i].token; i++) { -+ glGetIntegerv(lim[i].token, max); -+ if (glGetError() == GL_NO_ERROR) { -+ printf(" %s = %d\n", lim[i].name, max[0]); -+ } -+ } -+} -+ -+ -+/** -+ * Print interesting limits for vertex/fragment shaders. -+ */ -+static void -+print_shader_limits(GLenum target) -+{ -+ static const struct token_name vertex_limits[] = { -+ { GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB" }, -+ { GL_MAX_VARYING_FLOATS_ARB, "GL_MAX_VARYING_FLOATS_ARB" }, -+ { GL_MAX_VERTEX_ATTRIBS_ARB, "GL_MAX_VERTEX_ATTRIBS_ARB" }, -+ { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB" }, -+ { GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" }, -+ { GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB" }, -+ { GL_MAX_TEXTURE_COORDS_ARB, "GL_MAX_TEXTURE_COORDS_ARB" }, -+ { GL_MAX_VERTEX_OUTPUT_COMPONENTS , "GL_MAX_VERTEX_OUTPUT_COMPONENTS " }, -+ { (GLenum) 0, NULL } -+ }; -+ static const struct token_name fragment_limits[] = { -+ { GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB" }, -+ { GL_MAX_TEXTURE_COORDS_ARB, "GL_MAX_TEXTURE_COORDS_ARB" }, -+ { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB" }, -+ { GL_MAX_FRAGMENT_INPUT_COMPONENTS , "GL_MAX_FRAGMENT_INPUT_COMPONENTS " }, -+ { (GLenum) 0, NULL } -+ }; -+ static const struct token_name geometry_limits[] = { -+ { GL_MAX_GEOMETRY_UNIFORM_COMPONENTS, "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS" }, -+ { GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS" }, -+ { GL_MAX_GEOMETRY_OUTPUT_VERTICES , "GL_MAX_GEOMETRY_OUTPUT_VERTICES " }, -+ { GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS" }, -+ { GL_MAX_GEOMETRY_INPUT_COMPONENTS , "GL_MAX_GEOMETRY_INPUT_COMPONENTS " }, -+ { GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS" }, -+ { (GLenum) 0, NULL } -+ }; -+ -+ switch (target) { -+ case GL_VERTEX_SHADER: -+ printf(" GL_VERTEX_SHADER_ARB:\n"); -+ print_shader_limit_list(vertex_limits); -+ break; -+ -+ case GL_FRAGMENT_SHADER: -+ printf(" GL_FRAGMENT_SHADER_ARB:\n"); -+ print_shader_limit_list(fragment_limits); -+ break; -+ -+ case GL_GEOMETRY_SHADER: -+ printf(" GL_GEOMETRY_SHADER:\n"); -+ print_shader_limit_list(geometry_limits); -+ break; -+ } -+} -+ -+ -+/** -+ * Print interesting limits for vertex/fragment programs. -+ */ -+static void -+print_program_limits(GLenum target, -+ const struct ext_functions *extfuncs) -+{ -+#if defined(GL_ARB_vertex_program) || defined(GL_ARB_fragment_program) -+ struct token_name { -+ GLenum token; -+ const char *name; -+ }; -+ static const struct token_name common_limits[] = { -+ { GL_MAX_PROGRAM_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_INSTRUCTIONS_ARB" }, -+ { GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB" }, -+ { GL_MAX_PROGRAM_TEMPORARIES_ARB, "GL_MAX_PROGRAM_TEMPORARIES_ARB" }, -+ { GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB" }, -+ { GL_MAX_PROGRAM_PARAMETERS_ARB, "GL_MAX_PROGRAM_PARAMETERS_ARB" }, -+ { GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB" }, -+ { GL_MAX_PROGRAM_ATTRIBS_ARB, "GL_MAX_PROGRAM_ATTRIBS_ARB" }, -+ { GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB" }, -+ { GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB" }, -+ { GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" }, -+ { GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB" }, -+ { GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB" }, -+ { (GLenum) 0, NULL } -+ }; -+ static const struct token_name fragment_limits[] = { -+ { GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB" }, -+ { GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB" }, -+ { GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB" }, -+ { GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB" }, -+ { GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB" }, -+ { GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB" }, -+ { (GLenum) 0, NULL } -+ }; -+ -+ GLint max[1]; -+ int i; -+ -+ if (target == GL_VERTEX_PROGRAM_ARB) { -+ printf(" GL_VERTEX_PROGRAM_ARB:\n"); -+ } -+ else if (target == GL_FRAGMENT_PROGRAM_ARB) { -+ printf(" GL_FRAGMENT_PROGRAM_ARB:\n"); -+ } -+ else { -+ return; /* something's wrong */ -+ } -+ -+ for (i = 0; common_limits[i].token; i++) { -+ extfuncs->GetProgramivARB(target, common_limits[i].token, max); -+ if (glGetError() == GL_NO_ERROR) { -+ printf(" %s = %d\n", common_limits[i].name, max[0]); -+ } -+ } -+ if (target == GL_FRAGMENT_PROGRAM_ARB) { -+ for (i = 0; fragment_limits[i].token; i++) { -+ extfuncs->GetProgramivARB(target, fragment_limits[i].token, max); -+ if (glGetError() == GL_NO_ERROR) { -+ printf(" %s = %d\n", fragment_limits[i].name, max[0]); -+ } -+ } -+ } -+#endif /* GL_ARB_vertex_program / GL_ARB_fragment_program */ -+} -+ -+ -+/** -+ * Print interesting OpenGL implementation limits. -+ * \param version 20, 21, 30, 31, 32, etc. -+ */ -+void -+print_limits(const char *extensions, const char *oglstring, int version, -+ const struct ext_functions *extfuncs) -+{ -+ struct token_name { -+ GLuint count; -+ GLenum token; -+ const char *name; -+ const char *extension; /* NULL or GL extension name or version string */ -+ }; -+ static const struct token_name limits[] = { -+ { 1, GL_MAX_ATTRIB_STACK_DEPTH, "GL_MAX_ATTRIB_STACK_DEPTH", NULL }, -+ { 1, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", NULL }, -+ { 1, GL_MAX_CLIP_PLANES, "GL_MAX_CLIP_PLANES", NULL }, -+ { 1, GL_MAX_COLOR_MATRIX_STACK_DEPTH, "GL_MAX_COLOR_MATRIX_STACK_DEPTH", "GL_ARB_imaging" }, -+ { 1, GL_MAX_ELEMENTS_VERTICES, "GL_MAX_ELEMENTS_VERTICES", NULL }, -+ { 1, GL_MAX_ELEMENTS_INDICES, "GL_MAX_ELEMENTS_INDICES", NULL }, -+ { 1, GL_MAX_EVAL_ORDER, "GL_MAX_EVAL_ORDER", NULL }, -+ { 1, GL_MAX_LIGHTS, "GL_MAX_LIGHTS", NULL }, -+ { 1, GL_MAX_LIST_NESTING, "GL_MAX_LIST_NESTING", NULL }, -+ { 1, GL_MAX_MODELVIEW_STACK_DEPTH, "GL_MAX_MODELVIEW_STACK_DEPTH", NULL }, -+ { 1, GL_MAX_NAME_STACK_DEPTH, "GL_MAX_NAME_STACK_DEPTH", NULL }, -+ { 1, GL_MAX_PIXEL_MAP_TABLE, "GL_MAX_PIXEL_MAP_TABLE", NULL }, -+ { 1, GL_MAX_PROJECTION_STACK_DEPTH, "GL_MAX_PROJECTION_STACK_DEPTH", NULL }, -+ { 1, GL_MAX_TEXTURE_STACK_DEPTH, "GL_MAX_TEXTURE_STACK_DEPTH", NULL }, -+ { 1, GL_MAX_TEXTURE_SIZE, "GL_MAX_TEXTURE_SIZE", NULL }, -+ { 1, GL_MAX_3D_TEXTURE_SIZE, "GL_MAX_3D_TEXTURE_SIZE", NULL }, -+#if defined(GL_EXT_texture_array) -+ { 1, GL_MAX_ARRAY_TEXTURE_LAYERS_EXT, "GL_MAX_ARRAY_TEXTURE_LAYERS", "GL_EXT_texture_array" }, -+#endif -+ { 2, GL_MAX_VIEWPORT_DIMS, "GL_MAX_VIEWPORT_DIMS", NULL }, -+ { 2, GL_ALIASED_LINE_WIDTH_RANGE, "GL_ALIASED_LINE_WIDTH_RANGE", NULL }, -+ { 2, GL_SMOOTH_LINE_WIDTH_RANGE, "GL_SMOOTH_LINE_WIDTH_RANGE", NULL }, -+ { 2, GL_ALIASED_POINT_SIZE_RANGE, "GL_ALIASED_POINT_SIZE_RANGE", NULL }, -+ { 2, GL_SMOOTH_POINT_SIZE_RANGE, "GL_SMOOTH_POINT_SIZE_RANGE", NULL }, -+#if defined(GL_ARB_texture_cube_map) -+ { 1, GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB", "GL_ARB_texture_cube_map" }, -+#endif -+#if defined(GL_NV_texture_rectangle) -+ { 1, GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV", "GL_NV_texture_rectangle" }, -+#endif -+#if defined(GL_ARB_multitexture) -+ { 1, GL_MAX_TEXTURE_UNITS_ARB, "GL_MAX_TEXTURE_UNITS_ARB", "GL_ARB_multitexture" }, -+#endif -+#if defined(GL_EXT_texture_lod_bias) -+ { 1, GL_MAX_TEXTURE_LOD_BIAS_EXT, "GL_MAX_TEXTURE_LOD_BIAS_EXT", "GL_EXT_texture_lod_bias" }, -+#endif -+#if defined(GL_EXT_texture_filter_anisotropic) -+ { 1, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT", "GL_EXT_texture_filter_anisotropic" }, -+#endif -+#if defined(GL_ARB_draw_buffers) -+ { 1, GL_MAX_DRAW_BUFFERS_ARB, "GL_MAX_DRAW_BUFFERS_ARB", "GL_ARB_draw_buffers" }, -+#endif -+#if defined(GL_ARB_blend_func_extended) -+ { 1, GL_MAX_DUAL_SOURCE_DRAW_BUFFERS, "GL_MAX_DUAL_SOURCE_DRAW_BUFFERS", "GL_ARB_blend_func_extended" }, -+#endif -+#if defined (GL_ARB_framebuffer_object) -+ { 1, GL_MAX_RENDERBUFFER_SIZE, "GL_MAX_RENDERBUFFER_SIZE", "GL_ARB_framebuffer_object" }, -+ { 1, GL_MAX_COLOR_ATTACHMENTS, "GL_MAX_COLOR_ATTACHMENTS", "GL_ARB_framebuffer_object" }, -+ { 1, GL_MAX_SAMPLES, "GL_MAX_SAMPLES", "GL_ARB_framebuffer_object" }, -+#endif -+#if defined (GL_EXT_transform_feedback) -+ { 1, GL_MAX_TRANSFORM_FEEDBACK_BUFFERS, "GL_MAX_TRANSFORM_FEEDBACK_BUFFERS", "GL_EXT_transform_feedback" }, -+ { 1, GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT, "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", "GL_EXT_transform_feedback" }, -+ { 1, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", "GL_EXT_transform_feedback", }, -+ { 1, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", "GL_EXT_transform_feedback" }, -+#endif -+#if defined (GL_ARB_texture_buffer_object) -+ { 1, GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT", "GL_ARB_texture_buffer_object" }, -+ { 1, GL_MAX_TEXTURE_BUFFER_SIZE, "GL_MAX_TEXTURE_BUFFER_SIZE", "GL_ARB_texture_buffer_object" }, -+#endif -+#if defined (GL_ARB_texture_multisample) -+ { 1, GL_MAX_COLOR_TEXTURE_SAMPLES, "GL_MAX_COLOR_TEXTURE_SAMPLES", "GL_ARB_texture_multisample" }, -+ { 1, GL_MAX_DEPTH_TEXTURE_SAMPLES, "GL_MAX_DEPTH_TEXTURE_SAMPLES", "GL_ARB_texture_multisample" }, -+ { 1, GL_MAX_INTEGER_SAMPLES, "GL_MAX_INTEGER_SAMPLES", "GL_ARB_texture_multisample" }, -+#endif -+#if defined (GL_ARB_uniform_buffer_object) -+ { 1, GL_MAX_VERTEX_UNIFORM_BLOCKS, "GL_MAX_VERTEX_UNIFORM_BLOCKS", "GL_ARB_uniform_buffer_object" }, -+ { 1, GL_MAX_FRAGMENT_UNIFORM_BLOCKS, "GL_MAX_FRAGMENT_UNIFORM_BLOCKS", "GL_ARB_uniform_buffer_object" }, -+ { 1, GL_MAX_GEOMETRY_UNIFORM_BLOCKS, "GL_MAX_GEOMETRY_UNIFORM_BLOCKS" , "GL_ARB_uniform_buffer_object" }, -+ { 1, GL_MAX_COMBINED_UNIFORM_BLOCKS, "GL_MAX_COMBINED_UNIFORM_BLOCKS", "GL_ARB_uniform_buffer_object" }, -+ { 1, GL_MAX_UNIFORM_BUFFER_BINDINGS, "GL_MAX_UNIFORM_BUFFER_BINDINGS", "GL_ARB_uniform_buffer_object" }, -+ { 1, GL_MAX_UNIFORM_BLOCK_SIZE, "GL_MAX_UNIFORM_BLOCK_SIZE", "GL_ARB_uniform_buffer_object" }, -+ { 1, GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", "GL_ARB_uniform_buffer_object" }, -+ { 1, GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", "GL_ARB_uniform_buffer_object" }, -+ { 1, GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS", "GL_ARB_uniform_buffer_object" }, -+ { 1, GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT", "GL_ARB_uniform_buffer_object" }, -+#endif -+#if defined (GL_ARB_vertex_attrib_binding) -+ { 1, GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET, "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET", "GL_ARB_vertex_attrib_binding" }, -+ { 1, GL_MAX_VERTEX_ATTRIB_BINDINGS, "GL_MAX_VERTEX_ATTRIB_BINDINGS", "GL_ARB_vertex_attrib_binding" }, -+#endif -+#if defined(GL_VERSION_4_4) -+ { 1, GL_MAX_VERTEX_ATTRIB_STRIDE, "GL_MAX_VERTEX_ATTRIB_STRIDE", "4.4" }, -+#endif -+ { 0, (GLenum) 0, NULL, NULL } -+ }; -+ GLint i, max[2]; -+ -+ printf("%s limits:\n", oglstring); -+ for (i = 0; limits[i].count; i++) { -+ if (!limits[i].extension || -+ version_supported(limits[i].extension, version) || -+ extension_supported(limits[i].extension, extensions)) { -+ 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 */ -+ if (extension_supported("GL_ARB_imaging", extensions)) { -+ extfuncs->GetConvolutionParameteriv(GL_CONVOLUTION_2D, -+ GL_MAX_CONVOLUTION_WIDTH, max); -+ extfuncs->GetConvolutionParameteriv(GL_CONVOLUTION_2D, -+ GL_MAX_CONVOLUTION_HEIGHT, max+1); -+ printf(" GL_MAX_CONVOLUTION_WIDTH/HEIGHT = %d, %d\n", max[0], max[1]); -+ } -+ -+ if (extension_supported("GL_ARB_texture_compression", extensions)) { -+ GLint i, n; -+ GLint *formats; -+ glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &n); -+ printf(" GL_NUM_COMPRESSED_TEXTURE_FORMATS = %d\n", n); -+ formats = (GLint *) malloc(n * sizeof(GLint)); -+ glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats); -+ for (i = 0; i < n; i++) { -+ printf(" %s\n", enum_name(formats[i])); -+ } -+ free(formats); -+ } -+#if defined(GL_ARB_vertex_program) -+ if (extension_supported("GL_ARB_vertex_program", extensions)) { -+ print_program_limits(GL_VERTEX_PROGRAM_ARB, extfuncs); -+ } -+#endif -+#if defined(GL_ARB_fragment_program) -+ if (extension_supported("GL_ARB_fragment_program", extensions)) { -+ print_program_limits(GL_FRAGMENT_PROGRAM_ARB, extfuncs); -+ } -+#endif -+ if (extension_supported("GL_ARB_vertex_shader", extensions)) { -+ print_shader_limits(GL_VERTEX_SHADER_ARB); -+ } -+ if (extension_supported("GL_ARB_fragment_shader", extensions)) { -+ print_shader_limits(GL_FRAGMENT_SHADER_ARB); -+ } -+ if (version >= 32) { -+ print_shader_limits(GL_GEOMETRY_SHADER); -+ } -+} -+ -+ -+ -+/** -+ * Return string representation for bits in a bitmask. -+ */ -+const char * -+bitmask_to_string(const struct bit_info bits[], int numBits, int mask) -+{ -+ static char buffer[256], *p; -+ int i; -+ -+ strcpy(buffer, "(none)"); -+ p = buffer; -+ for (i = 0; i < numBits; i++) { -+ if (mask & bits[i].bit) { -+ if (p > buffer) -+ *p++ = ','; -+ strcpy(p, bits[i].name); -+ p += strlen(bits[i].name); -+ } -+ } -+ -+ return buffer; -+} -+ -+/** -+ * Return string representation for the bitmask returned by -+ * GL_CONTEXT_PROFILE_MASK (OpenGL 3.2 or later). -+ */ -+const char * -+profile_mask_string(int mask) -+{ -+ const static struct bit_info bits[] = { -+#ifdef GL_CONTEXT_CORE_PROFILE_BIT -+ { GL_CONTEXT_CORE_PROFILE_BIT, "core profile"}, -+#endif -+#ifdef GL_CONTEXT_COMPATIBILITY_PROFILE_BIT -+ { GL_CONTEXT_COMPATIBILITY_PROFILE_BIT, "compatibility profile" } -+#endif -+ }; -+ -+ return bitmask_to_string(bits, ELEMENTS(bits), mask); -+} -+ -+ -+/** -+ * Return string representation for the bitmask returned by -+ * GL_CONTEXT_FLAGS (OpenGL 3.0 or later). -+ */ -+const char * -+context_flags_string(int mask) -+{ -+ const static struct bit_info bits[] = { -+#ifdef GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT -+ { GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT, "forward-compatible" }, -+#endif -+#ifdef GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB -+ { GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB, "robust-access" }, -+#endif -+ }; -+ -+ return bitmask_to_string(bits, ELEMENTS(bits), mask); -+} -+ -+ -+static void -+usage(void) -+{ -+#ifdef _WIN32 -+ printf("Usage: wglinfo [-v] [-t] [-h] [-b] [-l] [-s]\n"); -+#else -+ printf("Usage: glxinfo [-v] [-t] [-h] [-b] [-l] [-s] [-i] [-display <dname>]\n"); -+ printf("\t-display <dname>: Print GLX visuals on specified server.\n"); -+ printf("\t-i: Force an indirect rendering context.\n"); -+#endif -+ printf("\t-B: brief output, print only the basics.\n"); -+ printf("\t-v: Print visuals info in verbose form.\n"); -+ printf("\t-t: Print verbose table.\n"); -+ printf("\t-h: This information.\n"); -+ printf("\t-b: Find the 'best' visual and print its number.\n"); -+ printf("\t-l: Print interesting OpenGL limits.\n"); -+ printf("\t-s: Print a single extension per line.\n"); -+} -+ -+void -+parse_args(int argc, char *argv[], struct options *options) -+{ -+ int i; -+ -+ options->mode = Normal; -+ options->findBest = GL_FALSE; -+ options->limits = GL_FALSE; -+ options->singleLine = GL_FALSE; -+ options->displayName = NULL; -+ options->allowDirect = GL_TRUE; -+ -+ for (i = 1; i < argc; i++) { -+#ifndef _WIN32 -+ if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) { -+ options->displayName = argv[i + 1]; -+ i++; -+ } -+ else if (strcmp(argv[i], "-i") == 0) { -+ options->allowDirect = GL_FALSE; -+ } -+ else -+#endif -+ if (strcmp(argv[i], "-t") == 0) { -+ options->mode = Wide; -+ } -+ else if (strcmp(argv[i], "-v") == 0) { -+ options->mode = Verbose; -+ } -+ else if (strcmp(argv[i], "-B") == 0) { -+ options->mode = Brief; -+ } -+ else if (strcmp(argv[i], "-b") == 0) { -+ options->findBest = GL_TRUE; -+ } -+ else if (strcmp(argv[i], "-l") == 0) { -+ options->limits = GL_TRUE; -+ } -+ else if (strcmp(argv[i], "-h") == 0) { -+ usage(); -+ exit(0); -+ } -+ else if(strcmp(argv[i], "-s") == 0) { -+ options->singleLine = GL_TRUE; -+ } -+ else { -+ printf("Unknown option `%s'\n", argv[i]); -+ usage(); -+ exit(0); -+ } -+ } -+} -diff -Naurp mesa-20.2.1-orig/src/glx/xdemos/glinfo_common.h mesa-20.2.1/src/glx/xdemos/glinfo_common.h ---- mesa-20.2.1-orig/src/glx/xdemos/glinfo_common.h 1969-12-31 18:00:00.000000000 -0600 -+++ mesa-20.2.1/src/glx/xdemos/glinfo_common.h 2020-10-15 23:06:45.826695773 -0500 -@@ -0,0 +1,142 @@ -+/* -+ * Copyright (C) 1999-2014 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. -+ */ -+ -+ -+/** -+ * Common code shared by glxinfo and wglinfo. -+ */ -+ -+#ifndef GLINFO_COMMON_H -+#define GLINFO_COMMON_H -+ -+ -+#ifdef _WIN32 -+/* GL/glext.h is not commonly available on Windows. */ -+#include <GL/glew.h> -+#else -+#include <GL/gl.h> -+#include <GL/glext.h> -+#endif -+ -+typedef void (APIENTRY * GETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params); -+typedef const GLubyte *(APIENTRY * GETSTRINGIPROC) (GLenum name, GLuint index); -+typedef void (APIENTRY * GETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); -+ -+ -+/** -+ * Ext functions needed in common code but must be provided by -+ * glxinfo or wglinfo. -+ */ -+struct ext_functions -+{ -+ GETPROGRAMIVARBPROC GetProgramivARB; -+ GETSTRINGIPROC GetStringi; -+ GETCONVOLUTIONPARAMETERIVPROC GetConvolutionParameteriv; -+}; -+ -+ -+#define ELEMENTS(array) (sizeof(array) / sizeof(array[0])) -+ -+ -+struct bit_info -+{ -+ int bit; -+ const char *name; -+}; -+ -+ -+typedef enum -+{ -+ Normal, -+ Wide, -+ Verbose, -+ Brief -+} InfoMode; -+ -+ -+struct options -+{ -+ InfoMode mode; -+ GLboolean findBest; -+ GLboolean limits; -+ GLboolean singleLine; -+ /* GLX only */ -+ char *displayName; -+ GLboolean allowDirect; -+}; -+ -+ -+/** list of known OpenGL versions */ -+static const struct { int major, minor; } gl_versions[] = { -+ {4, 5}, -+ {4, 4}, -+ {4, 3}, -+ {4, 2}, -+ {4, 1}, -+ {4, 0}, -+ -+ {3, 3}, -+ {3, 2}, -+ {3, 1}, -+ {3, 0}, -+ -+ {2, 1}, -+ {2, 0}, -+ -+ {1, 5}, -+ {1, 4}, -+ {1, 3}, -+ {1, 2}, -+ {1, 1}, -+ {1, 0}, -+ -+ {0, 0} /* end of list */ -+}; -+ -+ -+void -+print_extension_list(const char *ext, GLboolean singleLine); -+ -+char * -+build_core_profile_extension_list(const struct ext_functions *extfuncs); -+ -+GLboolean -+extension_supported(const char *ext, const char *extensionsList); -+ -+void -+print_limits(const char *extensions, const char *oglstring, int version, -+ const struct ext_functions *extfuncs); -+ -+const char * -+bitmask_to_string(const struct bit_info bits[], int numBits, int mask); -+ -+const char * -+profile_mask_string(int mask); -+ -+const char * -+context_flags_string(int mask); -+ -+ -+void -+parse_args(int argc, char *argv[], struct options *options); -+ -+ -+#endif /* GLINFO_COMMON_H */ -diff -Naurp mesa-20.2.1-orig/src/glx/xdemos/glxgears.1 mesa-20.2.1/src/glx/xdemos/glxgears.1 ---- mesa-20.2.1-orig/src/glx/xdemos/glxgears.1 1969-12-31 18:00:00.000000000 -0600 -+++ mesa-20.2.1/src/glx/xdemos/glxgears.1 2020-10-15 23:06:45.826695773 -0500 -@@ -0,0 +1,37 @@ -+.TH glxgears 1 "2006-11-29" -+.SH NAME -+glxgears \- ``gears'' demo for GLX -+.SH SYNOPSIS -+.B glxgears -+.RI [ options ] -+.SH DESCRIPTION -+The \fIglxgears\fP program is a port of the ``gears'' demo to GLX. It displays -+a set of rotating gears and prints out the frame rate at regular intervals. It -+has become quite popular as basic benchmarking tool. -+.SH OPTIONS -+.TP 8 -+.B \-display \fIdisplay\fP -+Specify which X display to run on. -+.TP 8 -+.B \-stereo -+Use a stereo enabled GLX visual. -+.TP 8 -+.B \-samples \fIN\fP -+Run in multisample mode with at least N samples. -+.TP 8 -+.B \-fullscreen -+Run in fullscreen mode. -+.TP 8 -+.B \-info -+Display OpenGL renderer information. -+.TP 8 -+.B \-geometry \fIWxH+X+Y\fP -+Window geometry. -+.SH AUTHOR -+glxgears was written by Brian Paul <brian.paul@tungstengraphics.com>. -+.PP -+This manual page was written by Thierry Reding <thierry@gilfi.de>, for the -+Debian project and updated by Fernando de Oliveira <famobr at yahoo dot -+com dot br>, for the Linux From Scratch (LFS) project (but may be used by -+others). -+ -diff -Naurp mesa-20.2.1-orig/src/glx/xdemos/glxgears.c mesa-20.2.1/src/glx/xdemos/glxgears.c ---- mesa-20.2.1-orig/src/glx/xdemos/glxgears.c 1969-12-31 18:00:00.000000000 -0600 -+++ mesa-20.2.1/src/glx/xdemos/glxgears.c 2020-10-15 23:06:45.826695773 -0500 -@@ -0,0 +1,809 @@ -+/* -+ * Copyright (C) 1999-2001 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. -+ */ -+ -+/* -+ * This is a port of the infamous "gears" demo to straight GLX (i.e. no GLUT) -+ * Port by Brian Paul 23 March 2001 -+ * -+ * See usage() below for command line options. -+ */ -+ -+ -+#include <math.h> -+#include <stdlib.h> -+#include <stdio.h> -+#include <string.h> -+#include <X11/Xlib.h> -+#include <X11/keysym.h> -+#include <GL/gl.h> -+#include <GL/glx.h> -+#include <GL/glxext.h> -+ -+#ifndef GLX_MESA_swap_control -+#define GLX_MESA_swap_control 1 -+typedef int (*PFNGLXGETSWAPINTERVALMESAPROC)(void); -+#endif -+ -+ -+#define BENCHMARK -+ -+#ifdef BENCHMARK -+ -+/* XXX this probably isn't very portable */ -+ -+#include <sys/time.h> -+#include <unistd.h> -+ -+/* return current time (in seconds) */ -+static double -+current_time(void) -+{ -+ struct timeval tv; -+#ifdef __VMS -+ (void) gettimeofday(&tv, NULL ); -+#else -+ struct timezone tz; -+ (void) gettimeofday(&tv, &tz); -+#endif -+ return (double) tv.tv_sec + tv.tv_usec / 1000000.0; -+} -+ -+#else /*BENCHMARK*/ -+ -+/* dummy */ -+static double -+current_time(void) -+{ -+ /* update this function for other platforms! */ -+ static double t = 0.0; -+ static int warn = 1; -+ if (warn) { -+ fprintf(stderr, "Warning: current_time() not implemented!!\n"); -+ warn = 0; -+ } -+ return t += 1.0; -+} -+ -+#endif /*BENCHMARK*/ -+ -+ -+ -+#ifndef M_PI -+#define M_PI 3.14159265 -+#endif -+ -+ -+/** Event handler results: */ -+#define NOP 0 -+#define EXIT 1 -+#define DRAW 2 -+ -+static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0; -+static GLint gear1, gear2, gear3; -+static GLfloat angle = 0.0; -+ -+static GLboolean fullscreen = GL_FALSE; /* Create a single fullscreen window */ -+static GLboolean stereo = GL_FALSE; /* Enable stereo. */ -+static GLint samples = 0; /* Choose visual with at least N samples. */ -+static GLboolean animate = GL_TRUE; /* Animation */ -+static GLfloat eyesep = 5.0; /* Eye separation. */ -+static GLfloat fix_point = 40.0; /* Fixation point distance. */ -+static GLfloat left, right, asp; /* Stereo frustum params. */ -+ -+ -+/* -+ * -+ * Draw a gear wheel. You'll probably want to call this function when -+ * building a display list since we do a lot of trig here. -+ * -+ * Input: inner_radius - radius of hole at center -+ * outer_radius - radius at center of teeth -+ * width - width of gear -+ * teeth - number of teeth -+ * tooth_depth - depth of tooth -+ */ -+static void -+gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width, -+ GLint teeth, GLfloat tooth_depth) -+{ -+ GLint i; -+ GLfloat r0, r1, r2; -+ GLfloat angle, da; -+ GLfloat u, v, len; -+ -+ r0 = inner_radius; -+ r1 = outer_radius - tooth_depth / 2.0; -+ r2 = outer_radius + tooth_depth / 2.0; -+ -+ da = 2.0 * M_PI / teeth / 4.0; -+ -+ glShadeModel(GL_FLAT); -+ -+ glNormal3f(0.0, 0.0, 1.0); -+ -+ /* draw front face */ -+ glBegin(GL_QUAD_STRIP); -+ for (i = 0; i <= teeth; i++) { -+ angle = i * 2.0 * M_PI / teeth; -+ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); -+ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); -+ if (i < teeth) { -+ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); -+ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -+ width * 0.5); -+ } -+ } -+ glEnd(); -+ -+ /* draw front sides of teeth */ -+ glBegin(GL_QUADS); -+ da = 2.0 * M_PI / teeth / 4.0; -+ for (i = 0; i < teeth; i++) { -+ angle = i * 2.0 * M_PI / teeth; -+ -+ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); -+ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5); -+ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -+ width * 0.5); -+ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -+ width * 0.5); -+ } -+ glEnd(); -+ -+ glNormal3f(0.0, 0.0, -1.0); -+ -+ /* draw back face */ -+ glBegin(GL_QUAD_STRIP); -+ for (i = 0; i <= teeth; i++) { -+ angle = i * 2.0 * M_PI / teeth; -+ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); -+ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); -+ if (i < teeth) { -+ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -+ -width * 0.5); -+ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); -+ } -+ } -+ glEnd(); -+ -+ /* draw back sides of teeth */ -+ glBegin(GL_QUADS); -+ da = 2.0 * M_PI / teeth / 4.0; -+ for (i = 0; i < teeth; i++) { -+ angle = i * 2.0 * M_PI / teeth; -+ -+ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -+ -width * 0.5); -+ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -+ -width * 0.5); -+ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5); -+ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); -+ } -+ glEnd(); -+ -+ /* draw outward faces of teeth */ -+ glBegin(GL_QUAD_STRIP); -+ for (i = 0; i < teeth; i++) { -+ angle = i * 2.0 * M_PI / teeth; -+ -+ glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); -+ glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); -+ u = r2 * cos(angle + da) - r1 * cos(angle); -+ v = r2 * sin(angle + da) - r1 * sin(angle); -+ len = sqrt(u * u + v * v); -+ u /= len; -+ v /= len; -+ glNormal3f(v, -u, 0.0); -+ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5); -+ glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5); -+ glNormal3f(cos(angle), sin(angle), 0.0); -+ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -+ width * 0.5); -+ glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -+ -width * 0.5); -+ u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da); -+ v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da); -+ glNormal3f(v, -u, 0.0); -+ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -+ width * 0.5); -+ glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -+ -width * 0.5); -+ glNormal3f(cos(angle), sin(angle), 0.0); -+ } -+ -+ glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5); -+ glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5); -+ -+ glEnd(); -+ -+ glShadeModel(GL_SMOOTH); -+ -+ /* draw inside radius cylinder */ -+ glBegin(GL_QUAD_STRIP); -+ for (i = 0; i <= teeth; i++) { -+ angle = i * 2.0 * M_PI / teeth; -+ glNormal3f(-cos(angle), -sin(angle), 0.0); -+ glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); -+ glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); -+ } -+ glEnd(); -+} -+ -+ -+static void -+draw(void) -+{ -+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); -+ -+ glPushMatrix(); -+ glRotatef(view_rotx, 1.0, 0.0, 0.0); -+ glRotatef(view_roty, 0.0, 1.0, 0.0); -+ glRotatef(view_rotz, 0.0, 0.0, 1.0); -+ -+ glPushMatrix(); -+ glTranslatef(-3.0, -2.0, 0.0); -+ glRotatef(angle, 0.0, 0.0, 1.0); -+ glCallList(gear1); -+ glPopMatrix(); -+ -+ glPushMatrix(); -+ glTranslatef(3.1, -2.0, 0.0); -+ glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0); -+ glCallList(gear2); -+ glPopMatrix(); -+ -+ glPushMatrix(); -+ glTranslatef(-3.1, 4.2, 0.0); -+ glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0); -+ glCallList(gear3); -+ glPopMatrix(); -+ -+ glPopMatrix(); -+} -+ -+ -+static void -+draw_gears(void) -+{ -+ if (stereo) { -+ /* First left eye. */ -+ glDrawBuffer(GL_BACK_LEFT); -+ -+ glMatrixMode(GL_PROJECTION); -+ glLoadIdentity(); -+ glFrustum(left, right, -asp, asp, 5.0, 60.0); -+ -+ glMatrixMode(GL_MODELVIEW); -+ -+ glPushMatrix(); -+ glTranslated(+0.5 * eyesep, 0.0, 0.0); -+ draw(); -+ glPopMatrix(); -+ -+ /* Then right eye. */ -+ glDrawBuffer(GL_BACK_RIGHT); -+ -+ glMatrixMode(GL_PROJECTION); -+ glLoadIdentity(); -+ glFrustum(-right, -left, -asp, asp, 5.0, 60.0); -+ -+ glMatrixMode(GL_MODELVIEW); -+ -+ glPushMatrix(); -+ glTranslated(-0.5 * eyesep, 0.0, 0.0); -+ draw(); -+ glPopMatrix(); -+ } -+ else { -+ draw(); -+ } -+} -+ -+ -+/** Draw single frame, do SwapBuffers, compute FPS */ -+static void -+draw_frame(Display *dpy, Window win) -+{ -+ static int frames = 0; -+ static double tRot0 = -1.0, tRate0 = -1.0; -+ double dt, t = current_time(); -+ -+ if (tRot0 < 0.0) -+ tRot0 = t; -+ dt = t - tRot0; -+ tRot0 = t; -+ -+ if (animate) { -+ /* advance rotation for next frame */ -+ angle += 70.0 * dt; /* 70 degrees per second */ -+ if (angle > 3600.0) -+ angle -= 3600.0; -+ } -+ -+ draw_gears(); -+ glXSwapBuffers(dpy, win); -+ -+ frames++; -+ -+ if (tRate0 < 0.0) -+ tRate0 = t; -+ if (t - tRate0 >= 5.0) { -+ GLfloat seconds = t - tRate0; -+ GLfloat fps = frames / seconds; -+ printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds, -+ fps); -+ fflush(stdout); -+ tRate0 = t; -+ frames = 0; -+ } -+} -+ -+ -+/* new window size or exposure */ -+static void -+reshape(int width, int height) -+{ -+ glViewport(0, 0, (GLint) width, (GLint) height); -+ -+ if (stereo) { -+ GLfloat w; -+ -+ asp = (GLfloat) height / (GLfloat) width; -+ w = fix_point * (1.0 / 5.0); -+ -+ left = -5.0 * ((w - 0.5 * eyesep) / fix_point); -+ right = 5.0 * ((w + 0.5 * eyesep) / fix_point); -+ } -+ else { -+ GLfloat h = (GLfloat) height / (GLfloat) width; -+ -+ glMatrixMode(GL_PROJECTION); -+ glLoadIdentity(); -+ glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0); -+ } -+ -+ glMatrixMode(GL_MODELVIEW); -+ glLoadIdentity(); -+ glTranslatef(0.0, 0.0, -40.0); -+} -+ -+ -+ -+static void -+init(void) -+{ -+ static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 }; -+ static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 }; -+ static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 }; -+ static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 }; -+ -+ glLightfv(GL_LIGHT0, GL_POSITION, pos); -+ glEnable(GL_CULL_FACE); -+ glEnable(GL_LIGHTING); -+ glEnable(GL_LIGHT0); -+ glEnable(GL_DEPTH_TEST); -+ -+ /* make the gears */ -+ gear1 = glGenLists(1); -+ glNewList(gear1, GL_COMPILE); -+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red); -+ gear(1.0, 4.0, 1.0, 20, 0.7); -+ glEndList(); -+ -+ gear2 = glGenLists(1); -+ glNewList(gear2, GL_COMPILE); -+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green); -+ gear(0.5, 2.0, 2.0, 10, 0.7); -+ glEndList(); -+ -+ gear3 = glGenLists(1); -+ glNewList(gear3, GL_COMPILE); -+ glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue); -+ gear(1.3, 2.0, 0.5, 10, 0.7); -+ glEndList(); -+ -+ glEnable(GL_NORMALIZE); -+} -+ -+ -+/** -+ * Remove window border/decorations. -+ */ -+static void -+no_border( Display *dpy, Window w) -+{ -+ static const unsigned MWM_HINTS_DECORATIONS = (1 << 1); -+ static const int PROP_MOTIF_WM_HINTS_ELEMENTS = 5; -+ -+ typedef struct -+ { -+ unsigned long flags; -+ unsigned long functions; -+ unsigned long decorations; -+ long inputMode; -+ unsigned long status; -+ } PropMotifWmHints; -+ -+ PropMotifWmHints motif_hints; -+ Atom prop, proptype; -+ unsigned long flags = 0; -+ -+ /* setup the property */ -+ motif_hints.flags = MWM_HINTS_DECORATIONS; -+ motif_hints.decorations = flags; -+ -+ /* get the atom for the property */ -+ prop = XInternAtom( dpy, "_MOTIF_WM_HINTS", True ); -+ if (!prop) { -+ /* something went wrong! */ -+ return; -+ } -+ -+ /* not sure this is correct, seems to work, XA_WM_HINTS didn't work */ -+ proptype = prop; -+ -+ XChangeProperty( dpy, w, /* display, window */ -+ prop, proptype, /* property, type */ -+ 32, /* format: 32-bit datums */ -+ PropModeReplace, /* mode */ -+ (unsigned char *) &motif_hints, /* data */ -+ PROP_MOTIF_WM_HINTS_ELEMENTS /* nelements */ -+ ); -+} -+ -+ -+/* -+ * Create an RGB, double-buffered window. -+ * Return the window and context handles. -+ */ -+static void -+make_window( Display *dpy, const char *name, -+ int x, int y, int width, int height, -+ Window *winRet, GLXContext *ctxRet, VisualID *visRet) -+{ -+ int attribs[64]; -+ int i = 0; -+ -+ int scrnum; -+ XSetWindowAttributes attr; -+ unsigned long mask; -+ Window root; -+ Window win; -+ GLXContext ctx; -+ XVisualInfo *visinfo; -+ -+ /* Singleton attributes. */ -+ attribs[i++] = GLX_RGBA; -+ attribs[i++] = GLX_DOUBLEBUFFER; -+ if (stereo) -+ attribs[i++] = GLX_STEREO; -+ -+ /* Key/value attributes. */ -+ attribs[i++] = GLX_RED_SIZE; -+ attribs[i++] = 1; -+ attribs[i++] = GLX_GREEN_SIZE; -+ attribs[i++] = 1; -+ attribs[i++] = GLX_BLUE_SIZE; -+ attribs[i++] = 1; -+ attribs[i++] = GLX_DEPTH_SIZE; -+ attribs[i++] = 1; -+ if (samples > 0) { -+ attribs[i++] = GLX_SAMPLE_BUFFERS; -+ attribs[i++] = 1; -+ attribs[i++] = GLX_SAMPLES; -+ attribs[i++] = samples; -+ } -+ -+ attribs[i++] = None; -+ -+ scrnum = DefaultScreen( dpy ); -+ root = RootWindow( dpy, scrnum ); -+ -+ visinfo = glXChooseVisual(dpy, scrnum, attribs); -+ if (!visinfo) { -+ printf("Error: couldn't get an RGB, Double-buffered"); -+ if (stereo) -+ printf(", Stereo"); -+ if (samples > 0) -+ printf(", Multisample"); -+ printf(" visual\n"); -+ exit(1); -+ } -+ -+ /* window attributes */ -+ attr.background_pixel = 0; -+ attr.border_pixel = 0; -+ attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone); -+ attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask; -+ /* XXX this is a bad way to get a borderless window! */ -+ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; -+ -+ win = XCreateWindow( dpy, root, x, y, width, height, -+ 0, visinfo->depth, InputOutput, -+ visinfo->visual, mask, &attr ); -+ -+ if (fullscreen) -+ no_border(dpy, win); -+ -+ /* set hints and properties */ -+ { -+ XSizeHints sizehints; -+ sizehints.x = x; -+ sizehints.y = y; -+ sizehints.width = width; -+ sizehints.height = height; -+ sizehints.flags = USSize | USPosition; -+ XSetNormalHints(dpy, win, &sizehints); -+ XSetStandardProperties(dpy, win, name, name, -+ None, (char **)NULL, 0, &sizehints); -+ } -+ -+ ctx = glXCreateContext( dpy, visinfo, NULL, True ); -+ if (!ctx) { -+ printf("Error: glXCreateContext failed\n"); -+ exit(1); -+ } -+ -+ *winRet = win; -+ *ctxRet = ctx; -+ *visRet = visinfo->visualid; -+ -+ XFree(visinfo); -+} -+ -+ -+/** -+ * Determine whether or not a GLX extension is supported. -+ */ -+static int -+is_glx_extension_supported(Display *dpy, const char *query) -+{ -+ const int scrnum = DefaultScreen(dpy); -+ const char *glx_extensions = NULL; -+ const size_t len = strlen(query); -+ const char *ptr; -+ -+ if (glx_extensions == NULL) { -+ glx_extensions = glXQueryExtensionsString(dpy, scrnum); -+ } -+ -+ ptr = strstr(glx_extensions, query); -+ return ((ptr != NULL) && ((ptr[len] == ' ') || (ptr[len] == '\0'))); -+} -+ -+ -+/** -+ * Attempt to determine whether or not the display is synched to vblank. -+ */ -+static void -+query_vsync(Display *dpy, GLXDrawable drawable) -+{ -+ int interval = 0; -+ -+#if defined(GLX_EXT_swap_control) -+ if (is_glx_extension_supported(dpy, "GLX_EXT_swap_control")) { -+ unsigned int tmp = -1; -+ glXQueryDrawable(dpy, drawable, GLX_SWAP_INTERVAL_EXT, &tmp); -+ interval = tmp; -+ } else -+#endif -+ if (is_glx_extension_supported(dpy, "GLX_MESA_swap_control")) { -+ PFNGLXGETSWAPINTERVALMESAPROC pglXGetSwapIntervalMESA = -+ (PFNGLXGETSWAPINTERVALMESAPROC) -+ glXGetProcAddressARB((const GLubyte *) "glXGetSwapIntervalMESA"); -+ -+ interval = (*pglXGetSwapIntervalMESA)(); -+ } else if (is_glx_extension_supported(dpy, "GLX_SGI_swap_control")) { -+ /* The default swap interval with this extension is 1. Assume that it -+ * is set to the default. -+ * -+ * Many Mesa-based drivers default to 0, but all of these drivers also -+ * export GLX_MESA_swap_control. In that case, this branch will never -+ * be taken, and the correct result should be reported. -+ */ -+ interval = 1; -+ } -+ -+ -+ if (interval > 0) { -+ printf("Running synchronized to the vertical refresh. The framerate should be\n"); -+ if (interval == 1) { -+ printf("approximately the same as the monitor refresh rate.\n"); -+ } else if (interval > 1) { -+ printf("approximately 1/%d the monitor refresh rate.\n", -+ interval); -+ } -+ } -+} -+ -+/** -+ * Handle one X event. -+ * \return NOP, EXIT or DRAW -+ */ -+static int -+handle_event(Display *dpy, Window win, XEvent *event) -+{ -+ (void) dpy; -+ (void) win; -+ -+ switch (event->type) { -+ case Expose: -+ return DRAW; -+ case ConfigureNotify: -+ reshape(event->xconfigure.width, event->xconfigure.height); -+ break; -+ case KeyPress: -+ { -+ char buffer[10]; -+ int code; -+ code = XLookupKeysym(&event->xkey, 0); -+ if (code == XK_Left) { -+ view_roty += 5.0; -+ } -+ else if (code == XK_Right) { -+ view_roty -= 5.0; -+ } -+ else if (code == XK_Up) { -+ view_rotx += 5.0; -+ } -+ else if (code == XK_Down) { -+ view_rotx -= 5.0; -+ } -+ else { -+ XLookupString(&event->xkey, buffer, sizeof(buffer), -+ NULL, NULL); -+ if (buffer[0] == 27) { -+ /* escape */ -+ return EXIT; -+ } -+ else if (buffer[0] == 'a' || buffer[0] == 'A') { -+ animate = !animate; -+ } -+ } -+ return DRAW; -+ } -+ } -+ return NOP; -+} -+ -+ -+static void -+event_loop(Display *dpy, Window win) -+{ -+ while (1) { -+ int op; -+ while (!animate || XPending(dpy) > 0) { -+ XEvent event; -+ XNextEvent(dpy, &event); -+ op = handle_event(dpy, win, &event); -+ if (op == EXIT) -+ return; -+ else if (op == DRAW) -+ break; -+ } -+ -+ draw_frame(dpy, win); -+ } -+} -+ -+ -+static void -+usage(void) -+{ -+ printf("Usage:\n"); -+ printf(" -display <displayname> set the display to run on\n"); -+ printf(" -stereo run in stereo mode\n"); -+ printf(" -samples N run in multisample mode with at least N samples\n"); -+ printf(" -fullscreen run in fullscreen mode\n"); -+ printf(" -info display OpenGL renderer info\n"); -+ printf(" -geometry WxH+X+Y window geometry\n"); -+} -+ -+ -+int -+main(int argc, char *argv[]) -+{ -+ unsigned int winWidth = 300, winHeight = 300; -+ int x = 0, y = 0; -+ Display *dpy; -+ Window win; -+ GLXContext ctx; -+ char *dpyName = NULL; -+ GLboolean printInfo = GL_FALSE; -+ VisualID visId; -+ int i; -+ -+ for (i = 1; i < argc; i++) { -+ if (strcmp(argv[i], "-display") == 0) { -+ dpyName = argv[i+1]; -+ i++; -+ } -+ else if (strcmp(argv[i], "-info") == 0) { -+ printInfo = GL_TRUE; -+ } -+ else if (strcmp(argv[i], "-stereo") == 0) { -+ stereo = GL_TRUE; -+ } -+ else if (i < argc-1 && strcmp(argv[i], "-samples") == 0) { -+ samples = strtod(argv[i+1], NULL ); -+ ++i; -+ } -+ else if (strcmp(argv[i], "-fullscreen") == 0) { -+ fullscreen = GL_TRUE; -+ } -+ else if (i < argc-1 && strcmp(argv[i], "-geometry") == 0) { -+ XParseGeometry(argv[i+1], &x, &y, &winWidth, &winHeight); -+ i++; -+ } -+ else { -+ usage(); -+ return -1; -+ } -+ } -+ -+ dpy = XOpenDisplay(dpyName); -+ if (!dpy) { -+ printf("Error: couldn't open display %s\n", -+ dpyName ? dpyName : getenv("DISPLAY")); -+ return -1; -+ } -+ -+ if (fullscreen) { -+ int scrnum = DefaultScreen(dpy); -+ -+ x = 0; y = 0; -+ winWidth = DisplayWidth(dpy, scrnum); -+ winHeight = DisplayHeight(dpy, scrnum); -+ } -+ -+ make_window(dpy, "glxgears", x, y, winWidth, winHeight, &win, &ctx, &visId); -+ XMapWindow(dpy, win); -+ glXMakeCurrent(dpy, win, ctx); -+ query_vsync(dpy, win); -+ -+ if (printInfo) { -+ printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); -+ printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); -+ printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); -+ printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); -+ printf("VisualID %d, 0x%x\n", (int) visId, (int) visId); -+ } -+ -+ init(); -+ -+ /* Set initial projection/viewing transformation. -+ * We can't be sure we'll get a ConfigureNotify event when the window -+ * first appears. -+ */ -+ reshape(winWidth, winHeight); -+ -+ event_loop(dpy, win); -+ -+ glDeleteLists(gear1, 1); -+ glDeleteLists(gear2, 1); -+ glDeleteLists(gear3, 1); -+ glXMakeCurrent(dpy, None, NULL); -+ glXDestroyContext(dpy, ctx); -+ XDestroyWindow(dpy, win); -+ XCloseDisplay(dpy); -+ -+ return 0; -+} -diff -Naurp mesa-20.2.1-orig/src/glx/xdemos/glxinfo.1 mesa-20.2.1/src/glx/xdemos/glxinfo.1 ---- mesa-20.2.1-orig/src/glx/xdemos/glxinfo.1 1969-12-31 18:00:00.000000000 -0600 -+++ mesa-20.2.1/src/glx/xdemos/glxinfo.1 2020-10-15 23:06:45.826695773 -0500 -@@ -0,0 +1,46 @@ -+.TH glxinfo 1 "2006-11-29" -+.SH NAME -+glxinfo \- show information about the GLX implementation -+.SH SYNOPSIS -+.B glxinfo -+.RI [ options ] -+.SH DESCRIPTION -+The \fIglxinfo\fP program shows information about the OpenGL and GLX -+implementations running on a given X display. -+.PP -+The information includes details about the server- and client-side GLX -+implementation, the OpenGL and GLU implementations as well as a list -+of available GLX visuals. -+.SH OPTIONS -+.TP 8 -+.B \-v -+Print visuals info in verbose form. -+.TP 8 -+.B \-t -+Print verbose table. -+.TP 8 -+.B \-display \fIdisplay\fP -+Specify the X display to interrogate. -+.TP 8 -+.B \-h -+Print usage information. -+.TP 8 -+.B \-i -+Force an indirect rendering context. -+.TP 8 -+.B \-b -+Find the "best" visual and print its number. -+.TP 8 -+.B \-l -+Print interesting OpenGL limits. -+.TP 8 -+.B \-s -+Print a single extension per line. -+.SH AUTHOR -+glxinfo was written by Brian Paul <brian.paul@tungstengraphics.com>. -+.PP -+This manual page was written by Thierry Reding <thierry@gilfi.de>, for the -+Debian project and updated by Fernando de Oliveira <famobr at yahoo dot -+com dot br>, for the Linux From Scratch (LFS) project (but may be used by -+others). -+ -diff -Naurp mesa-20.2.1-orig/src/glx/xdemos/glxinfo.c mesa-20.2.1/src/glx/xdemos/glxinfo.c ---- mesa-20.2.1-orig/src/glx/xdemos/glxinfo.c 1969-12-31 18:00:00.000000000 -0600 -+++ mesa-20.2.1/src/glx/xdemos/glxinfo.c 2020-10-15 23:06:45.826695773 -0500 -@@ -0,0 +1,1281 @@ -+/* -+ * Copyright (C) 1999-2006 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. -+ */ -+ -+ -+/* -+ * This program is a work-alike of the IRIX glxinfo program. -+ * Command line options: -+ * -t print wide table -+ * -v print verbose information -+ * -display DisplayName specify the X display to interogate -+ * -B brief, print only the basics -+ * -b only print ID of "best" visual on screen 0 -+ * -i use indirect rendering connection only -+ * -l print interesting OpenGL limits (added 5 Sep 2002) -+ * -+ * Brian Paul 26 January 2000 -+ */ -+ -+#define GLX_GLXEXT_PROTOTYPES -+#define GL_GLEXT_PROTOTYPES -+ -+#include <assert.h> -+#include <X11/Xlib.h> -+#include <X11/Xutil.h> -+#include <GL/gl.h> -+#include <GL/glx.h> -+#include <stdio.h> -+#include <string.h> -+#include <stdlib.h> -+#include "glinfo_common.h" -+ -+ -+#ifndef GLX_NONE_EXT -+#define GLX_NONE_EXT 0x8000 -+#endif -+ -+#ifndef GLX_TRANSPARENT_RGB -+#define GLX_TRANSPARENT_RGB 0x8008 -+#endif -+ -+#ifndef GLX_RGBA_BIT -+#define GLX_RGBA_BIT 0x00000001 -+#endif -+ -+#ifndef GLX_COLOR_INDEX_BIT -+#define GLX_COLOR_INDEX_BIT 0x00000002 -+#endif -+ -+ -+struct visual_attribs -+{ -+ /* X visual attribs */ -+ int id; /* May be visual ID or FBConfig ID */ -+ int vis_id; /* Visual ID. Only set for FBConfigs */ -+ int klass; -+ int depth; -+ int redMask, greenMask, blueMask; -+ int colormapSize; -+ int bitsPerRGB; -+ -+ /* GL visual attribs */ -+ int supportsGL; -+ int drawableType; -+ int transparentType; -+ int transparentRedValue; -+ int transparentGreenValue; -+ int transparentBlueValue; -+ int transparentAlphaValue; -+ int transparentIndexValue; -+ int bufferSize; -+ int level; -+ int render_type; -+ int doubleBuffer; -+ int stereo; -+ int auxBuffers; -+ int redSize, greenSize, blueSize, alphaSize; -+ int depthSize; -+ int stencilSize; -+ int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize; -+ int numSamples, numMultisample; -+ int visualCaveat; -+ int floatComponents; -+ int packedfloatComponents; -+ int srgb; -+}; -+ -+ -+/** -+ * Version of the context that was created -+ * -+ * 20, 21, 30, 31, 32, etc. -+ */ -+static int version; -+ -+/** -+ * GL Error checking/warning. -+ */ -+static void -+CheckError(int line) -+{ -+ int n; -+ n = glGetError(); -+ if (n) -+ printf("Warning: GL error 0x%x at line %d\n", n, line); -+} -+ -+ -+static void -+print_display_info(Display *dpy) -+{ -+ printf("name of display: %s\n", DisplayString(dpy)); -+} -+ -+ -+/** -+ * Choose a simple FB Config. -+ */ -+static GLXFBConfig * -+choose_fb_config(Display *dpy, int scrnum) -+{ -+ int fbAttribSingle[] = { -+ GLX_RENDER_TYPE, GLX_RGBA_BIT, -+ GLX_RED_SIZE, 1, -+ GLX_GREEN_SIZE, 1, -+ GLX_BLUE_SIZE, 1, -+ GLX_DOUBLEBUFFER, False, -+ None }; -+ int fbAttribDouble[] = { -+ GLX_RENDER_TYPE, GLX_RGBA_BIT, -+ GLX_RED_SIZE, 1, -+ GLX_GREEN_SIZE, 1, -+ GLX_BLUE_SIZE, 1, -+ GLX_DOUBLEBUFFER, True, -+ None }; -+ GLXFBConfig *configs; -+ int nConfigs; -+ -+ configs = glXChooseFBConfig(dpy, scrnum, fbAttribSingle, &nConfigs); -+ if (!configs) -+ configs = glXChooseFBConfig(dpy, scrnum, fbAttribDouble, &nConfigs); -+ -+ return configs; -+} -+ -+ -+static Bool CreateContextErrorFlag; -+ -+static int -+create_context_error_handler(Display *dpy, XErrorEvent *error) -+{ -+ (void) dpy; -+ (void) error->error_code; -+ CreateContextErrorFlag = True; -+ return 0; -+} -+ -+ -+/** -+ * Try to create a GLX context of the given version with flags/options. -+ * Note: A version number is required in order to get a core profile -+ * (at least w/ NVIDIA). -+ */ -+static GLXContext -+create_context_flags(Display *dpy, GLXFBConfig fbconfig, int major, int minor, -+ int contextFlags, int profileMask, Bool direct) -+{ -+#ifdef GLX_ARB_create_context -+ static PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB_func = 0; -+ static Bool firstCall = True; -+ int (*old_handler)(Display *, XErrorEvent *); -+ GLXContext context; -+ int attribs[20]; -+ int n = 0; -+ -+ if (firstCall) { -+ /* See if we have GLX_ARB_create_context_profile and get pointer to -+ * glXCreateContextAttribsARB() function. -+ */ -+ const char *glxExt = glXQueryExtensionsString(dpy, 0); -+ if (extension_supported("GLX_ARB_create_context_profile", glxExt)) { -+ glXCreateContextAttribsARB_func = (PFNGLXCREATECONTEXTATTRIBSARBPROC) -+ glXGetProcAddress((const GLubyte *) "glXCreateContextAttribsARB"); -+ } -+ firstCall = False; -+ } -+ -+ if (!glXCreateContextAttribsARB_func) -+ return 0; -+ -+ /* setup attribute array */ -+ if (major) { -+ attribs[n++] = GLX_CONTEXT_MAJOR_VERSION_ARB; -+ attribs[n++] = major; -+ attribs[n++] = GLX_CONTEXT_MINOR_VERSION_ARB; -+ attribs[n++] = minor; -+ } -+ if (contextFlags) { -+ attribs[n++] = GLX_CONTEXT_FLAGS_ARB; -+ attribs[n++] = contextFlags; -+ } -+#ifdef GLX_ARB_create_context_profile -+ if (profileMask) { -+ attribs[n++] = GLX_CONTEXT_PROFILE_MASK_ARB; -+ attribs[n++] = profileMask; -+ } -+#endif -+ attribs[n++] = 0; -+ -+ /* install X error handler */ -+ old_handler = XSetErrorHandler(create_context_error_handler); -+ CreateContextErrorFlag = False; -+ -+ /* try creating context */ -+ context = glXCreateContextAttribsARB_func(dpy, -+ fbconfig, -+ 0, /* share_context */ -+ direct, -+ attribs); -+ -+ /* restore error handler */ -+ XSetErrorHandler(old_handler); -+ -+ if (CreateContextErrorFlag) -+ context = 0; -+ -+ if (context && direct) { -+ if (!glXIsDirect(dpy, context)) { -+ glXDestroyContext(dpy, context); -+ return 0; -+ } -+ } -+ -+ return context; -+#else -+ return 0; -+#endif -+} -+ -+ -+/** -+ * Try to create a GLX context of the newest version. -+ */ -+static GLXContext -+create_context_with_config(Display *dpy, GLXFBConfig config, -+ Bool coreProfile, Bool es2Profile, Bool direct) -+{ -+ GLXContext ctx = 0; -+ -+ if (coreProfile) { -+ /* Try to create a core profile, starting with the newest version of -+ * GL that we're aware of. If we don't specify the version -+ */ -+ int i; -+ for (i = 0; gl_versions[i].major > 0; i++) { -+ /* don't bother below GL 3.0 */ -+ if (gl_versions[i].major == 3 && -+ gl_versions[i].minor == 0) -+ return 0; -+ ctx = create_context_flags(dpy, config, -+ gl_versions[i].major, -+ gl_versions[i].minor, -+ 0x0, -+ GLX_CONTEXT_CORE_PROFILE_BIT_ARB, -+ direct); -+ if (ctx) -+ return ctx; -+ } -+ /* couldn't get core profile context */ -+ return 0; -+ } -+ -+ if (es2Profile) { -+#ifdef GLX_CONTEXT_ES2_PROFILE_BIT_EXT -+ if (extension_supported("GLX_EXT_create_context_es2_profile", -+ glXQueryExtensionsString(dpy, 0))) { -+ ctx = create_context_flags(dpy, config, 2, 0, 0x0, -+ GLX_CONTEXT_ES2_PROFILE_BIT_EXT, -+ direct); -+ return ctx; -+ } -+#endif -+ return 0; -+ } -+ -+ /* GLX should return a context of the latest GL version that supports -+ * the full profile. -+ */ -+ ctx = glXCreateNewContext(dpy, config, GLX_RGBA_TYPE, NULL, direct); -+ -+ /* make sure the context is direct, if direct was requested */ -+ if (ctx && direct) { -+ if (!glXIsDirect(dpy, ctx)) { -+ glXDestroyContext(dpy, ctx); -+ return 0; -+ } -+ } -+ -+ return ctx; -+} -+ -+ -+static XVisualInfo * -+choose_xvisinfo(Display *dpy, int scrnum) -+{ -+ int attribSingle[] = { -+ GLX_RGBA, -+ GLX_RED_SIZE, 1, -+ GLX_GREEN_SIZE, 1, -+ GLX_BLUE_SIZE, 1, -+ None }; -+ int attribDouble[] = { -+ GLX_RGBA, -+ GLX_RED_SIZE, 1, -+ GLX_GREEN_SIZE, 1, -+ GLX_BLUE_SIZE, 1, -+ GLX_DOUBLEBUFFER, -+ None }; -+ XVisualInfo *visinfo; -+ -+ visinfo = glXChooseVisual(dpy, scrnum, attribSingle); -+ if (!visinfo) -+ visinfo = glXChooseVisual(dpy, scrnum, attribDouble); -+ -+ return visinfo; -+} -+ -+ -+static void -+query_renderer(void) -+{ -+#ifdef GLX_MESA_query_renderer -+ PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC queryInteger; -+ PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC queryString; -+ unsigned int v[3]; -+ -+ queryInteger = (PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC) -+ glXGetProcAddressARB((const GLubyte *) -+ "glXQueryCurrentRendererIntegerMESA"); -+ queryString = (PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC) -+ glXGetProcAddressARB((const GLubyte *) -+ "glXQueryCurrentRendererStringMESA"); -+ -+ printf("Extended renderer info (GLX_MESA_query_renderer):\n"); -+ queryInteger(GLX_RENDERER_VENDOR_ID_MESA, v); -+ printf(" Vendor: %s (0x%x)\n", -+ queryString(GLX_RENDERER_VENDOR_ID_MESA), *v); -+ queryInteger(GLX_RENDERER_DEVICE_ID_MESA, v); -+ printf(" Device: %s (0x%x)\n", -+ queryString(GLX_RENDERER_DEVICE_ID_MESA), *v); -+ queryInteger(GLX_RENDERER_VERSION_MESA, v); -+ printf(" Version: %d.%d.%d\n", v[0], v[1], v[2]); -+ queryInteger(GLX_RENDERER_ACCELERATED_MESA, v); -+ printf(" Accelerated: %s\n", *v ? "yes" : "no"); -+ queryInteger(GLX_RENDERER_VIDEO_MEMORY_MESA, v); -+ printf(" Video memory: %dMB\n", *v); -+ queryInteger(GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA, v); -+ printf(" Unified memory: %s\n", *v ? "yes" : "no"); -+ queryInteger(GLX_RENDERER_PREFERRED_PROFILE_MESA, v); -+ printf(" Preferred profile: %s (0x%x)\n", -+ *v == GLX_CONTEXT_CORE_PROFILE_BIT_ARB ? "core" : -+ *v == GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB ? "compat" : -+ "unknown", *v); -+ queryInteger(GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA, v); -+ printf(" Max core profile version: %d.%d\n", v[0], v[1]); -+ queryInteger(GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA, v); -+ printf(" Max compat profile version: %d.%d\n", v[0], v[1]); -+ queryInteger(GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA, v); -+ printf(" Max GLES1 profile version: %d.%d\n", v[0], v[1]); -+ queryInteger(GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA, v); -+ printf(" Max GLES[23] profile version: %d.%d\n", v[0], v[1]); -+#endif -+} -+ -+ -+static Bool -+print_screen_info(Display *dpy, int scrnum, -+ const struct options *opts, -+ Bool coreProfile, Bool es2Profile, Bool limits, -+ Bool coreWorked) -+{ -+ Window win; -+ XSetWindowAttributes attr; -+ unsigned long mask; -+ Window root; -+ GLXContext ctx = NULL; -+ XVisualInfo *visinfo; -+ int width = 100, height = 100; -+ GLXFBConfig *fbconfigs; -+ const char *oglstring = coreProfile ? "OpenGL core profile" : -+ es2Profile ? "OpenGL ES profile" : "OpenGL"; -+ -+ root = RootWindow(dpy, scrnum); -+ -+ /* -+ * Choose FBConfig or XVisualInfo and create a context. -+ */ -+ fbconfigs = choose_fb_config(dpy, scrnum); -+ if (fbconfigs) { -+ ctx = create_context_with_config(dpy, fbconfigs[0], -+ coreProfile, es2Profile, -+ opts->allowDirect); -+ if (!ctx && opts->allowDirect && !coreProfile) { -+ /* try indirect */ -+ ctx = create_context_with_config(dpy, fbconfigs[0], -+ coreProfile, es2Profile, False); -+ } -+ -+ visinfo = glXGetVisualFromFBConfig(dpy, fbconfigs[0]); -+ XFree(fbconfigs); -+ } -+ else if (!coreProfile && !es2Profile) { -+ visinfo = choose_xvisinfo(dpy, scrnum); -+ if (visinfo) -+ ctx = glXCreateContext(dpy, visinfo, NULL, opts->allowDirect); -+ } else -+ visinfo = NULL; -+ -+ if (!visinfo && !coreProfile && !es2Profile) { -+ fprintf(stderr, "Error: couldn't find RGB GLX visual or fbconfig\n"); -+ return False; -+ } -+ -+ if (!ctx) { -+ if (!coreProfile && !es2Profile) -+ fprintf(stderr, "Error: glXCreateContext failed\n"); -+ XFree(visinfo); -+ return False; -+ } -+ -+ /* -+ * Create a window so that we can just bind the context. -+ */ -+ 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); -+ -+ if (glXMakeCurrent(dpy, win, ctx)) { -+ const char *serverVendor = glXQueryServerString(dpy, scrnum, GLX_VENDOR); -+ const char *serverVersion = glXQueryServerString(dpy, scrnum, GLX_VERSION); -+ const char *serverExtensions = glXQueryServerString(dpy, scrnum, GLX_EXTENSIONS); -+ const char *clientVendor = glXGetClientString(dpy, GLX_VENDOR); -+ const char *clientVersion = glXGetClientString(dpy, GLX_VERSION); -+ const char *clientExtensions = glXGetClientString(dpy, GLX_EXTENSIONS); -+ const char *glxExtensions = glXQueryExtensionsString(dpy, scrnum); -+ const char *glVendor = (const char *) glGetString(GL_VENDOR); -+ const char *glRenderer = (const char *) glGetString(GL_RENDERER); -+ const char *glVersion = (const char *) glGetString(GL_VERSION); -+ char *glExtensions = NULL; -+ int glxVersionMajor = 0; -+ int glxVersionMinor = 0; -+ char *displayName = NULL; -+ char *colon = NULL, *period = NULL; -+ struct ext_functions extfuncs; -+ -+ CheckError(__LINE__); -+ -+ /* Get some ext functions */ -+ extfuncs.GetProgramivARB = (GETPROGRAMIVARBPROC) -+ glXGetProcAddressARB((GLubyte *) "glGetProgramivARB"); -+ extfuncs.GetStringi = (GETSTRINGIPROC) -+ glXGetProcAddressARB((GLubyte *) "glGetStringi"); -+ extfuncs.GetConvolutionParameteriv = (GETCONVOLUTIONPARAMETERIVPROC) -+ glXGetProcAddressARB((GLubyte *) "glGetConvolutionParameteriv"); -+ -+ if (!glXQueryVersion(dpy, & glxVersionMajor, & glxVersionMinor)) { -+ fprintf(stderr, "Error: glXQueryVersion failed\n"); -+ exit(1); -+ } -+ -+ /* Get list of GL extensions */ -+ if (coreProfile && extfuncs.GetStringi) -+ glExtensions = build_core_profile_extension_list(&extfuncs); -+ if (!glExtensions) { -+ coreProfile = False; -+ glExtensions = (char *) glGetString(GL_EXTENSIONS); -+ } -+ -+ CheckError(__LINE__); -+ -+ if (!coreWorked) { -+ /* Strip the screen number from the display name, if present. */ -+ if (!(displayName = (char *) malloc(strlen(DisplayString(dpy)) + 1))) { -+ fprintf(stderr, "Error: malloc() failed\n"); -+ exit(1); -+ } -+ strcpy(displayName, DisplayString(dpy)); -+ colon = strrchr(displayName, ':'); -+ if (colon) { -+ period = strchr(colon, '.'); -+ if (period) -+ *period = '\0'; -+ } -+ -+ printf("display: %s screen: %d\n", displayName, scrnum); -+ free(displayName); -+ printf("direct rendering: "); -+ if (glXIsDirect(dpy, ctx)) { -+ printf("Yes\n"); -+ } -+ else { -+ if (!opts->allowDirect) { -+ printf("No (-i specified)\n"); -+ } -+ else if (getenv("LIBGL_ALWAYS_INDIRECT")) { -+ printf("No (LIBGL_ALWAYS_INDIRECT set)\n"); -+ } -+ else { -+ printf("No (If you want to find out why, try setting " -+ "LIBGL_DEBUG=verbose)\n"); -+ } -+ } -+ if (opts->mode != Brief) { -+ printf("server glx vendor string: %s\n", serverVendor); -+ printf("server glx version string: %s\n", serverVersion); -+ printf("server glx extensions:\n"); -+ print_extension_list(serverExtensions, opts->singleLine); -+ printf("client glx vendor string: %s\n", clientVendor); -+ printf("client glx version string: %s\n", clientVersion); -+ printf("client glx extensions:\n"); -+ print_extension_list(clientExtensions, opts->singleLine); -+ printf("GLX version: %u.%u\n", glxVersionMajor, glxVersionMinor); -+ printf("GLX extensions:\n"); -+ print_extension_list(glxExtensions, opts->singleLine); -+ } -+ if (strstr(glxExtensions, "GLX_MESA_query_renderer")) -+ query_renderer(); -+ printf("OpenGL vendor string: %s\n", glVendor); -+ printf("OpenGL renderer string: %s\n", glRenderer); -+ } else -+ printf("\n"); -+ -+ printf("%s version string: %s\n", oglstring, glVersion); -+ -+ version = (glVersion[0] - '0') * 10 + (glVersion[2] - '0'); -+ -+ CheckError(__LINE__); -+ -+#ifdef GL_VERSION_2_0 -+ if (version >= 20) { -+ char *v = (char *) glGetString(GL_SHADING_LANGUAGE_VERSION); -+ printf("%s shading language version string: %s\n", oglstring, v); -+ } -+#endif -+ CheckError(__LINE__); -+#ifdef GL_VERSION_3_0 -+ if (version >= 30 && !es2Profile) { -+ GLint flags; -+ glGetIntegerv(GL_CONTEXT_FLAGS, &flags); -+ printf("%s context flags: %s\n", oglstring, context_flags_string(flags)); -+ } -+#endif -+ CheckError(__LINE__); -+#ifdef GL_VERSION_3_2 -+ if (version >= 32 && !es2Profile) { -+ GLint mask; -+ glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask); -+ printf("%s profile mask: %s\n", oglstring, profile_mask_string(mask)); -+ } -+#endif -+ -+ CheckError(__LINE__); -+ -+ if (opts->mode != Brief) { -+ printf("%s extensions:\n", oglstring); -+ print_extension_list(glExtensions, opts->singleLine); -+ } -+ -+ if (limits) { -+ print_limits(glExtensions, oglstring, version, &extfuncs); -+ } -+ -+ if (coreProfile) -+ free(glExtensions); -+ } -+ else { -+ fprintf(stderr, "Error: glXMakeCurrent failed\n"); -+ } -+ -+ glXDestroyContext(dpy, ctx); -+ XFree(visinfo); -+ XDestroyWindow(dpy, win); -+ XSync(dpy, 1); -+ return True; -+} -+ -+ -+static const char * -+visual_class_name(int cls) -+{ -+ switch (cls) { -+ case StaticColor: -+ return "StaticColor"; -+ case PseudoColor: -+ return "PseudoColor"; -+ case StaticGray: -+ return "StaticGray"; -+ case GrayScale: -+ return "GrayScale"; -+ case TrueColor: -+ return "TrueColor"; -+ case DirectColor: -+ return "DirectColor"; -+ default: -+ return ""; -+ } -+} -+ -+static const char * -+visual_drawable_type(int type) -+{ -+ const static struct bit_info bits[] = { -+ { GLX_WINDOW_BIT, "window" }, -+ { GLX_PIXMAP_BIT, "pixmap" }, -+ { GLX_PBUFFER_BIT, "pbuffer" } -+ }; -+ -+ return bitmask_to_string(bits, ELEMENTS(bits), type); -+} -+ -+static const char * -+visual_class_abbrev(int cls) -+{ -+ switch (cls) { -+ case StaticColor: -+ return "sc"; -+ case PseudoColor: -+ return "pc"; -+ case StaticGray: -+ return "sg"; -+ case GrayScale: -+ return "gs"; -+ case TrueColor: -+ return "tc"; -+ case DirectColor: -+ return "dc"; -+ default: -+ return ""; -+ } -+} -+ -+static const char * -+visual_render_type_name(int type) -+{ -+ switch (type) { -+ case GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT: -+ return "ufloat"; -+ case GLX_RGBA_FLOAT_BIT_ARB: -+ return "float"; -+ case GLX_RGBA_BIT: -+ return "rgba"; -+ case GLX_COLOR_INDEX_BIT: -+ return "ci"; -+ case GLX_RGBA_BIT | GLX_COLOR_INDEX_BIT: -+ return "rgba|ci"; -+ default: -+ return ""; -+ } -+} -+ -+static const char * -+caveat_string(int caveat) -+{ -+ switch (caveat) { -+#ifdef GLX_EXT_visual_rating -+ case GLX_SLOW_VISUAL_EXT: -+ return "Slow"; -+ case GLX_NON_CONFORMANT_VISUAL_EXT: -+ return "Ncon"; -+ case GLX_NONE_EXT: -+ /* fall-through */ -+#endif -+ case 0: -+ /* fall-through */ -+ default: -+ return "None"; -+ } -+} -+ -+ -+static Bool -+get_visual_attribs(Display *dpy, XVisualInfo *vInfo, -+ struct visual_attribs *attribs) -+{ -+ const char *ext = glXQueryExtensionsString(dpy, vInfo->screen); -+ int rgba; -+ -+ memset(attribs, 0, sizeof(struct visual_attribs)); -+ -+ attribs->id = vInfo->visualid; -+#if defined(__cplusplus) || defined(c_plusplus) -+ attribs->klass = vInfo->c_class; -+#else -+ attribs->klass = vInfo->class; -+#endif -+ attribs->depth = vInfo->depth; -+ attribs->redMask = vInfo->red_mask; -+ attribs->greenMask = vInfo->green_mask; -+ attribs->blueMask = vInfo->blue_mask; -+ attribs->colormapSize = vInfo->colormap_size; -+ attribs->bitsPerRGB = vInfo->bits_per_rgb; -+ -+ if (glXGetConfig(dpy, vInfo, GLX_USE_GL, &attribs->supportsGL) != 0 || -+ !attribs->supportsGL) -+ return False; -+ glXGetConfig(dpy, vInfo, GLX_BUFFER_SIZE, &attribs->bufferSize); -+ glXGetConfig(dpy, vInfo, GLX_LEVEL, &attribs->level); -+ glXGetConfig(dpy, vInfo, GLX_RGBA, &rgba); -+ if (rgba) -+ attribs->render_type = GLX_RGBA_BIT; -+ else -+ attribs->render_type = GLX_COLOR_INDEX_BIT; -+ -+ glXGetConfig(dpy, vInfo, GLX_DRAWABLE_TYPE, &attribs->drawableType); -+ glXGetConfig(dpy, vInfo, GLX_DOUBLEBUFFER, &attribs->doubleBuffer); -+ glXGetConfig(dpy, vInfo, GLX_STEREO, &attribs->stereo); -+ glXGetConfig(dpy, vInfo, GLX_AUX_BUFFERS, &attribs->auxBuffers); -+ glXGetConfig(dpy, vInfo, GLX_RED_SIZE, &attribs->redSize); -+ glXGetConfig(dpy, vInfo, GLX_GREEN_SIZE, &attribs->greenSize); -+ glXGetConfig(dpy, vInfo, GLX_BLUE_SIZE, &attribs->blueSize); -+ glXGetConfig(dpy, vInfo, GLX_ALPHA_SIZE, &attribs->alphaSize); -+ glXGetConfig(dpy, vInfo, GLX_DEPTH_SIZE, &attribs->depthSize); -+ glXGetConfig(dpy, vInfo, GLX_STENCIL_SIZE, &attribs->stencilSize); -+ glXGetConfig(dpy, vInfo, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize); -+ glXGetConfig(dpy, vInfo, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize); -+ glXGetConfig(dpy, vInfo, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize); -+ glXGetConfig(dpy, vInfo, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize); -+ -+ /* get transparent pixel stuff */ -+ glXGetConfig(dpy, vInfo,GLX_TRANSPARENT_TYPE, &attribs->transparentType); -+ if (attribs->transparentType == GLX_TRANSPARENT_RGB) { -+ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue); -+ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue); -+ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue); -+ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue); -+ } -+ else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) { -+ glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue); -+ } -+ -+ /* multisample attribs */ -+#ifdef GLX_ARB_multisample -+ if (ext && strstr(ext, "GLX_ARB_multisample")) { -+ glXGetConfig(dpy, vInfo, GLX_SAMPLE_BUFFERS_ARB, &attribs->numMultisample); -+ glXGetConfig(dpy, vInfo, GLX_SAMPLES_ARB, &attribs->numSamples); -+ } -+#endif -+ else { -+ attribs->numSamples = 0; -+ attribs->numMultisample = 0; -+ } -+ -+#if defined(GLX_EXT_visual_rating) -+ if (ext && strstr(ext, "GLX_EXT_visual_rating")) { -+ glXGetConfig(dpy, vInfo, GLX_VISUAL_CAVEAT_EXT, &attribs->visualCaveat); -+ } -+ else { -+ attribs->visualCaveat = GLX_NONE_EXT; -+ } -+#else -+ attribs->visualCaveat = 0; -+#endif -+ -+#if defined(GLX_EXT_framebuffer_sRGB) -+ if (ext && strstr(ext, "GLX_EXT_framebuffer_sRGB")) { -+ glXGetConfig(dpy, vInfo, GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, &attribs->srgb); -+ } -+#endif -+ -+ return True; -+} -+ -+#ifdef GLX_VERSION_1_3 -+ -+static int -+glx_token_to_visual_class(int visual_type) -+{ -+ switch (visual_type) { -+ case GLX_TRUE_COLOR: -+ return TrueColor; -+ case GLX_DIRECT_COLOR: -+ return DirectColor; -+ case GLX_PSEUDO_COLOR: -+ return PseudoColor; -+ case GLX_STATIC_COLOR: -+ return StaticColor; -+ case GLX_GRAY_SCALE: -+ return GrayScale; -+ case GLX_STATIC_GRAY: -+ return StaticGray; -+ case GLX_NONE: -+ default: -+ return None; -+ } -+} -+ -+static Bool -+get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig, -+ struct visual_attribs *attribs) -+{ -+ const char *ext = glXQueryExtensionsString(dpy, 0); -+ int visual_type; -+ XVisualInfo *vInfo; -+ -+ memset(attribs, 0, sizeof(struct visual_attribs)); -+ -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_FBCONFIG_ID, &attribs->id); -+ -+ vInfo = glXGetVisualFromFBConfig(dpy, fbconfig); -+ -+ if (vInfo != NULL) { -+ attribs->vis_id = vInfo->visualid; -+ attribs->depth = vInfo->depth; -+ attribs->redMask = vInfo->red_mask; -+ attribs->greenMask = vInfo->green_mask; -+ attribs->blueMask = vInfo->blue_mask; -+ attribs->colormapSize = vInfo->colormap_size; -+ attribs->bitsPerRGB = vInfo->bits_per_rgb; -+ } -+ -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_X_VISUAL_TYPE, &visual_type); -+ attribs->klass = glx_token_to_visual_class(visual_type); -+ -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_DRAWABLE_TYPE, &attribs->drawableType); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_BUFFER_SIZE, &attribs->bufferSize); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_LEVEL, &attribs->level); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_RENDER_TYPE, &attribs->render_type); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_DOUBLEBUFFER, &attribs->doubleBuffer); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_STEREO, &attribs->stereo); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_AUX_BUFFERS, &attribs->auxBuffers); -+ -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_RED_SIZE, &attribs->redSize); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_GREEN_SIZE, &attribs->greenSize); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_BLUE_SIZE, &attribs->blueSize); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ALPHA_SIZE, &attribs->alphaSize); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_DEPTH_SIZE, &attribs->depthSize); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_STENCIL_SIZE, &attribs->stencilSize); -+ -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize); -+ -+ /* get transparent pixel stuff */ -+ glXGetFBConfigAttrib(dpy, fbconfig,GLX_TRANSPARENT_TYPE, &attribs->transparentType); -+ if (attribs->transparentType == GLX_TRANSPARENT_RGB) { -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue); -+ } -+ else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) { -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue); -+ } -+ -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLE_BUFFERS, &attribs->numMultisample); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLES, &attribs->numSamples); -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_CONFIG_CAVEAT, &attribs->visualCaveat); -+ -+#if defined(GLX_NV_float_buffer) -+ if (ext && strstr(ext, "GLX_NV_float_buffer")) { -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_FLOAT_COMPONENTS_NV, &attribs->floatComponents); -+ } -+#endif -+#if defined(GLX_ARB_fbconfig_float) -+ if (ext && strstr(ext, "GLX_ARB_fbconfig_float")) { -+ if (attribs->render_type & GLX_RGBA_FLOAT_BIT_ARB) { -+ attribs->floatComponents = True; -+ } -+ } -+#endif -+#if defined(GLX_EXT_fbconfig_packed_float) -+ if (ext && strstr(ext, "GLX_EXT_fbconfig_packed_float")) { -+ if (attribs->render_type & GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT) { -+ attribs->packedfloatComponents = True; -+ } -+ } -+#endif -+ -+#if defined(GLX_EXT_framebuffer_sRGB) -+ if (ext && strstr(ext, "GLX_EXT_framebuffer_sRGB")) { -+ glXGetFBConfigAttrib(dpy, fbconfig, GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, &attribs->srgb); -+ } -+#endif -+ return True; -+} -+ -+#endif -+ -+ -+ -+static void -+print_visual_attribs_verbose(const struct visual_attribs *attribs, -+ int fbconfigs) -+{ -+ if (fbconfigs) { -+ printf("FBConfig ID: %x Visual ID=%x depth=%d class=%s, type=%s\n", -+ attribs->id, attribs->vis_id, attribs->depth, -+ visual_class_name(attribs->klass), -+ visual_drawable_type(attribs->drawableType)); -+ } -+ else { -+ printf("Visual ID: %x depth=%d class=%s, type=%s\n", -+ attribs->id, attribs->depth, visual_class_name(attribs->klass), -+ visual_drawable_type(attribs->drawableType)); -+ } -+ printf(" bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n", -+ attribs->bufferSize, attribs->level, -+ visual_render_type_name(attribs->render_type), -+ attribs->doubleBuffer, attribs->stereo); -+ printf(" rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d float=%c sRGB=%c\n", -+ attribs->redSize, attribs->greenSize, -+ attribs->blueSize, attribs->alphaSize, -+ attribs->packedfloatComponents ? 'P' : attribs->floatComponents ? 'Y' : 'N', -+ attribs->srgb ? 'Y' : 'N'); -+ printf(" auxBuffers=%d depthSize=%d stencilSize=%d\n", -+ attribs->auxBuffers, attribs->depthSize, attribs->stencilSize); -+ printf(" accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", -+ attribs->accumRedSize, attribs->accumGreenSize, -+ attribs->accumBlueSize, attribs->accumAlphaSize); -+ printf(" multiSample=%d multiSampleBuffers=%d\n", -+ attribs->numSamples, attribs->numMultisample); -+#ifdef GLX_EXT_visual_rating -+ if (attribs->visualCaveat == GLX_NONE_EXT || attribs->visualCaveat == 0) -+ printf(" visualCaveat=None\n"); -+ else if (attribs->visualCaveat == GLX_SLOW_VISUAL_EXT) -+ printf(" visualCaveat=Slow\n"); -+ else if (attribs->visualCaveat == GLX_NON_CONFORMANT_VISUAL_EXT) -+ printf(" visualCaveat=Nonconformant\n"); -+#endif -+ if (attribs->transparentType == GLX_NONE) { -+ printf(" Opaque.\n"); -+ } -+ else if (attribs->transparentType == GLX_TRANSPARENT_RGB) { -+ printf(" Transparent RGB: Red=%d Green=%d Blue=%d Alpha=%d\n",attribs->transparentRedValue,attribs->transparentGreenValue,attribs->transparentBlueValue,attribs->transparentAlphaValue); -+ } -+ else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) { -+ printf(" Transparent index=%d\n",attribs->transparentIndexValue); -+ } -+} -+ -+ -+static void -+print_visual_attribs_short_header(void) -+{ -+ printf(" visual x bf lv rg d st colorbuffer sr ax dp st accumbuffer ms cav\n"); -+ printf(" id dep cl sp sz l ci b ro r g b a F gb bf th cl r g b a ns b eat\n"); -+ printf("----------------------------------------------------------------------------\n"); -+} -+ -+ -+static void -+print_visual_attribs_short(const struct visual_attribs *attribs) -+{ -+ const char *caveat = caveat_string(attribs->visualCaveat); -+ -+ printf("0x%03x %2d %2s %2d %3d %2d %c%c %c %c %2d %2d %2d %2d %c %c %2d %2d %2d", -+ attribs->id, -+ attribs->depth, -+ visual_class_abbrev(attribs->klass), -+ attribs->transparentType != GLX_NONE, -+ attribs->bufferSize, -+ attribs->level, -+ (attribs->render_type & GLX_RGBA_BIT) ? 'r' : ' ', -+ (attribs->render_type & GLX_COLOR_INDEX_BIT) ? 'c' : ' ', -+ attribs->doubleBuffer ? 'y' : '.', -+ attribs->stereo ? 'y' : '.', -+ attribs->redSize, attribs->greenSize, -+ attribs->blueSize, attribs->alphaSize, -+ attribs->packedfloatComponents ? 'u' : attribs->floatComponents ? 'f' : '.', -+ attribs->srgb ? 's' : '.', -+ attribs->auxBuffers, -+ attribs->depthSize, -+ attribs->stencilSize -+ ); -+ -+ printf(" %2d %2d %2d %2d %2d %1d %s\n", -+ attribs->accumRedSize, attribs->accumGreenSize, -+ attribs->accumBlueSize, attribs->accumAlphaSize, -+ attribs->numSamples, attribs->numMultisample, -+ caveat -+ ); -+} -+ -+ -+static void -+print_visual_attribs_long_header(void) -+{ -+ printf("Vis Vis Visual Trans buff lev render DB ste r g b a s aux dep ste accum buffer MS MS \n"); -+ printf(" ID Depth Type parent size el type reo sz sz sz sz flt rgb buf th ncl r g b a num bufs caveats\n"); -+ printf("--------------------------------------------------------------------------------------------------------------------\n"); -+} -+ -+ -+static void -+print_visual_attribs_long(const struct visual_attribs *attribs) -+{ -+ const char *caveat = caveat_string(attribs->visualCaveat); -+ -+ printf("0x%3x %2d %-11s %2d %3d %2d %4s %3d %3d %3d %3d %3d %3d", -+ attribs->id, -+ attribs->depth, -+ visual_class_name(attribs->klass), -+ attribs->transparentType != GLX_NONE, -+ attribs->bufferSize, -+ attribs->level, -+ visual_render_type_name(attribs->render_type), -+ attribs->doubleBuffer, -+ attribs->stereo, -+ attribs->redSize, attribs->greenSize, -+ attribs->blueSize, attribs->alphaSize -+ ); -+ -+ printf(" %c %c %3d %4d %2d %3d %3d %3d %3d %2d %2d %6s\n", -+ attribs->floatComponents ? 'f' : '.', -+ attribs->srgb ? 's' : '.', -+ attribs->auxBuffers, -+ attribs->depthSize, -+ attribs->stencilSize, -+ attribs->accumRedSize, attribs->accumGreenSize, -+ attribs->accumBlueSize, attribs->accumAlphaSize, -+ attribs->numSamples, attribs->numMultisample, -+ caveat -+ ); -+} -+ -+ -+static void -+print_visual_info(Display *dpy, int scrnum, InfoMode mode) -+{ -+ XVisualInfo theTemplate; -+ XVisualInfo *visuals; -+ int numVisuals, numGlxVisuals; -+ long mask; -+ int i; -+ struct visual_attribs attribs; -+ -+ /* get list of all visuals on this screen */ -+ theTemplate.screen = scrnum; -+ mask = VisualScreenMask; -+ visuals = XGetVisualInfo(dpy, mask, &theTemplate, &numVisuals); -+ -+ numGlxVisuals = 0; -+ for (i = 0; i < numVisuals; i++) { -+ if (get_visual_attribs(dpy, &visuals[i], &attribs)) -+ numGlxVisuals++; -+ } -+ -+ if (numGlxVisuals == 0) -+ return; -+ -+ printf("%d GLX Visuals\n", numGlxVisuals); -+ -+ if (mode == Normal) -+ print_visual_attribs_short_header(); -+ else if (mode == Wide) -+ print_visual_attribs_long_header(); -+ -+ for (i = 0; i < numVisuals; i++) { -+ if (!get_visual_attribs(dpy, &visuals[i], &attribs)) -+ continue; -+ -+ if (mode == Verbose) -+ print_visual_attribs_verbose(&attribs, False); -+ else if (mode == Normal) -+ print_visual_attribs_short(&attribs); -+ else if (mode == Wide) -+ print_visual_attribs_long(&attribs); -+ } -+ printf("\n"); -+ -+ XFree(visuals); -+} -+ -+#ifdef GLX_VERSION_1_3 -+ -+static void -+print_fbconfig_info(Display *dpy, int scrnum, InfoMode mode) -+{ -+ int numFBConfigs = 0; -+ struct visual_attribs attribs; -+ GLXFBConfig *fbconfigs; -+ int i; -+ -+ /* get list of all fbconfigs on this screen */ -+ fbconfigs = glXGetFBConfigs(dpy, scrnum, &numFBConfigs); -+ -+ if (numFBConfigs == 0) { -+ XFree(fbconfigs); -+ return; -+ } -+ -+ printf("%d GLXFBConfigs:\n", numFBConfigs); -+ if (mode == Normal) -+ print_visual_attribs_short_header(); -+ else if (mode == Wide) -+ print_visual_attribs_long_header(); -+ -+ for (i = 0; i < numFBConfigs; i++) { -+ get_fbconfig_attribs(dpy, fbconfigs[i], &attribs); -+ -+ if (mode == Verbose) -+ print_visual_attribs_verbose(&attribs, True); -+ else if (mode == Normal) -+ print_visual_attribs_short(&attribs); -+ else if (mode == Wide) -+ print_visual_attribs_long(&attribs); -+ } -+ printf("\n"); -+ -+ XFree(fbconfigs); -+} -+ -+#endif -+ -+/* -+ * Stand-alone Mesa doesn't really implement the GLX protocol so it -+ * doesn't really know the GLX attributes associated with an X visual. -+ * The first time a visual is presented to Mesa's pseudo-GLX it -+ * attaches ancilliary buffers to it (like depth and stencil). -+ * But that usually only works if glXChooseVisual is used. -+ * This function calls glXChooseVisual() to sort of "prime the pump" -+ * for Mesa's GLX so that the visuals that get reported actually -+ * reflect what applications will see. -+ * This has no effect when using true GLX. -+ */ -+static void -+mesa_hack(Display *dpy, int scrnum) -+{ -+ static int attribs[] = { -+ GLX_RGBA, -+ GLX_RED_SIZE, 1, -+ GLX_GREEN_SIZE, 1, -+ GLX_BLUE_SIZE, 1, -+ GLX_DEPTH_SIZE, 1, -+ GLX_STENCIL_SIZE, 1, -+ GLX_ACCUM_RED_SIZE, 1, -+ GLX_ACCUM_GREEN_SIZE, 1, -+ GLX_ACCUM_BLUE_SIZE, 1, -+ GLX_ACCUM_ALPHA_SIZE, 1, -+ GLX_DOUBLEBUFFER, -+ None -+ }; -+ XVisualInfo *visinfo; -+ -+ visinfo = glXChooseVisual(dpy, scrnum, attribs); -+ if (visinfo) -+ XFree(visinfo); -+} -+ -+ -+/* -+ * Examine all visuals to find the so-called best one. -+ * We prefer deepest RGBA buffer with depth, stencil and accum -+ * that has no caveats. -+ */ -+static int -+find_best_visual(Display *dpy, int scrnum) -+{ -+ XVisualInfo theTemplate; -+ XVisualInfo *visuals; -+ int numVisuals; -+ long mask; -+ int i; -+ struct visual_attribs bestVis; -+ -+ /* get list of all visuals on this screen */ -+ theTemplate.screen = scrnum; -+ mask = VisualScreenMask; -+ visuals = XGetVisualInfo(dpy, mask, &theTemplate, &numVisuals); -+ -+ /* init bestVis with first visual info */ -+ get_visual_attribs(dpy, &visuals[0], &bestVis); -+ -+ /* try to find a "better" visual */ -+ for (i = 1; i < numVisuals; i++) { -+ struct visual_attribs vis; -+ -+ get_visual_attribs(dpy, &visuals[i], &vis); -+ -+ /* always skip visuals with caveats */ -+ if (vis.visualCaveat != GLX_NONE_EXT) -+ continue; -+ -+ /* see if this vis is better than bestVis */ -+ if ((!bestVis.supportsGL && vis.supportsGL) || -+ (bestVis.visualCaveat != GLX_NONE_EXT) || -+ (!(bestVis.render_type & GLX_RGBA_BIT) && (vis.render_type & GLX_RGBA_BIT)) || -+ (!bestVis.doubleBuffer && vis.doubleBuffer) || -+ (bestVis.redSize < vis.redSize) || -+ (bestVis.greenSize < vis.greenSize) || -+ (bestVis.blueSize < vis.blueSize) || -+ (bestVis.alphaSize < vis.alphaSize) || -+ (bestVis.depthSize < vis.depthSize) || -+ (bestVis.stencilSize < vis.stencilSize) || -+ (bestVis.accumRedSize < vis.accumRedSize)) { -+ /* found a better visual */ -+ bestVis = vis; -+ } -+ } -+ -+ XFree(visuals); -+ -+ return bestVis.id; -+} -+ -+ -+int -+main(int argc, char *argv[]) -+{ -+ Display *dpy; -+ int numScreens, scrnum; -+ struct options opts; -+ Bool coreWorked; -+ -+ parse_args(argc, argv, &opts); -+ -+ dpy = XOpenDisplay(opts.displayName); -+ if (!dpy) { -+ fprintf(stderr, "Error: unable to open display %s\n", -+ XDisplayName(opts.displayName)); -+ return -1; -+ } -+ -+ if (opts.findBest) { -+ int b; -+ mesa_hack(dpy, 0); -+ b = find_best_visual(dpy, 0); -+ printf("%d\n", b); -+ } -+ else { -+ numScreens = ScreenCount(dpy); -+ print_display_info(dpy); -+ for (scrnum = 0; scrnum < numScreens; scrnum++) { -+ mesa_hack(dpy, scrnum); -+ coreWorked = print_screen_info(dpy, scrnum, &opts, -+ True, False, opts.limits, False); -+ print_screen_info(dpy, scrnum, &opts, False, False, -+ opts.limits, coreWorked); -+ print_screen_info(dpy, scrnum, &opts, False, True, False, True); -+ -+ printf("\n"); -+ -+ if (opts.mode != Brief) { -+ print_visual_info(dpy, scrnum, opts.mode); -+#ifdef GLX_VERSION_1_3 -+ print_fbconfig_info(dpy, scrnum, opts.mode); -+#endif -+ } -+ -+ if (scrnum + 1 < numScreens) -+ printf("\n\n"); -+ } -+ } -+ -+ XCloseDisplay(dpy); -+ -+ return 0; -+} -diff -Naurp mesa-20.2.1-orig/src/glx/xdemos/meson.build mesa-20.2.1/src/glx/xdemos/meson.build ---- mesa-20.2.1-orig/src/glx/xdemos/meson.build 1969-12-31 18:00:00.000000000 -0600 -+++ mesa-20.2.1/src/glx/xdemos/meson.build 2020-10-15 23:07:14.486696790 -0500 -@@ -0,0 +1,32 @@ -+inc_xdemos = include_directories('.') -+ -+glxinfo_files = files( -+ 'glxinfo.c', -+ 'glinfo_common.c', -+) -+ -+x11_dep = dependency('x11', required: true) -+ -+executable('glxinfo', glxinfo_files, -+ install : true, -+ #c_args : gl_lib_cargs, -+ link_args : [ld_args_bsymbolic, ld_args_gc_sections, extra_ld_args_libgl, '-lm'], -+ link_with : libgl, -+ include_directories : [ inc_src, inc_include, inc_mesa, inc_glx], -+ dependencies : [x11_dep] -+) -+ -+executable('glxgears', 'glxgears.c', -+ install : true, -+ #c_args : gl_lib_cargs, -+ link_args : [ld_args_bsymbolic, ld_args_gc_sections, extra_ld_args_libgl, '-lm'], -+ link_with : libgl, -+ include_directories : [inc_src, inc_include, inc_mesa, inc_glx], -+ dependencies : [x11_dep] -+) -+ -+man_dir = get_option('prefix') + '/share/man/man1' -+install_data(['glxinfo.1', 'glxgears.1'], -+ install_dir : man_dir -+) -+ |