上下文初始化前如何查询系统最高支持的OpenGL版本（跨平台/Linux方案）

Great question! Let's tackle this from two angles: first, how to query the maximum supported OpenGL version without initializing a context (matching glxinfo's behavior), and second, how to use that information to directly spin up a GLFW window with the highest compatible context.

First, a quick reality check: there's no single cross-platform API for querying OpenGL version without a context—each OS has its own native windowing/GL binding layer (GLX on Linux, WGL on Windows, CGL on macOS). But we can write platform-specific code wrapped in conditional compilation to cover your needs.

On Linux (and other X11-based POSIX systems), you can use the GLX extension API to query framebuffer configurations (FBConfigs) and extract the maximum supported OpenGL version. Here's a working example:

#include <X11/Xlib.h>
#include <GL/glx.h>
#include <stdio.h>
#include <stdlib.h>

// Define function pointers for GLX extensions
typedef GLXFBConfig (*PFNGLXGETFBCONFIGSPROC)(Display*, int*, int*);
typedef int (*PFNGLXGETFBCONFIGATTRIBPROC)(Display*, GLXFBConfig, int, int*);

int main() {
    Display* dpy = XOpenDisplay(NULL);
    if (!dpy) {
        fprintf(stderr, "Failed to open X display\n");
        return EXIT_FAILURE;
    }

    // Load required GLX functions dynamically
    PFNGLXGETFBCONFIGSPROC glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glXGetProcAddress((const GLubyte*)"glXGetFBConfigs");
    PFNGLXGETFBCONFIGATTRIBPROC glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glXGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib");

    if (!glXGetFBConfigs || !glXGetFBConfigAttrib) {
        fprintf(stderr, "Required GLX extensions not supported\n");
        XCloseDisplay(dpy);
        return EXIT_FAILURE;
    }

    int numConfigs;
    GLXFBConfig* configs = glXGetFBConfigs(dpy, 0, &numConfigs);
    if (!configs) {
        fprintf(stderr, "Failed to retrieve FB configs\n");
        XCloseDisplay(dpy);
        return EXIT_FAILURE;
    }

    int maxMajor = 0, maxMinor = 0;
    // Iterate through all FBConfigs to find the highest OpenGL version
    for (int i = 0; i < numConfigs; i++) {
        int isRenderable;
        if (glXGetFBConfigAttrib(dpy, configs[i], GLX_X_RENDERABLE, &isRenderable) != Success || !isRenderable) {
            continue;
        }

        int major, minor;
        if (glXGetFBConfigAttrib(dpy, configs[i], GLX_CONTEXT_MAJOR_VERSION_ARB, &major) == Success &&
            glXGetFBConfigAttrib(dpy, configs[i], GLX_CONTEXT_MINOR_VERSION_ARB, &minor) == Success) {
            if (major > maxMajor || (major == maxMajor && minor > maxMinor)) {
                maxMajor = major;
                maxMinor = minor;
            }
        }
    }

    XFree(configs);
    XCloseDisplay(dpy);

    if (maxMajor == 0) {
        fprintf(stderr, "No OpenGL-compatible FB configs found\n");
        return EXIT_FAILURE;
    }

    printf("Maximum supported OpenGL version: %d.%d\n", maxMajor, maxMinor);
    return EXIT_SUCCESS;
}

Compile this with: gcc -o gl_query gl_query.c -lX11 -lGL

To cover Windows and macOS too, wrap platform-specific code in preprocessor directives. Here's a high-level outline:

Windows (WGL) #

Use the WGL_ARB_pixel_format extension to query pixel formats and their supported OpenGL versions:

#ifdef _WIN32
#include <windows.h>
#include <gl/gl.h>
#include <stdio.h>

typedef BOOL (*PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC, int, int, int, int*);

int query_max_opengl_version() {
    HDC hdc = GetDC(GetDesktopWindow());
    if (!hdc) return -1;

    PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = 
        (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)wglGetProcAddress("wglGetPixelFormatAttribivARB");
    if (!wglGetPixelFormatAttribivARB) {
        ReleaseDC(GetDesktopWindow(), hdc);
        return -1;
    }

    int numFormats = 0;
    wglGetPixelFormatAttribivARB(hdc, 1, 0, 1, WGL_NUMBER_PIXEL_FORMATS_ARB, &numFormats);

    int maxMajor = 0, maxMinor = 0;
    for (int i = 1; i <= numFormats; i++) {
        int supportsGL;
        if (!wglGetPixelFormatAttribivARB(hdc, i, 0, 1, WGL_SUPPORT_OPENGL_ARB, &supportsGL) || !supportsGL)
            continue;

        int major, minor;
        if (wglGetPixelFormatAttribivARB(hdc, i, 0, 1, WGL_CONTEXT_MAJOR_VERSION_ARB, &major) &&
            wglGetPixelFormatAttribivARB(hdc, i, 0, 1, WGL_CONTEXT_MINOR_VERSION_ARB, &minor)) {
            if (major > maxMajor || (major == maxMajor && minor > maxMinor)) {
                maxMajor = major;
                maxMinor = minor;
            }
        }
    }

    ReleaseDC(GetDesktopWindow(), hdc);
    printf("Maximum supported OpenGL version: %d.%d\n", maxMajor, maxMinor);
    return 0;
}
#endif

