[OpenGL]Can't create GL Rendering Context

[Verwijderd]

Ik heb een probleempje,
ik heb een tutorial gedaan over OpenGL
maar nu zit er als ik het draai een GL Render Context error in
Ik heb alle documentatie in het nederlands erbij gezet
misschien kan iemand mij helpen

dit is de source:

[ Voor 4% gewijzigd door Verwijderd op 25-10-2003 01:50 ]

[Verwijderd]

C++:

//////////////////////////////
//      OpenGL Window       //
//                          //
//   Door Wouter Rengelink  //
//      [e-mail]     //
//////////////////////////////


#include <windows.h>    //Windows header file
#include <gl\gl.h>      //OpenGL header file
#include <gl\glu.h>     //GLu2 header file 
#include <gl\glaux.h>   //GLaux header file

HGLRC       hRC=NULL;   //Permanente render context
HDC         hDC=NULL;   //Private GDI device context
HWND        hWnd=NULL;  //Houdt het scherm zoals hij is
HINSTANCE   hInstance;  //Houdt de Instance van het programma

bool    keys[256];          //Keyboard button press
bool    active = true;      //Programma maximized
bool    fullscreen = true;  //Programma draait fullscreen

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);   //WndProc declaratie

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)     //Resize en initializeren van GL window
{
    if (height == 0)                                    //Voorkom delen door nul
    {
        height = 1;                                     //Height gelijk aan 1 te maken
    }

    glViewport(0,0, width, height);                     //Reset huidig viewpoint

    glMatrixMode(GL_PROJECTION);                        //Selecteer de projectie matrix
    glLoadIdentity();                                   //Reset de projectie matrix
    
    //Berekent het aspect ratio van het window
    gluPerspective(45.0f,(GLfloat)width/(GLfloat)height, 0.1f, 100.0f);

    glMatrixMode(GL_MODELVIEW);                         //Selecteer de modelview matrix
    glLoadIdentity();                                   //Reset de modelview matrix
}

int InitGL(GLvoid)                                      //Alle setup voor OpenGL
{
    glShadeModel(GL_SMOOTH);                            //Zet smoothshading aan
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);               //Zwarte achtergrond
    
    glClearDepth(1.0f);                                 //Depth Buffer Setup
    glEnable(GL_DEPTH_TEST);                            //Zet diepte test aan
    glDepthFunc(GL_LEQUAL);                             //Type van de test

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  //Zeer mooie perspectieven

    return true;                                        //OpenGL initialisatie goed gegaan
}

int DrawGLScene(GLvoid)                                 //Functie voor het tekenen
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Leegt de scherm en diepte buffer
    glLoadIdentity();                                   //Reset de huidige modelview matrix
    return true;                                        //Alles ging ok
}

GLvoid KillGLWindow(GLvoid)                             //Sluit window af
{
    if (fullscreen)                                     //Kijkt of het window in fullscreen staat
    {                                                   
        ChangeDisplaySettings(NULL,0);                  //Gaat naar desktop modus
        ShowCursor(true);                               //Laat muiscursor zien
    }

    if (hRC)                                            //Kijkt of we een Rendering Context hebben
    {
        if (!wglMakeCurrent(NULL,NULL))                 //Kijkt of we de RC en de DC kunnen losmaken
        {
            MessageBox(NULL,"Release of DC and RC failed.","Shutdown error",MB_OK | MB_ICONINFORMATION);
        }
        if (!wglDeleteContext(hRC))                     //Kijkt of we de RC kunnen verwijderen
        {
            MessageBox(NULL,"Release Rendering Content Failed.","Shutdown error",MB_OK | MB_ICONINFORMATION);
        }
        hRC=NULL;                                       //Zet hRC op NULL
    }
    if (hDC && !ReleaseDC(hWnd,hDC))                    //Kijkt of we hDC kunnen losmaken
    {
        MessageBox(NULL,"Release Device Context failed.","Shutdown error",MB_OK | MB_ICONINFORMATION);
        hDC = NULL;                                     //Zet hDC op NULL
    }
    if (hWnd && !DestroyWindow(hWnd))                   //Kijkt of het het window kapot kunnen maken
    {
        MessageBox(NULL,"Could not release hWnd","Shutdown error",MB_OK | MB_ICONINFORMATION);
        hWnd = NULL;                                    //Zet hWnd op NULL
    }
    if (!UnregisterClass("WouterGL",hInstance))         //Kijkt of het window verwijderd kan worden
    {
        MessageBox(NULL,"Could not unregister class.","Shutdown error",MB_OK | MB_ICONINFORMATION);
        hInstance = NULL;                               //Zet hInstance op NULL
    }
}

