Comment faire pour vérifier la Version d'OpenGL sous Windows 7kl

Je suis l'aide de Windows 7. Je suis à la programmation à l'aide de l'OpenGL. Mais j'ai trouvé qu'il ya certaines caractéristiques que je peux utiliser. Je tiens donc à vérifier la version de OpenGL sur mon système.
J'utilise le code ci-dessous pour vous

const char* version = (const char*)glGetString(GL_VERSION);

Mais je reçois un pointeur null. Et si je veux mettre à jour mon OpenGL, que dois-je faire?

OriginalL'auteur Yongwei Xing | 2010-12-12

  1. 6

    Vous avez besoin d'un GL contexte actuel avant que vous pouvez demander la version que vous avez.

    Donc en premier lieu, de créer un contexte, appel wglMakeCurrent sur elle, et vous devriez être en mesure d'appeler glGetString après.

    La version qui est rapporté est à venir à partir du pilote que vous avez installés. La version d'OpenGL que votre matériel n'est pas lui-même "évolutive" (parce que certaines fonctionnalités du matériel sera absent pour soutenir les plus récentes et les plus grands).

    Donc le mieux que vous pouvez faire est de mettre à niveau votre pilote, mais ne pas obtenir vos espoirs haute, il en résultera une nouvelle OpenGL.

    J'ai vu beaucoup de bases de code avec des approches différentes de la gestion du contexte. Je ne sais pas si l'OP est à l'aide d'un cadre ou pas. Mais le principe de base s'applique toujours quel que soit le cadre (le cas échéant) est utilisé.
    Vrai. 🙂 +1 de moi.

    OriginalL'auteur Bahbar

  2. 5

    La plus simple et la plus rapide consiste à utiliser un outil de diagnostic comme GPU Caps Viewer.

    Vous pouvez également utiliser glGetString(GL_VERSION) mais rappelez-vous que la version dont vous aurez affiché est la version d'un contexte OpenGL - ce qui n'est pas nécessairement le plus haut de votre GPU peut faire.
    Toutefois, si vous créez le contexte avec les paramètres par défaut, vous aurez probablement la plus élevée possible du contexte OpenGL dans la compatibilité du profil, donc, oui, cette méthode peut être utile.

    Aussi, comme le glGetString(GL_VERSION) se réfère à un contexte OpenGL, vous devez avoir créé au préalable. En fait, un GL contexte est nécessaire pour appeler tout gl* fonction.

    En effet, la mise à niveau les pilotes peut vous donnent une plus grande version d'opengl, mais il est peu probable que la version majeure allait changer. Par exemple, si vous vous trouvez avoir du soutien pour GL 3.1, il est très probable que les pilotes les plus récents vous donnera GL 3.3, mais pas GL 4.0.

    OriginalL'auteur Kos

  3. 0

    Vous devez créer du Contexte OpenGL (WGL) avant d'appeler glGetString(GL_VERSION) :

    #include <windows.h>
#include <GL/GL.h>

#pragma comment (lib, "opengl32.lib")

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

int WinMain( __in HINSTANCE hInstance, __in_opt HINSTANCE hPrevInstance, __in_opt LPSTR lpCmdLine, __in int nShowCmd )
{
        MSG msg          = {0};
        WNDCLASS wc      = {0}; 
        wc.lpfnWndProc   = WndProc;
        wc.hInstance     = hInstance;
        wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND);
        wc.lpszClassName = L"oglversionchecksample";
        wc.style = CS_OWNDC;
        if( !RegisterClass(&wc) )
                return 1;
        CreateWindowW(wc.lpszClassName,L"openglversioncheck",WS_OVERLAPPEDWINDOW|WS_VISIBLE,0,0,640,480,0,0,hInstance,0);

        while( GetMessage( &msg, NULL, 0, 0 ) > 0 )
                DispatchMessage( &msg );

        return 0;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        switch(message)
        {
        case WM_CREATE:
                {
                PIXELFORMATDESCRIPTOR pfd =
                {
                        sizeof(PIXELFORMATDESCRIPTOR),
                        1,
                        PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,    //Flags
                        PFD_TYPE_RGBA,            //The kind of framebuffer. RGBA or palette.
                        32,                        //Colordepth of the framebuffer.
                        0, 0, 0, 0, 0, 0,
                        0,
                        0,
                        0,
                        0, 0, 0, 0,
                        24,                        //Number of bits for the depthbuffer
                        8,                        //Number of bits for the stencilbuffer
                        0,                        //Number of Aux buffers in the framebuffer.
                        PFD_MAIN_PLANE,
                        0,
                        0, 0, 0
                };

                HDC ourWindowHandleToDeviceContext = GetDC(hWnd);

                int  letWindowsChooseThisPixelFormat;
                letWindowsChooseThisPixelFormat = ChoosePixelFormat(ourWindowHandleToDeviceContext, &pfd); 
                SetPixelFormat(ourWindowHandleToDeviceContext,letWindowsChooseThisPixelFormat, &pfd);

                HGLRC ourOpenGLRenderingContext = wglCreateContext(ourWindowHandleToDeviceContext);
                wglMakeCurrent (ourWindowHandleToDeviceContext, ourOpenGLRenderingContext);

                MessageBoxA(0,(char*)glGetString(GL_VERSION), "OPENGL VERSION",0);

                wglDeleteContext(ourOpenGLRenderingContext);
                PostQuitMessage(0);
                }
                break;
        default:
                return DefWindowProc(hWnd, message, wParam, lParam);
        }
        return 0;

}

    OriginalL'auteur dns

  4. 0

    essayez d'utiliser le code suivant, ça fonctionne pour moi: 

    cout << "OpenGL Version : " << glGetString(GL_VERSION) << endl;

    Assurez-vous d'inclure string et iostream dans votre programme.

    OriginalL'auteur all_by_grace