macOS (CGL) #

Use Apple's Core OpenGL framework to query renderer properties:

#ifdef __APPLE__
#include <OpenGL/CGLTypes.h>
#include <OpenGL/CGLRenderers.h>
#include <stdio.h>

int query_max_opengl_version() {
    CGLRendererInfoObj rendererInfo = NULL;
    GLint numRenderers;
    CGLError err = CGLChooseRenderer(NULL, NULL, &rendererInfo, &numRenderers);
    if (err != kCGLNoError || numRenderers == 0) return -1;

    int maxMajor = 0, maxMinor = 0;
    for (int i = 0; i < numRenderers; i++) {
        GLint profile;
        err = CGLGetRendererProperty(rendererInfo[i], kCGLRPOpenGLProfile, &profile);
        if (err != kCGLNoError) continue;

        int major, minor;
        // Check core profile versions (macOS supports up to 4.1 for compat, newer for core)
        if (profile & kCGLProfileCore) {
            if (profile & kCGLProfileVersion4_6) { major=4; minor=6; }
            else if (profile & kCGLProfileVersion4_5) { major=4; minor=5; }
            else if (profile & kCGLProfileVersion4_4) { major=4; minor=4; }
            else if (profile & kCGLProfileVersion4_3) { major=4; minor=3; }
            else if (profile & kCGLProfileVersion4_2) { major=4; minor=2; }
            else continue;
        } else if (profile & kCGLProfileCompat) {
            major = 4; minor = 1; // macOS max compatibility profile version
        } else {
            continue;
        }

        if (major > maxMajor || (major == maxMajor && minor > maxMinor)) {
            maxMajor = major;
            maxMinor = minor;
        }
    }

    CGLDestroyRendererInfo(rendererInfo);
    printf("Maximum supported OpenGL version: %d.%d\n", maxMajor, maxMinor);
    return 0;
}
#endif

Once you have the maximum major and minor version numbers, configuring GLFW to create the highest possible context is straightforward. Just set the relevant window hints before calling glfwCreateWindow:

#include <GLFW/glfw3.h>
#include <stdio.h>

int main() {
    // First, run your platform-specific query to get maxMajor and maxMinor
    int maxMajor = 4, maxMinor = 6; // Replace with actual query result

    if (!glfwInit()) {
        fprintf(stderr, "GLFW initialization failed\n");
        return EXIT_FAILURE;
    }

    // Set hints for the highest detected OpenGL version
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, maxMajor);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, maxMinor);
    // Prefer core profile (most modern applications use this)
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    // Required for macOS core profile
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

    GLFWwindow* window = glfwCreateWindow(800, 600, "Max OpenGL Version", NULL, NULL);
    if (!window) {
        // Fallback to compatibility profile if core fails (e.g., older hardware)
        fprintf(stderr, "Core profile failed, trying compatibility profile\n");
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
        window = glfwCreateWindow(800, 600, "Max OpenGL Version (Compat)", NULL, NULL);
        if (!window) {
            fprintf(stderr, "Failed to create GLFW window\n");
            glfwTerminate();
            return EXIT_FAILURE;
        }
    }

    glfwMakeContextCurrent(window);
    // Verify the actual context version
    const GLubyte* version = glGetString(GL_VERSION);
    printf("Created context with OpenGL version: %s\n", version);

    // Your application logic here...

    glfwDestroyWindow(window);
    glfwTerminate();
    return EXIT_SUCCESS;
}

Key Notes #

• Extension Support: The contextless queries rely on modern GLX/WGL/CGL extensions. For extremely old systems, you might need to fall back to creating a temporary minimal context to query the version—but that's outside your original requirement.
• Profiles: Always consider whether you need a core or compatibility profile. Core profiles exclude deprecated features and are recommended for new applications.
• macOS Quirks: macOS only supports up to OpenGL 4.1 for compatibility profiles; newer versions require core profile.

内容的提问来源于stack exchange，提问作者Makogan