bool CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
    GLuint      PixelFormat;                            //Bewaart het resultaat wanneer er een gelijke is gevonden
    WNDCLASS    wc;                                     //Window Class struktuur
    DWORD       dwExStyle;                              //Window extended stijl
    DWORD       dwStyle;                                //Window stijl

    RECT WindowRect;                                    //Pakt linksboven en rechtsonder van vierkant
    WindowRect.left = (long)0;                          //Set left waarde op 0
    WindowRect.right = (long)width;                     //Set right waarde op de width van venster
    WindowRect.top = (long)0;                           //Set top waarde op 0
    WindowRect.bottom = (long)height;                   //Set bottom waarde op de height van venster

    fullscreen = fullscreenflag;                        //Set globale fullscreenflag
    
    hInstance       = GetModuleHandle(NULL);            //Neem Instance voor scherm
    wc.style        = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; //Redraw op verplaatsing en een eigen DC voor scherm
    wc.lpfnWndProc  = (WNDPROC) WndProc;                //WndProc voor berichten
    wc.cbClsExtra   = 0;                                //Geen extra window gegevens
    wc.cbWndExtra   = 0;                                //Geen extra window gegevens
    wc.hInstance    = hInstance;                        //Set de Instance
    wc.hIcon        = LoadIcon(NULL, IDI_WINLOGO);      //Laad het standaard icoon
    wc.hCursor      = LoadCursor(NULL, IDC_ARROW);      //Laad de standaard muiscursor
    wc.hbrBackground= NULL;                             //Geen achtergrond voor GL
    wc.lpszMenuName = NULL;                             //Geen menu in GL
    wc.lpszClassName= "WouterGL";                       //Class naam

    if (!RegisterClass(&wc))                            //Probeer de class te registreren
    {
        MessageBox(NULL,"Failed to register the window class.","Error",MB_OK | MB_ICONINFORMATION);
        return false;                                   //Exit en return false
    }
    
    if (fullscreen)                                             //Probeer op fullscreen te zetten
    {
        DEVMODE dmScreenSettings;                               //Device Modus
        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));   //Checkt of het memory leeg is
        dmScreenSettings.dmSize = sizeof(dmScreenSettings);     //Maten van de DEVMODE struktuur
        dmScreenSettings.dmPelsWidth = width;                   //Geselecteerde schermbreedte
        dmScreenSettings.dmPelsHeight = height;                 //Geselecteerde schermhoogte
        dmScreenSettings.dmBitsPerPel = bits;                   //Geselecteerde bits per pixel
        dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

        //Probeer om in geselecteerde modus te komen en de resultaten op te halen.
        //NOTE: CDS_FULLSCREEN zorgt er voor dat er geen startbalk is
        if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
        {
            //Wanneer fullscreen vaalt, biedt twee opties aan. Quit | Run windowed
            if (MessageBox(NULL,"The requested fullscreen mode is nog supported by\nyour video card. Use windowed mode instead?","WouterGL",MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
            {
                fullscreen = false;                             //Selecteer windowed mode
            }
            else
            {
                //Popup Message Box die aan gebruiker verteld dat programma afsluit
                MessageBox(NULL,"Program will now close.","Error",MB_OK | MB_ICONSTOP);
                return false;
            }
        }
    }

[Verwijderd]

C++:

    if (fullscreen)                                             //We zitten in fullscreen mode
    {
        dwExStyle   = WS_EX_APPWINDOW;                          //Window Extended stijl
        dwStyle     = WS_POPUP;                                 //Windows Stijl
        ShowCursor(false);
    }
    else
    {
        dwExStyle   = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;       //Window Extended stijl
        dwStyle     = WS_OVERLAPPEDWINDOW;                      //Window stijl
    }

    AdjustWindowRectEx(&WindowRect, dwStyle, false, dwExStyle); //Maak window aangevraagde grootte

    if (!(hWnd = CreateWindowEx(    dwExStyle,                              //Extended stijl voor het window
                                    "WouterGL",                             //Class naam
                                    title,                                  //Window titel
                                    dwStyle |                               //Geselecteerde window stijl
                                    WS_CLIPSIBLINGS |                       //Noodzakelijk
                                    WS_CLIPCHILDREN ,                       //Noodzakelijk                          
                                    0, 0,                                   //Window positie
                                    WindowRect.right - WindowRect.left,     //Bereken window breedte
                                    WindowRect.bottom - WindowRect.top,     //Bereken window hoogte
                                    NULL,                                   //Geen parent window
                                    NULL,                                   //Geen menu
                                    hInstance,                              //Instance
                                    NULL)))                                 //Laat niets over op WM_CREATE
    {
        KillGLWindow();                                         //Reset het display
        MessageBox(NULL,"Window Creation Error.","Error",MB_OK | MB_ICONEXCLAMATION);
        return false;                                           //Return false
    }
    
    static PIXELFORMATDESCRIPTOR pfd =  //pft verteld windows hoe we dingen willen zien
    {
        sizeof(PIXELFORMATDESCRIPTOR),  //Grootte van de PFD
        1,                              //Versie nummer
        PFD_DRAW_TO_WINDOW|             //PDF moet window ondersteunen
        PFD_SUPPORT_OPENGL|             //PDF moet OpenGL ondersteunen
        PFD_DOUBLEBUFFER,               //Moet doublebuffering ondersteunen
        PFD_TYPE_RGBA,                  //Een RGBA aanvragen
        bits,                           //Selecteer een kleur diepte
        0, 0, 0, 0, 0, 0,               //Kleur bits negeren
        0,                              //Geen alpha buffer
        0,                              //Shitf bit negeren
        0,                              //Geen accumulation buffer
        0, 0, 0, 0,                     //Accumulation Bits negeren
        16,                             //16Bit Z-Buffer (Diepte buffer)
        0,                              //Geen stencil buffer
        0,                              //Geen Auxiliary Buffer
        PFD_MAIN_PLANE,                 //Main teken laag
        0,                              //Gereserveerd
        0, 0, 0                         //Layer masks negeren
    };

    if (!(hDC = GetDC(hWnd)))           //Kijkt of we een Device Context hebben
    {
        KillGLWindow();                 //Reset het window
        MessageBox(NULL,"Can't create a GL Device Context.","Error",MB_OK | MB_ICONEXCLAMATION);
        return false;                   //Return false
    }

    if (!(PixelFormat=ChoosePixelFormat(hDC, &pfd)))        //Kijkt of windows het juiste pixeltype kan vinden
    {
        KillGLWindow();                                     //Reset het window
        MessageBox(NULL,"Can't find suitable pixel format","Error",MB_OK | MB_ICONEXCLAMATION);
        return false;                                       //Return false
    }

    if (!(hRC=wglCreateContext(hDC)))                       //Kijkt of we Rendering Context kunnen krijgen
    {
        KillGLWindow();                                     //Reset het window
        MessageBox(NULL,"Can't create a GL Rendering Context.","Error",MB_OK | MB_ICONEXCLAMATION);
        return false;                                       //Return false
    }

    if (!wglMakeCurrent(hDC,hRC))                           //Kijkt of de Rendering Context geactiveerd kan worden
    {
        KillGLWindow();                                     //Reset het window
        MessageBox(NULL,"Can't activate the GL Rendering Context.","Error",MB_OK | MB_ICONEXCLAMATION);
        return false;                                       //Return false
    }
    ShowWindow(hWnd,SW_SHOW);       //Laat het scherm zien
    SetForegroundWindow(hWnd);      //Verhoog de prioriteit
    SetFocus(hWnd);                 //Keyboard focus op het window
    ReSizeGLScene(width, height);   //Zet het window in perspectief op

    if (!InitGL())                  //Initialiseer het nieuwe GL window
    {
        KillGLWindow();             //Reset het window
        MessageBox(NULL,"Initialization failed.","Error",MB_OK | MB_ICONEXCLAMATION);
        return false;               //Return false
    }
    
    
    return true;                    //Alles ging goed
}

