spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "main.h"


//**********************************************************************

// Lädt eine Bitmap                                                       *

//**********************************************************************


AUX_RGBImageRec *LoadBMP(const wchar_t *filename)
{
    FILE *file = NULL;                      // File-Handle


    if(!filename)
        return NULL;

    _wfopen_s(&file, filename, L"r");       // Existiert die Datei?


    if(file)                                // Falls ja...

    {
        fclose(file);                       // Handle schließen


        return auxDIBImageLoad(filename);   // Bitmap laden und Zeiger zurückgeben

    }

    return NULL;
}

//**********************************************************************

// Lädt eine Bitmap und konvertiert sie zu einer Textur                   *

//**********************************************************************


int LoadGLTextures()
{
    int status = false;

    AUX_RGBImageRec *TextureImage[1];                       // Platz für die Textur anfordern


    memset(TextureImage, 0, sizeof(void*));                 // Zeiger auf 0 setzen


    if(TextureImage[0] = LoadBMP(L"3D.bmp"))                // BMP laden

    {
        status = true;

        glGenTextures(1, &texture[0]);                      // Eine Textur erstellen


        // Erstellt eine Textur mit linearen Filtern

        glBindTexture(GL_TEXTURE_2D, texture[0]);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY,
                     0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
    }

    // Falls eine Textur existiert, Speicher freigeben

    if(TextureImage[0])
    {
        if(TextureImage[0]->data)
            free(TextureImage[0]->data);

        free(TextureImage[0]);
    }

    return status;
}   

//**********************************************************************

// Initialisierung und Anpassen des Fensters                           *

//**********************************************************************


GLvoid ResizeGLScene(GLsizei width, GLsizei height)
{
    // Division durch 0 verhindern

    if(!height)
        height = 1;

    glViewport(0, 0, width, height);                            // Viewport resetten


    glMatrixMode(GL_PROJECTION);                                // Projektionsmatrix auswählen

    glLoadIdentity();                                           // und resetten


    gluPerspective(45.0f, GLfloat(width) / GLfloat(height),     // Bildseitenverhältnis berechnen

                   0.1f, 100.0f);

    glMatrixMode(GL_MODELVIEW);                                 // Modelview-Matrix auswählen

    glLoadIdentity();                                           // und resetten

}

//**********************************************************************

// Initialisierung von OpenGL                                          *

//**********************************************************************


int InitGL(GLvoid)
{
    // Texturen laden

    if(!LoadGLTextures())
        return false;

    glEnable(GL_TEXTURE_2D);                            // Texture-Mapping aktivieren

    glShadeModel(GL_SMOOTH);                            // Smooth Shading aktivieren

    glClearColor(0.0f, 0.0f, 0.0f, 0.5f);               // Schwarzer Hintergrund

    glClearDepth(1.0f);                                 // Depth Buffer mir schwarz füllen

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  // Genaue Perspektiven Berechnungen

    glBlendFunc(GL_SRC_ALPHA, GL_ONE);                  // Blend-Funkion für Transparenz

    glEnable(GL_BLEND);

    return true;
}

//**********************************************************************

// Zeichenfunktion                                                     *

//**********************************************************************


int DrawGLScene(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);             // Bildschirm und Tiefenbuffer resetten

    glBindTexture(GL_TEXTURE_2D, texture[0]);                       // Textur auswählen


    glLoadIdentity();

    glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 0.0f);
        glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 0.0f);
        glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f, 0.0f);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f, 0.0f);
    glEnd();

    return TRUE;
}

//**********************************************************************

// Fenster löschen                                                    *

//**********************************************************************


