spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include <iostream>
#include <windows.h> // Header Datei für Windows 
#include <gl\gl.h> // Header Datei für die OpenGL32 Library 
#include <gl\glu.h> // Header Datei für die GLu32 Library 
#include <gl\glaux.h> // Header Datei für die GLaux Library 

HGLRC hRC=NULL; // Permanenter Rendering Context 
HDC hDC=NULL; // Privater GDI Device Context 
HWND hWnd=NULL; // Enthält unser Fenster-Handle HINSTANCE hInstance; // Enthält die Instanz der Applikation 
bool keys[256]; // Array das für die Tastatur Routine verwendet wird
bool active=TRUE; // Fenster Aktiv Flag standardmäßig auf TRUE gesetzt bool 
fullscreen=TRUE; // Fullscreen Flag ist standardmäßig auf TRUE gesetzt 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Deklaration für WndProc 


GLvoid ReSizeGLScene(GLsizei width, GLsizei height) 
// verändert die Größe und initialisiert das GL-Fenster 
if (height==0) // Verhindere eine Divison durch 0, indem die Höhe auf 1 gesetzt wird 
{
    height=1; 
}
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION); // wähle die Projektions-Matrix aus  
glLoadIdentity(); // Resette die Projektions-Matrix  
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);  // berechne das Seitenverhältnis des Fensters  
glMatrixMode(GL_MODELVIEW); // Wähle die Modelview Matrix aus  glLoadIdentity(); // Resette die Modelview Matrix 
// End ReSizeGLScene
} 


int InitGL(GLvoid) // Der ganze Setup Kram für OpenGL kommt hier rein 
{ 
glShadeModel(GL_SMOOTH); // aktiviert weiches Shading (Smooth Shading) 
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f); // Depth Buffer Setup  
glEnable(GL_DEPTH_TEST); // aktiviert Depth Test  
glDepthFunc(GL_LEQUAL); // Die Art des auszuführenden Depth Test 
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // wirklich nette Perspektiven Berechnungen 
return TRUE; // Initialisierung war OK 
} 

int DrawGLScene(GLvoid) // Hier kommt der ganze Zeichnen-Kram hin 
{ 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Lösche den Bildschirm und den Depth-Buffer  
    glLoadIdentity(); // Resettet die aktuelle Modelview Matrix  
    return TRUE; // Alles war OK 
} 

