spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

if(ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL){
    MessageBox(NULL,"Programm wird beendet.","ERROR",MB_OK|MB_ICONSTOP);
    return(FALSE);
}

C-/C++-Quelltext

#include <windows.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
      
HGLRC       hRC = NULL;
HDC         hDC = NULL;
HWND        hWnd = NULL;
HINSTANCE   hInstance;

bool    keys[256];
bool    active = TRUE;

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam); /* Windows MSGs */
int CreateGLWindow(char* title, GLsizei width, GLsizei height, int bits); /* Fensterklasse erstellen u. Fenster generrieren */
GLvoid KillGLWindow(GLvoid); /* Um das Fenster zu terminieren */
int InitGL(GLvoid);
GLvoid KillGLWindow(GLvoid);
int DrawGLScene(GLvoid);

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

    if(!CreateGLWindow("Ein tolles Fenster", 1024, 800, 16)) /* Generriere Fenster*/
        return(0);

    while(!done)
    {
        if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            if(msg.message==WM_QUIT)
            {
                done = 1;
            }
            else
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        else
        {
            if(active){
                if(keys[VK_ESCAPE])
                    done = 1;
                else
                {
                    DrawGLScene();
                    SwapBuffers(hDC);
                }
            }
        }
    }

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

int DrawGLScene(GLvoid)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    glTranslatef(-1.5f,0.0f,-6.0f); /* Bewege Zeiger x, y, z, */


    glBegin(GL_TRIANGLES);
        glColor3f(0.0f,0.0f,1.0f);
        glVertex3f( 0.0f, 1.0f, 0.0f);
        glVertex3f(-1.0f,-1.0f, 0.0f);
        glVertex3f( 1.0f,-1.0f, 0.0f);
    glEnd();

    glTranslatef(3.0f,0.0f,0.0f); 

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

    return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{

    switch (uMsg)
    {
/* WM_ACTIVE gibt an ob Fenster grade aktiviert wurde. Ob das Fenster Aktiviert ist oder nicht wird in wParam gespeichert */
    case WM_ACTIVATE:
        {
            if(!HIWORD(wParam))
                active = TRUE;
            else
                active = FALSE;
            return(0);
        }
    case WM_SYSCOMMAND: /* return null verhindert den start vom screensaver und vom start des monitor sandby*/
        {
            switch (wParam)
            {
                case SC_SCREENSAVE:
                case SC_MONITORPOWER:
                return(0);
            }
            break;
        }
    case WM_CLOSE: /* wenn das fenster geschlossen wird beenden wir das programm*/
        {
            PostQuitMessage(0);
            return(0);
        }
    case WM_KEYDOWN: /* Tastertureingaben aktuallisieren*/
        {
            keys[wParam] = TRUE;
            return(0);
        }

    case WM_KEYUP: /* Tastertureingaben aktuallisieren*/
        {
            keys[wParam] = FALSE;
            return(0);
        }
    }

    return DefWindowProc(hWnd,uMsg,wParam,lParam); /* alles nicht bearbeitete an nachrichten zurück an den WM*/
}

