//---------------------------------------------------------------------------

#include <windows.h>
#include <gl\glaux.h>
#include <gl\glu.h>
#include <gl\gl.h>

HDC hDC;
HGLRC hRC;
HWND hWnd;
HINSTANCE hInstance;

bool keys[256];
bool active = true;
bool fullscreen = true;

LRESULT CALLBACK WinProc( HWND, UINT, WPARAM, LPARAM );
GLvoid ReSizeGLScene( GLsizei ,GLsizei );
int InitGL();
int DrawGLScene();
GLvoid KillGLWindow();
bool CreateGLWindow( char *titel, int width, int height, int bits ,
                     bool fullscreenflag );

int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine, int nCmdShow ) {

    MSG messages;

    if( MessageBox( NULL,
                    "Soll das Programm im Vollbildmodus erstellt werden?",
                    "Fenstereinstellung", MB_YESNO | MB_ICONQUESTION ) ==IDNO ) {

        fullscreen = false;
    }

    CreateGLWindow( "OpenGL", 800, 600, 16, fullscreen );

    while( GetMessage( &messages, 0, 0, 0 ) ) {

        TranslateMessage( &messages );
        DispatchMessage( &messages );

        DrawGLScene();
        SwapBuffers( hDC );

    }
    return messages.wParam;
}

GLvoid ReSizeGLScene( GLsizei width, GLsizei height ) {  // init OpenGL Fenster

    if( height == 0 ) {

        height = 1;
    }

    glViewport( 0, 0, width, height );  // mittelpkt. der perspetive wird 0/0 gesetzt
    glMatrixMode( GL_PROJECTION );  //festlegung der projectionsmatrix
    glLoadIdentity();   //anpassung der projection
    gluPerspective( 45.0f, ( GLfloat ) width / (GLfloat ) height, 0.1f, 100.0f );
        //verhältnis von hoehe und breite + verzerungswinkel von 45,0°
    glMatrixMode( GL_MODELVIEW );   // festlegunf der model-view matrix
    glLoadIdentity();    // anpassung der modele

}   // ende der init des OpenGL Fensters

int InitGL() {  //init der OpenGL

    glShadeModel( GL_SMOOTH );  // glSmooth sorgt fuer schoene farbübergänge auf körpern
    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); // fensterBG per RGB + alphafactor( transparenz )
    glClearDepth( 1.0f ); // bewirkt das räumliche ausehen von uebereinander liegenden Objecten
    glEnable( GL_DEPTH_TEST ); // aktiviert den depth test
    glDepthFunc( GL_LEQUAL );   // der typ des depthtest wird festgelegt
    glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );    //perspektive wird festgelegt

    return true;
}

int DrawGLScene() { // hier passieren alle zeichen aktionen

    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );   // löscht vorigen bildshcirm fuer
                                                            // naechste scene
    glLoadIdentity();   // matrix wird wieder zurückgesetzt

    return true;
}

GLvoid KillGLWindow() {     // schliesst das GL Fenster

    if( fullscreen ) {

        ChangeDisplaySettings( 0, 0 );   // kehrt zum desktop zurück
        ShowCursor( true ); // abgeschalteter mauszeiger wird wieder sichtbat
    }

    hDC = NULL;
    hRC = NULL;
    hInstance = NULL;
    hWnd = NULL;
}