GLvoid KillGLWindow(GLvoid) // Entferne das Fenster korrekt 
{ 
    if (fullscreen) // Sind wir im Fullscreen Modus?  
    { 
         ChangeDisplaySettings(NULL,0); // Wenn ja, wechsle zurück zum Desktop  
         ShowCursor(TRUE); // Zeige den Maus-Zeiger  
    } 

     if (hRC) // Haben wir einen Rendering Context?  
     { 
         if (!wglMakeCurrent(NULL,NULL)) // Können wir den DC und RC Kontext freigeben?  
         { 
             MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); 
         } 

         if (!wglDeleteContext(hRC)) // Können wir den RC löschen?  
         { 
             MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); 
         } 
         hRC=NULL; // Setze RC auf NULL  
     } 

      if (hDC && !ReleaseDC(hWnd,hDC)) // Können wir DC freigeben?  
      { 
          MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); 
          hDC=NULL; // Setze DC auf NULL  
      } 

      if (hWnd && !DestroyWindow(hWnd)) // Können wir das Fenster zerstören?  
      { 
          MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); 
          hWnd=NULL; // Setze hWnd auf NULL  
      } 

       if (!UnregisterClass("OpenGL",hInstance)) // Können wir die Klasse de-registrieren?  
       { 
           MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); 
           hInstance=NULL; // Setze hInstance auf NULL  
       } 
} 

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag) { 
     GLuint PixelFormat; // Enthält die Ergebnisse nachdem nach was passendem gesucht wurde 
     WNDCLASS wc; // Fenster Klassen Struktur  
     DWORD dwExStyle; // erweiterter Fenster-Stil 
     DWORD dwStyle; // Fenster-Stil 
     RECT WindowRect; // Enthält die obere linke / untere rechte Eckwerte des Rechtecks  
     WindowRect.left=(long)0; // Setze linken Wert auf 0  
     WindowRect.right=(long)width; // Setze rechten Wert auf die gewünschte Breite 
     WindowRect.top=(long)0; // Setze den oberen Wert auf 0  
     WindowRect.bottom=(long)height; // Setze unteren Wert auf die gewünschte Höhe 
     fullscreen=fullscreenflag; // Setze das globale Fullscreen Flag 
     hInstance = GetModuleHandle(NULL); // Ermittle die Instanz für unser Fenster  
     wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Zeichne neu beim bewegen und eigener DC für's Fenster  
     wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc behandelt die Nachrichten  
     wc.cbClsExtra = 0; // Keine extra Fenster-Daten  wc.cbWndExtra = 0; // Keine extra Fenster-Daten  
     wc.hInstance = hInstance; // Setze die Instanz  wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Lade das Standard-Icon  
     wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Lade den Pfeil-Zeiger  
     wc.hbrBackground = NULL; // es wird kein Hintergrund für GL benötigt  
     wc.lpszMenuName = NULL; // Wir wollen kein Menü  
     wc.lpszClassName = "OpenGL"; // Setze den Klassen-Namen 
     if (!RegisterClass(&wc)) // Versuche die Fenster-Klasse zu registrieren 
     { 
         MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
         return FALSE; // beende und gebe FALSE zurück 
     } 

     if (fullscreen) // Fullscreen Modus?  
     { 
         DEVMODE dmScreenSettings; // Device Modus  
         memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Stelle sicher, dass der Speicher geleert ist  
         dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Größe der Devmode Struktur  
         dmScreenSettings.dmPelsWidth = width; // ausgewählte Screen Breite 
         dmScreenSettings.dmPelsHeight = height; // ausgewählte Screen Höhe  
         dmScreenSettings.dmBitsPerPel = bits; // ausgewählte Bits Per Pixel  
         dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT; 

         // Versuche gewählten Modus zu setzen und Ergebnisse zurückliefern. ANMERKUNG: CDS_FULLSCREEN lässt die Start-Leiste nicht anzeigen.  
         if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) 
         { 
              // Wenn der Modus fehl schlägt, biete zwei Optionen an. Beenden oder im Fenster-Modus laufen lassen.  
             if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES) 
             { 
                  fullscreen=FALSE; // wähle Fenster-Modus aus 
                  } else { 
                      // Message Box anzeigen, die den Benutzer wissen lässt, dass das Programm geschlossen wird.  
                      MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP); 
                      return FALSE; // beende und gebe FALSE zurück  
             }
         }
     } 

     if (fullscreen) // Fullscreen Modus?  
     { 
         dwExStyle=WS_EX_APPWINDOW; // erweiterter Fenster-Stil  
         dwStyle=WS_POPUP; // Fenster-Stil  
         ShowCursor(FALSE); // verstecke Maus-Zeiger  
     } else { 
          dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // erweiterter Fenster-Stil  
          dwStyle=WS_OVERLAPPEDWINDOW; // Fenster Stil  
     } 

     djustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // justiere das Fenster der angeforderten Größe entsprechend 

     if (!(hWnd=CreateWindowEx( dwExStyle, // erweiterter Stil für das Fenster  
         "OpenGL", // Klassen Name  
         title, // Fenster Titel  
         WS_CLIPSIBLINGS | // benötigter Fenster-Stil
         WS_CLIPCHILDREN | // benötigter Fenster-Stil  
         dwStyle, // ausgewählter Fenster Stil  
         0, 0, // Fenster Position  
         WindowRect.right-WindowRect.left, // berechne die justierte Fenster-Breite  
         WindowRect.bottom-WindowRect.top, // berechne die justierte Fenster-Höhe  
         NULL, // Kein Parent-Fenster  
         NULL, // Kein Menu  
         hInstance, // Instanz  
         NULL))) // Leite nichts an WM_CREATE weiter  
     { 
         KillGLWindow(); // Resette die Ansicht  
         MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
         return FALSE; // Gebe FALSE zurück  
     } 

      static PIXELFORMATDESCRIPTOR pfd= // pfd teilt Windows mit, wie wie die Dinge haben wollen  
      { 
          sizeof(PIXELFORMATDESCRIPTOR), // Größe des Pixel Format Descriptors  
          1, // Versions Nummer  
          PFD_DRAW_TO_WINDOW | // Format muss Fenster unterstützen  
          PFD_SUPPORT_OPENGL | // Format muss OpenGL unterstützen  
          PFD_DOUBLEBUFFER, // Muss Double Buffering unterstützen  
          PFD_TYPE_RGBA, // Fordere ein RGBA Format an  bits, // wähle unsere Farbtiefe aus  
          0, 0, 0, 0, 0, 0, // Color Bits werden ignoriert  
          0, // Kein Alpha Buffer  
          0, // Shift Bit wird ignoriert  
          0, // Kein Accumulation Buffer  
          0, 0, 0, 0, // Accumulation Bits werden ignoriert  
          16, // 16Bit Z-Buffer (Depth Buffer)  
          0, // Kein Stencil Buffer  
          0, // Kein Auxiliary Buffer 
          PFD_MAIN_PLANE, // Haupt-Zeichen-Schicht  
          0, // Reserviert  
          0, 0, 0 // Layer Masken werden ignoriert  
      };

      if (!(hDC=GetDC(hWnd))) // Haben wir einen Device Kontext erhalten?  
      { 
          KillGLWindow(); // Resette die Anzeige  
          MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
          return FALSE; // Gebe FALSE zurück  
      }

      if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Hat Windows ein passendes Pixel Format gefunden?  
      { KillGLWindow(); // Resette die Anzeige  
      MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Gebe FALSE zurück  
      } 

      if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Können wir das Pixel Format setzen?  
      { KillGLWindow(); // Resette die Anzeige  
      MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Gebe FALSE zurück  
      }

      if (!(hRC=wglCreateContext(hDC))) // Können wir einenRendering Kontext kriegen?  
      { 
          KillGLWindow(); // Resette die Anzeige  
          MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
          return FALSE; // Gebe FALSE zurück  
      }

       if(!wglMakeCurrent(hDC,hRC)) // Versuche den Rendering Kontext zu aktivieren  
       { 
           KillGLWindow(); // Resette die Anzeige  
           MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
           return FALSE; // Gebe FALSE zurück  
       } 

       ShowWindow(hWnd,SW_SHOW); // Zeige das Fenster  
       SetForegroundWindow(hWnd); // Etwas höhere Priorität  
       SetFocus(hWnd); // Setze den Tastatur-Fokus auf das Fenster  
       ReSizeGLScene(width, height); // Initialisiere unseren perspektivischen GL-Screen 

       if (!InitGL()) // Initialisiere unser neu erzeugtes GL Fenster  
       { 
           KillGLWindow(); // Resette die Anzeige  
           MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Gebe FALSE zurück  
       }
       return TRUE; // Erfolg 
} 