LRESULT CALLBACK WndProc(   HWND    hWnd,               //Handle voor dit window
                            UINT    uMsg,               //Bericht voor dit window
                            WPARAM  wParam,             //Bijkomende bericht informatie
                            LPARAM  lParam)             //Bijkomende bericht informatie
{
    switch (uMsg)                                       //Check voor window berichten
    {
    case WM_ACTIVATE:                                   //Kijk naar window activatie bericht
        {
            if (!HIWORD(wParam))                        //Check minimalisatie status
            {
                active = true;                          //Programma is actief
            }
            else
            {
                active = false;                         //Programma is niet meer actief
            }

            return 0;                                   //Return de message lus
        }

    case WM_SYSCOMMAND:                                 //Onderschept systeem commando's
        {
            switch (wParam)                             //Check system oproepen
            {
            case SC_SCREENSAVE:                         //Kijkt of screensaver probeert te starten
            case SC_MONITORPOWER:                       //Kijkt of de monitor op standby wil gaan
            return 0;                                   //Zorgt ervoor dat het niet zal gebeuren
            }
            break;                                      //Exit
        }

    case WM_CLOSE:                                      //Kijkt of een we een sluit bericht hebben gekregen
        {
            PostQuitMessage(0);                         //Stuurt een afsluit bericht
            return 0;                                   //Spring terug
        }

    case WM_KEYDOWN:                                    //Kijkt of er een toets wordt ingedrukt
        {
            keys[wParam] = false;                       //Als het zo is wordt het als false gemarkeerd
            return 0;                                   //Spring terug
        }

    case WM_KEYUP:                                      //Kijkt of er een toets wordt losgelaten
        {
            keys[wParam] = false;                       //Als het zo is wordt het als false gemarkeerd
            return 0;                                   //Spring terug
        }

    case WM_SIZE:                                       //Resize het window
        {
            ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); //LoWord = width, HiWord = height
            return 0;                                   //Spring terug
        }
    }
    //Geef alle onbehandelde berichten door aan windows
    return DefWindowProc(hWnd,uMsg,wParam,lParam);
}