GLvoid KillGLWindow(GLvoid)
{
    if(fullscreen)
    {
        ChangeDisplaySettings(NULL, 0);
        ShowCursor(TRUE);
    }

    if(hRC)
    {
        if(!wglMakeCurrent(NULL, NULL))
        {
            MessageBox(NULL, L"Freigabe des DC und RC fehlgeschlagen!", L"SHUTDOWN ERROR",
                       MB_OK | MB_ICONINFORMATION);
        }

        if(!wglDeleteContext(hRC))
        {
            MessageBox(NULL, L"Freigabe des RC fehlgeschlagen!", L"SHUTDOWN ERROR",
                       MB_OK | MB_ICONINFORMATION);
        }

        hRC = NULL;
    }

    if(hDC && !ReleaseDC(hWnd, hDC))
    {
        MessageBox(NULL, L"Freigabe des DC fehlgeschlagen!", L"SHUTDOWN ERROR",
                   MB_OK | MB_ICONINFORMATION);
        hDC = NULL;
    }

    if(hWnd && !DestroyWindow(hWnd))
    {
        MessageBox(NULL, L"Freigabe des hWnd fehlgeschlagen!", L"SHUTDOWN ERROR",
                   MB_OK | MB_ICONINFORMATION);
        hWnd = NULL;
    }

    if(!UnregisterClass(L"OpenGL", hInstance))
    {
        MessageBox(NULL, L"Klasse abmelden fehlgeschlagen!", L"SHUTDOWN ERROR",
                   MB_OK | MB_ICONINFORMATION);
        hInstance = NULL;
    }
}

//**********************************************************************

// Erstellt das OpenGL Fenster                                         *

//**********************************************************************