LRESULT CALLBACK WndProc( HWND hWnd, // Handle für dieses Fenster 
                         UINT uMsg, // Nachricht für dieses Fenster  
                         WPARAM wParam, // Weitere Nachrichten Informationen  
                         LPARAM lParam) // Weitere Nachrichten Informationen 
{ 
    switch (uMsg) // Überprüfe auf Fenster-Nachrichten  
    { 
        case WM_ACTIVATE: // Wenn Aktivierungs-Nachricht reinkommt  
            { 
                if (!HIWORD(wParam)) // Überprüfe Minimierungs-Status  
                { active=TRUE; // Programm ist aktiv  
                } else { 
                    active=FALSE; // Programm ist nicht länger aktiv  
                } return 0; // Kehre zurück zur Nachrichten-Schleife  
            } 

            case WM_SYSCOMMAND: // hereinkommende System Befehle  
                { 
                    switch (wParam) // Überprüfe auf System Aufrufe  
                    { 
                    case SC_SCREENSAVE: // versucht der Screensaver sich zu starten?  
                    case SC_MONITORPOWER: // versucht der Monitor in den Energiesparmodus zu gehen?  
                        return 0; // verhindere das  
                    } 
                    break; // Ende  
                } 

                case WM_CLOSE: // Haben wir eine Nachricht zum Schließen erhalten?  
                    { 
                        PostQuitMessage(0); // Sende eine Beenden-Nachricht  
                        return 0; // Springe zurück  
                    } 

                    case WM_KEYUP: // Wurde eine Taste losgelassen?  
                        { 
                            keys[wParam] = FALSE; // Wenn ja, markiere sie mit FALSE  
                            return 0; // Springe zurück  
                        } 

                        case WM_SIZE: // ändere die Größe des Fenster  
                            { 
                                ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Breite, H
                                return 0; // Springe zurück  
                            } 
    } 

     // Übergebe alle nicht bearbeiteten Nachrichten an DefWindowProc  
    return DefWindowProc(hWnd,uMsg,wParam,lParam); 
} 