//HIER START WinAPI
int WINAPI WinMain( HINSTANCE   hInstance,                  //Instance
                    HINSTANCE   hPrevInstance,              //Previous instance
                    LPSTR       lpCmdLine,                  //Command line parameters
                    int         nCmdShow)                   //Window toon status
{
    MSG msg;                                                //Window bericht structuur
    BOOL done = false;                                      //Bool variable voor exit lus
    
    // Ask The User Which Screen Mode They Prefer
    if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Choose window mode.",MB_YESNO|MB_ICONQUESTION)==IDNO)
    {
        fullscreen = false;                                 // Windowed Mode
    }

    //Maak het window
    if (!CreateGLWindow("WouterGL Framework",640,480,16,fullscreen))
    {
        return 0;                                           //Sluit af wanneer window niet gemaakt is
    }

    while (!done)                                           //Loop totdat done = true
    {
        if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))           //Kijkt of er een bericht is
        {
            if (msg.message==WM_QUIT)                       //Kijkt of er een afsluit bericht ontvangen is
            {
                done = true;                                //Als het zo is, done = true
            }
            else                                            //Als er geen afsluit bericht ontvangen is: Handel de andere window berichten af
            {
                TranslateMessage(&msg);                     //Vertaal het bericht
                DispatchMessage(&msg);                      //Dispatch het bericht
            }
        }
        else
        {
            //Teken het beeld. Kijk uit naar ESC of afsluit berichten door DrawGLScene()
            if (active)                                     //Kijkt of het programma actief is
            {
                if (keys[VK_ESCAPE])                                //Kijkt of ESC wordt ingedrukt
                {
                    done = true;                            //ESC heeft een quit doorgegeven
                }
                else
                {
                    DrawGLScene();                          //Tekent het beeld
                    SwapBuffers(hDC);                       //Verwissel buffers (Double-Buffering)
                }
            }

            if (keys[VK_F1])                                //Kijkt of F1 is ingedrukt
            {
                keys[VK_F1] = false;                        //Als F1 ingedrukt is maak het dan false
                KillGLWindow();                             //Sluit huidige scherm af
                fullscreen = !fullscreen;                   //Kies tussen windowed / fullscreen modus
                //Maak opnieuw OpenGL scherm aan
                if (!CreateGLWindow("WouterGL",640,480,16,fullscreen))
                {
                    return 0;                               //Sluit af als het scherm niet creert kan worden
                }
            }
        }
    }
    // Afsluiten
    KillGLWindow();                                         //Sluit het schermpje
    return (msg.wParam);                                    //Sluit het programma
}