bool CreateGLWindow(wchar_t* title, int width, int height, int bits, bool fullflag)
{
    GLuint      PixelFormat;        // Beinhaltet später das passende Pixelformat

    WNDCLASS    wc;                 // Window-Class-Struktur

    DWORD       dwExStyle;
    DWORD       dwStyle;
    RECT        WindowRect;         // Obere linke + untere rechte Ecke


    // Fenstermaße setzen

    WindowRect.left = long(0);
    WindowRect.right = long(width);
    WindowRect.top = long(0);
    WindowRect.bottom = long(height);

    fullscreen = fullflag;          // Globales Fullscreen-Flag setzen


    hInstance           = GetModuleHandle(NULL);                    // Instanz für das Fenster erstellen

    wc.style            = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;       // Neu zeichnen beim Größe verstellen + eigener DC

    wc.lpfnWndProc      = WNDPROC(WndProc);                         // Zeiger auf die Fenster-Prozedur

    wc.cbClsExtra       = 0;                                        // Keine Extrabytes nach Struktur

    wc.cbWndExtra       = 0;                                        // oder Instanz

    wc.hInstance        = hInstance;                                // Instanz setzen

    wc.hIcon            = LoadIcon(NULL, IDI_WINLOGO);              // Default icon...

    wc.hCursor          = LoadCursor(NULL, IDC_ARROW);              // ...und Cursor laden

    wc.hbrBackground    = NULL;                                     // Kein Hintergrund

    wc.lpszMenuName     = NULL;                                     // Kein Menü

    wc.lpszClassName    = L"OpenGL";                                // Klassenname


    // Registriere Fensterklasse

    if(!RegisterClass(&wc))
    {
        MessageBox(NULL, L"Fehler beim Registrieren der Fensterklasse!", L"ERROR",
                   MB_OK | MB_ICONEXCLAMATION);

        return false;
    }

    // Setze Fullscreen-Modus

    if(fullscreen)
    {
        DEVMODE dmScreenSettings;                                                   // Device Mode

        memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));                     // Speicher leeren

        dmScreenSettings.dmSize = sizeof(dmScreenSettings);                         // Größe der Struktur setzen

        dmScreenSettings.dmPelsWidth = width;                                       // Breite,

        dmScreenSettings.dmPelsHeight = height;                                     // Höhe und

        dmScreenSettings.dmBitsPerPel = bits;                                       // BBP in die Struktur eintragen

        dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;   // Flags setzen


        // Ausgewählten Modus setzen

        if(ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
        {
            // Falls nicht möglich, Fenstermodus vorschlagen, andernfalls verlassen

            if(MessageBox(NULL, L"Der gewählte Vollbildmodus wird\n von ihrer Grafikkarte nicht unterstützt.\n Soll stattdessen in den Fenstermodus gewechselt werden?",
                          L"Superman", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
            {
                fullscreen = false;
            }
            else
            {
                MessageBox(NULL, L"Programm wird geschlossen...", L"ERROR",
                           MB_OK | MB_ICONSTOP);

                return false;
            }
        }
    }

    // Fullscreen-Modus erfolgreich gesetzt?

    if(fullscreen)
    {
        dwExStyle = WS_EX_APPWINDOW;                        // Erstellt ein Top-Level Fenster in der Taskleiste

        dwStyle = WS_POPUP;                                 // Popup-Fenster erstellen

        ShowCursor(false);                                  // Cursor ausblenden

    }
    else
    {
        dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;     // Top-Level-Fenster + Rahmen

        dwStyle = WS_OVERLAPPEDWINDOW;
    }

    AdjustWindowRectEx(&WindowRect, dwStyle, false, dwExStyle);     // Fenster auf die richtige Größe anpassen


    if(!(hWnd = CreateWindowEx(dwExStyle,                                       // Extended Window Style

                              L"OpenGL",                                        // Name der Klasse

                              title,                                            // Fenstertitel

                              dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,      // Window Style

                              0, 0,                                             // Fensterposition

                              WindowRect.right - WindowRect.left,               // Breite

                              WindowRect.bottom - WindowRect.top,               // Höhe

                              NULL,                                             // Kein übergeordnetes Fenster

                              NULL,                                             // Kein Menü

                              hInstance,                                        // Instanz

                              NULL)))                                           // kein Pointer

    {
        KillGLWindow();
        MessageBox(NULL, L"Fehler beim Erstellen des Fensters!", L"ERROR",
                   MB_OK | MB_ICONEXCLAMATION);

        return false;
    }

    static PIXELFORMATDESCRIPTOR pfd=
    {
        sizeof(PIXELFORMATDESCRIPTOR),                                  // Größe des PFD

        1,                                                              // Versionsnummer

        PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |                       // Format muss Fenster, OpenGL und

        PFD_DOUBLEBUFFER,                                               // Double-Buffering unterstützen

        PFD_TYPE_RGBA,                                                  // RGBA-Format anfordern

        bits,                                                           // Farbtiefe

        0, 0, 0, 0, 0, 0,                                               // Ignorierte Farbbits

        0,                                                              // ...

        0,
        0,
        0, 0, 0, 0,
        16,                                                             // 16 Bit Z-Buffer

        0,                                                              // Kein Stencil-Buffer

        0,                                                              // Kein Auxilary-Buffer

        PFD_MAIN_PLANE,                                                 // Ebene auf der gezeichnet wird

        0,
        0, 0, 0                                                         // Ignorierte Ebenen-Masken

    };

    // DC erstellen

    if(!(hDC = GetDC(hWnd)))
    {
        KillGLWindow();
        MessageBox(NULL, L"Fehler beim Erstellen des GL Device Context!", L"ERROR",
                   MB_OK | MB_ICONEXCLAMATION);

        return false;
    }

    // Konnte Windows ein passendes Pixel-Format finden?

    if(!(PixelFormat = ChoosePixelFormat(hDC, &pfd)))
    {
        KillGLWindow();
        MessageBox(NULL, L"Kein passendes Pixelformat gefunden!", L"ERROR",
                   MB_OK | MB_ICONEXCLAMATION);
        
        return false;
    }

    // Pixel-Format setzen

    if(!SetPixelFormat(hDC, PixelFormat, &pfd))
    {
        KillGLWindow();
        MessageBox(NULL, L"Pixelformat konnte nicht gesetzt werden!", L"ERROR",
                   MB_OK | MB_ICONEXCLAMATION);

        return false;
    }
    
    // RC erstellen

    if(!(hRC = wglCreateContext(hDC)))
    {
        KillGLWindow();
        MessageBox(NULL, L"Fehler beim Erstellen des GL Rendering Context!", L"ERROR",
                   MB_OK | MB_ICONEXCLAMATION);

        return false;
    }

    // RC aktivieren

    if(!wglMakeCurrent(hDC, hRC))
    {
        KillGLWindow();
        MessageBox(NULL, L"Aktivierung des GL Rendering Context fehlgeschlagen!", L"ERROR",
                   MB_OK | MB_ICONEXCLAMATION);

        return false;
    }

    ShowWindow(hWnd, SW_SHOW);              // Fenster anzeigen

    SetForegroundWindow(hWnd);              // Priorität leicht erhöhen

    SetFocus(hWnd);                         // Fokus für Tastatureingaben setzen

    ResizeGLScene(width, height);           // Das GL-Fenster initialisieren und anpassen


    // Das neu erstellte Fenster initialisieren

    if(!InitGL())
    {
        KillGLWindow();
        MessageBox(NULL, L"Initialisierung fehlgeschlagen!", L"ERROR",
                   MB_OK | MB_ICONEXCLAMATION);

        return false;
    }

    return true;
}

//**********************************************************************

// Behandelt Fenster-Nachrichten                                       *

//**********************************************************************


LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)                             // Testen, ob Message vorhanden

    {
        case WM_ACTIVATE:                   // Falls Window-Activate-Message...

        {
            if(!HIWORD(wParam))             // Minimier-Status checken

            {
                active = true;
            }
            else
            {
                active = false;
            }

            return 0;
        }

        case WM_SYSCOMMAND:                 // System-Befehle abfangen

        {
            switch(wParam)                  // System-Aufrufe checken

            {
                case SC_SCREENSAVE:         // Bildschirmschoner aktiv?

                case SC_MONITORPOWER:       // Power-safe-Modus aktiv?


                    return 0;               // Falls ja, verhindern

            }

            break;
        }

        case WM_CLOSE:                      // Gab es eine Close-Message

        {
            PostQuitMessage(0);             // Quit-Message verschicken


            return 0;
        }

        case WM_KEYDOWN:                    // Wurde eine Taste gedrückt?

        {
            keys[wParam] = true;            // mit 'true' markieren


            return 0;
        }

        case WM_KEYUP:                      // Wurde eine Taste losgelassen

        {
            keys[wParam] = false;           // wieder auf 'false' setzen


            return 0;
        }

        case WM_SIZE:                                           // OpenGL-Fenster wurde verändert

        {
            ResizeGLScene(LOWORD(lParam), HIWORD(lParam));      // An Funktion verweisen


            return 0;
        }
    }

    return DefWindowProc(hWnd, msg, wParam, lParam);            // Alle unbehandelten Messages an DefWindowProc schicken

}