int WINAPI WinMain( HINSTANCE hInstance, // Instanz  HINSTANCE hPrevInstance, // vorherige Instanz  
                   LPSTR lpCmdLine, // Kommandozeilen Parameter  
                   int nCmdShow) // Fenster Anzeige Status 
{ 
    MSG msg; // Windows Nachrichten Struktur  
    BOOL done=FALSE; // Bool Variable um die Schleife zu beenden 
    
    // erzeuge unser OpenGL Fenster  
    if (!CreateGLWindow("NeHe's OpenGL Framework",640,480,16,fullscreen)) 
    { 
        return 0; // Beende, wenn Fenster nicht erzeugt wurde  
    } 

    while(!done) // Schleife die so lange läuft, bis done=TRUE  
    {
        if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Wartet eine Nachricht?  
        { 
            if (msg.message==WM_QUIT) // Haben wir eine Nachricht zum beenden erhalten?  
            { 
                done=TRUE; // Wenn ja done=TRUE  
            } else // Wenn nicht, bearbeite die Fenster-Nachrichten  
            { 
                TranslateMessage(&msg); // Übersetze die Nachricht  
                DispatchMessage(&msg); // bearbeite die Nachricht  
            } 
        } else // Wenn da keine Nachrichten sind  
        { 
            // Zeichne die Szene. Schau nach der ESC-Taste und Beendigungs-Nachrichten von DrawGLScene()  
            if (active) // Programm aktiv?  
            { 
                if (keys[VK_ESCAPE]) // Wurde ESC gedrückt?  
                { 
                    done=TRUE; // ESC Signalisiert, dass Beendet werden soll  
                } else // Es ist noch nicht Zeit zum beenden, zeichne Screen neu  
                { 
                    DrawGLScene(); // Zeichne die Szene  
                    SwapBuffers(hDC); // Swap Buffers (Double Buffering)  
                } 
            } 

            if (keys[VK_F1]) // Wurde F1 gedrückt?  
            { 
                keys[VK_F1]=FALSE; // Wenn ja, setze Taste auf FALSE  
                KillGLWindow(); // Kill unser aktuelles Fenster  
                fullscreen=!fullscreen; // Wechsel zwischen Fullscreen und Fester-Modus  // Erzeuge unser OpenGL Fenster erneut  
                if (!CreateGLWindow("NeHe's OpenGL Framework",640,480,16,fullscreen)) 
                { 
                    return 0; // Beenden, wenn das Fenster nicht erzeugt wurde  
                }
            }
        }
    }

    // Shutdown  
    KillGLWindow(); // Kill das Fenster  
    return (msg.wParam); // Beende das Programm 
}