[Tomatoman]

'Hier is mijn code, wil iemand het even voor mij debuggen?'
Zo klinkt het wat jij zegt. Dat lijkt me niet helemaal de bedoeling.

Op welke regel krijg je een foutmelding? Wat heb je zelf al geprobeerd om het probleem te verhelpen? Waar komt de code vandaan?

[Verwijderd]

tomatoman schreef op 25 October 2003 @ 02:15:
'Hier is mijn code, wil iemand het even voor mij debuggen?'
Zo klinkt het wat jij zegt. Dat lijkt me niet helemaal de bedoeling.

Op welke regel krijg je een foutmelding? Wat heb je zelf al geprobeerd om het probleem te verhelpen? Waar komt de code vandaan?

Nee tuurlijk wil ik niet dat iemand het zomaar voor mij oplost
een tip naar waar de fout zou kunnen zitten zou al super zijn.

Ik heb zelf niet zo veel ervaring met OpenGL dus het gaat wat stroef allemaal.

Ik heb de source van de tutorial maker zelf uitgeprint (Die werkte namelijk wel)
en ben alles dus nauwkeurig aan het doorlopen.
Maar vind helemaal niets (Zal wel ergens een klein ding fout zijn )

Heb ook al ge-debugged een aantal keren, stap voor stap
maar vind dus totaal niets.

Dit is mijn uiterste redmiddel

edit:

Ik ben al vanaf half 1 zelf bezig om de fout te zoeken.
Dus dat ik graag wil dat iemand het even snel voor mij oplost is niet van toepassing hier

[ Voor 10% gewijzigd door Verwijderd op 25-10-2003 02:20 ]

[RUXperienced]

Ik zie zo snel wel een ChoosePixelFormat(...) , maar daarna geen SetPixelFormat(...)
Ben je die niet vergeten?

[Tomatoman]

Ik kom zo snel nergens glInit() tegen, zodat er geen render context wordt gemaakt. Lijkt me tamelijk essentieel dat dit gebeurt (en het verklaart ook de foutmelding).

[Verwijderd]

RUXperienced schreef op 25 October 2003 @ 02:37:
Ik zie zo snel wel een ChoosePixelFormat(...) , maar daarna geen SetPixelFormat(...)
Ben je die niet vergeten?

je bent een schat!!!!

het werkt!
ik was de SetPixelFormat vergeten

eeuwige lof aan RUXperienced

[ Voor 19% gewijzigd door Verwijderd op 25-10-2003 02:50 ]

[.oisyn]

Mja, zoals gezegd, hele lappen code posten en dan aan ons vragen waar de fout zit is niet de bedoeling, zo werkt het gewoon niet op GoT.

Je had bijvoorbeeld kunnen proberen uit te zoeken wat die render context error nou precies was, dan had je er wellicht achter gekomen dat het iets was met een verkeerde pixel format oid. Maar goed, je hebt je oplossing al, maar bedenk de volgende keer dat dit niet de goede manier is