//**********************************************************************

// Main-Funktion                                                       *

//**********************************************************************


int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    MSG msg;
    bool done = false;

    // User nach Vollbild fragen

    if(MessageBox(NULL, L"Soll das Programm im Vollbild-Modus gestartet werden?", L"Vollbild?",
                   MB_YESNO | MB_ICONQUESTION) == IDNO)
    {
        fullscreen = false;
    }

    // OpenGL-Fenster erstellen

    if(!CreateGLWindow(L"Superman", 640, 480, 16, fullscreen))
    {
        return 0;
    }

    // Nachrichtenschleife

    while(!done)
    {
        // Liegt eine Message vor?

        if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            // Ist es eine Quit-Message?

            if(msg.message == WM_QUIT)
            {
                // Schleife beenden

                done = true;
            }
            else
            {
                // Message übersetzen und verarbeiten

                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        else
        {
            // Szene zeichnen, auf ESC-key achten

            if((active && !DrawGLScene()) || keys[VK_ESCAPE])
            {
                done = true;
            }
            else
            {
                // Buffer zeichnen

                SwapBuffers(hDC);

                // Wurde F1 gedrückt?

                if(keys[VK_F1])
                {
                    keys[VK_F1] = false;
                    KillGLWindow();                                             // Fenster schließen

                    fullscreen = !fullscreen;                                   // fullscreen flag umkehren

    
                    if(!CreateGLWindow(L"Superman", 640, 480, 16, fullscreen))  // Neues Fenster erstellen

                    {
                        return 0;
                    }
                }
            }
        }
    }

    KillGLWindow();
    
    return(msg.wParam);
}