int CreateGLWindow(char* title, GLsizei width, GLsizei height, int bits)
{
    GLuint       PixelFormat;   
    WNDCLASS     wc;    
    DWORD        dwExStyle;
    DWORD        dwStyle;   
    RECT         WindowRect;

    WindowRect.left     = (long)0;      /* Größe des Fensters festlegen */
    WindowRect.right    = (long)width;
    WindowRect.top      = (long)0;
    WindowRect.bottom   = (long)height;

    hInstance = GetModuleHandle(NULL); /* Handel des aktuellen Modules bestimmen */

    wc.style            = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;  /* Fensterstrucktur ausfüllen */
    wc.lpfnWndProc      = (WNDPROC) WndProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = hInstance;
    wc.hIcon            = LoadIcon(NULL, IDI_WINLOGO);
    wc.hCursor          = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground    = NULL;
    wc.lpszMenuName     = NULL;
    wc.lpszClassName    = "OpenGL";

    if(!RegisterClass(&wc))
    {
        MessageBox(NULL,"Fensterklasse konnte nicht Registriert werden.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return(FALSE);
    }

    DEVMODE dmScreenSettings;
    memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
    dmScreenSettings.dmSize         = sizeof(dmScreenSettings); /* Grafikmodus */
    dmScreenSettings.dmPelsWidth    = width;
    dmScreenSettings.dmPelsHeight   = height;
    dmScreenSettings.dmBitsPerPel   = bits;
    dmScreenSettings.dmFields       = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;


    if(ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
    {
        MessageBox(NULL,"Programm wird beendet.","ERROR",MB_OK|MB_ICONSTOP);
        return(FALSE);
    }


    dwExStyle = WS_EX_APPWINDOW; /* alle anderen Fenster in die Taskbar */
    dwStyle = WS_POPUP;          /* Fenster als PopUp (keine ränder)    */
    ShowCursor(FALSE);           /* Den Cursor unsichbar machen         */

    AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); /* einstellungen übernehmen */

    /* Fenster erstellen wenn nicht möglich Fenster killen */
    if(!(hWnd=CreateWindowEx(   dwExStyle,
                                "OpenGL",
                                title,
                                WS_CLIPSIBLINGS | /* das Fenster darf nicht übermalt werden */
                                WS_CLIPCHILDREN |
                                dwStyle,
                                0, 0,
                                WindowRect.right - WindowRect.left,
                                WindowRect.bottom - WindowRect.top,
                                NULL,
                                NULL,
                                hInstance,
                                NULL)))
    {
        KillGLWindow();
        MessageBox(NULL, "Fenster konnte nicht erstellt werden.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;
    }

    static  PIXELFORMATDESCRIPTOR pfd= /* Pixelformart erstellen */
    {
        sizeof(PIXELFORMATDESCRIPTOR),
        1,
        PFD_DRAW_TO_WINDOW |
        PFD_SUPPORT_OPENGL |
        PFD_DOUBLEBUFFER,
        PFD_TYPE_RGBA,
        bits,
        0, 0, 0, 0, 0, 0,
        0,
        0,
        0,
        0, 0, 0, 0,
        16,
        0,
        0,
        PFD_MAIN_PLANE,
        0,
        0, 0, 0
    };

    if(!(hDC = GetDC(hWnd)))
    {
        KillGLWindow();
        MessageBox(NULL,"Konnte DC nicht erstellen.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }

    if(!(PixelFormat = ChoosePixelFormat(hDC, &pfd))) /* Suche Pixelformart */
    {
        KillGLWindow();
        MessageBox(NULL,"Konnte Pixelformat nicht finden.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }

    if(!SetPixelFormat(hDC, PixelFormat, &pfd)) /* Nutze Pixelformart */
    {
        KillGLWindow();
        MessageBox(NULL,"Konnte Pixelformat nicht nutzen.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }

    if(!(hRC = wglCreateContext(hDC))) /* Redering Context erstellen */
    {
        KillGLWindow();
        MessageBox(NULL,"Konnte Rendering Context nicht erstellen.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }

    if(!wglMakeCurrent(hDC,hRC)) /* Redering Context benutzen */
    {
        KillGLWindow();
        MessageBox(NULL,"Konnte Rendering Context nicht auswählen.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }

    ShowWindow(hWnd, SW_SHOW);    /* Fenster anzeigen                 */
    SetForegroundWindow(hWnd);    /* Fenster in Vordergrund setzen    */
    SetFocus(hWnd);               /* Den Focus auf das Fenster setzen */

    if(!InitGL()) /* OpenGL initilaisierung */
    {
        KillGLWindow();
        MessageBox(NULL,"Initailisierung Fehlgeschlagen.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }

    return TRUE;
}

GLvoid KillGLWindow(GLvoid)
{
    ChangeDisplaySettings(NULL,0); /* Auflösung und alles wieder zurücksetzen */
    ShowCursor(TRUE);

    if(hRC)
    {
        if(!wglMakeCurrent(NULL, NULL))
            MessageBox(NULL,"DC und RC löschen fehlgeschlagen.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);

        if(!wglDeleteContext(hRC))
            MessageBox(NULL,"Rendering Context löschen fehlgeschlagen.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);

        hRC=NULL;
    }

    if(hDC && !ReleaseDC(hWnd, hDC))
    {
        MessageBox(NULL,"Device Context löschen fehlgeschlagen.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hDC=NULL;
    }

    if(hWnd && !DestroyWindow(hWnd))
    {
        MessageBox(NULL,"Konnte Fenster nicht terminieren.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hWnd=NULL;
    }

    if(!UnregisterClass("OpenGL", hInstance))
    {
        MessageBox(NULL,"Konnte Fensterklasse nicht abmelden.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hInstance=NULL;
    }
}

int InitGL(GLvoid)
{
    glShadeModel(GL_SMOOTH); /* es soll Smooth-Shading verwand werden */
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f); /* Bildschirmfarbe */

    /* wenn ein Objekt hinter einem anderen liegt verdecken (Depthpuffer) */
    glClearDepth(1.0f);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    return TRUE;
}