bool CreateGLWindow( char *titel, int width, int height, int bits ,
                     bool fullscreenflag ) {

    GLuint Pixelformat; // speichert pixelformat
    WNDCLASS wc;
    DWORD wndExStyle;   //speichert zusätzliche infos ueber das fenster
    DWORD wndStyle;     //speichert fenster eigenschaften
    RECT wndRect;   // hier wird die auflösung gespeichert

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

    fullscreen = fullscreenflag;
    hInstance = GetModuleHandle( 0 );

    wc.lpfnWndProc = WinProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.lpszMenuName = 0;
    wc.lpszClassName = "OpenGL";
    wc.hIcon = LoadIcon( NULL, IDI_APPLICATION );
    wc.hCursor = LoadCursor( NULL, IDC_ARROW );
    wc.hbrBackground = NULL;
    wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

    RegisterClass( &wc );

    if( fullscreen ) {      // soll fenster im Vollbildmodus laufen ?

        DEVMODE displaySettings;

        memset( &displaySettings, 0, sizeof( displaySettings ) );

        displaySettings.dmSize = sizeof( displaySettings );
        displaySettings.dmPelsWidth = width;
        displaySettings.dmPelsHeight = height;
        displaySettings.dmBitsPerPel = bits;
        displaySettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

        ChangeDisplaySettings( &displaySettings, CDS_FULLSCREEN );
    }

    if( fullscreen ) {  // konnte in Vollbildmodus geschaltet werden

        wndExStyle = WS_EX_APPWINDOW;
        wndStyle = WS_POPUP;
        ShowCursor( false );
    }

    else {

        wndExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;    // window erhält 3D rahmen
        wndStyle = WS_OVERLAPPEDWINDOW;
    }

    // das verdecken des fensters durch schaltflaechen wird anoliert
    AdjustWindowRectEx( &wndRect, wndStyle, false, wndExStyle );

    hWnd = CreateWindowEx( wndExStyle,
                           "OpenGL",
                           "Mein erstes OpenGL - Fenster",
                           WS_CLIPSIBLINGS | WS_CLIPCHILDREN | wndStyle,
                           0, 0,
                           wndRect.right - wndRect.left, wndRect.bottom - wndRect.top,
                           NULL,
                           NULL,
                           hInstance,
                           NULL );

    static PixelFormat;
    static PIXELFORMATDESCRIPTOR pfd = {

        sizeof( PIXELFORMATDESCRIPTOR ),
        1,  //versionnummer
        PFD_DRAW_TO_WINDOW |    // foramt muss im fenster sichtbar sien
        PFD_SUPPORT_OPENGL |    //unterstuetzt OpenGL
        PFD_DOUBLEBUFFER,       // doublebuffering wird unterstuetzt
        PFD_TYPE_RGBA,          // unterstuetzt RGB + alpha f.
        bits,                   // farbtiefe
        0, 0, 0, 0, 0, 0,
        0,                      // kein alphabuffer
        0,                      // shift bit ignoriet
        0,                      // kein accumulationsbuffer
        0, 0, 0, 0,
        16,                     // 16-Bit Depth-Buffer
        0,                      // kein stencil buffer
        0,                      // kein auxiliary buffer
        PFD_MAIN_PLANE,         // hauptebene auf der später gezeichnet wird
        0,                      // unwichtig
        0, 0, 0 };              // keine ebenenmasken benötigt

        hDC = GetDC( hWnd );

        PixelFormat = ChoosePixelFormat( hDC, &pfd );   // sucht ein passendes PixelFormat
        SetPixelFormat( hDC, PixelFormat, &pfd );       // verwendet PixelFormat

        wglMakeCurrent(hDC,hRC); // verucht hRC zu aktivieren

        ShowWindow( hWnd, SW_SHOW );    // zeigt fenster an
        SetForegroundWindow( hWnd );    // erhöt priorität des fensters
        SetFocus( hWnd );               // leitet keyboardbefele an das fenster
        ReSizeGLScene( width, height ); // aktiviert perspective

        InitGL();                       // läd die openGL ( texturen, lich .... )

        return true; // alles klappt
}

LRESULT CALLBACK WinProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) {

    switch( message ) {

        case WM_ACTIVATE: {

            if( !HIWORD( wParam ) ) {   // ist das prog nicht minimiert

                active = true;
            }

            else {

                active = false;
            }
            return 0;
        }

        case WM_SIZE: {

            ReSizeGLScene( LOWORD( lParam ), HIWORD( lParam ) );
            return  0;
        }

        case WM_SYSCOMMAND: {   // ist ein systemcommand, wie zB.
                                // "Bildschirmschoner soll gestartet werden!", vorhanden
            switch( wParam ) {

                case SC_SCREENSAVE:    // bildschirmschoner soll gestartet werden
                case SC_MONITORPOWER:   // monitor soll in standby
                return 0;               // für beide fälle liefer NULL zurück
            }
            return 0;
        }

        case WM_KEYDOWN: {

            keys[wParam] = true;

            if( keys[VK_F1] ) {

                keys[VK_F1] = false;
                KillGLWindow();

                fullscreen =! fullscreen;
                return 0;
            }

            if( keys[VK_ESCAPE] ) {

                SendMessage( hWnd, WM_DESTROY, 0, 0 );
                return 0;
            }
            return 0;
        }

        case WM_KEYUP: {

            keys[wParam] = false;
            return 0;
        }

        case WM_DESTROY: {

            KillGLWindow();
            PostQuitMessage( 0 );
            return 0;
        }
    }
    return DefWindowProc( hWnd, message, wParam, lParam );
}

gibt es eine einfachere variante ein openGL fenster zu erstellen, könnt eich an meinen code was weglassen????
danke, für kommende antworten.

SetPixelFormat( hDC, PixelFormat, &pfd );       // verwendet PixelFormat

        hRC = wglCreateContext(hDC);  // <-- fehlte.

        wglMakeCurrent(hDC,hRC); // verucht hRC zu aktivieren

Bei mir hats danach funktioniert.