Warum ist m_hWnd == NULL? und warum invalid Window handle...

ja wird erstellt... registrieren funktioniert auch

Sieht so aus, als müßtest du für WS_OVERLAPPED ein parent-Fenster angeben. GetDesktopWindow() ist wahrscheinlich das, was Du suchst.

@peterchen: daran dürfte es IMHO nicht liegen.

Gibst du in WM_CREATE auch IMMER 0 zurück?
Wenn ja, dann probiers halt mal mit dem DesktopHandle .

class CWindow;

#include "Main.h"

CWindow::CWindow()
{
	m_hWnd = NULL;
}

CWindow::~CWindow()
{

}

bool CWindow::CreateGLWindow(const char *strClass, const char *strTitle, int iWidth, int iHeight, bool bSizeFixed, int iBits, bool bFullscreen,HINSTANCE hInstance)
{
	unsigned int iPixelFormat;
	WNDCLASS wc;
	DWORD dwExStyle = 0;
	DWORD dwStyle = 0;
	RECT rcWindowRect;
	rcWindowRect.left=(long)0;
	rcWindowRect.right=(long)iWidth;
	rcWindowRect.top=(long)0;
	rcWindowRect.bottom=(long)iHeight;

	m_bFullscreen = bFullscreen;
	m_hInstance = hInstance;

	strcpy(m_strClass,strClass);
	wc.style			= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc		= (WNDPROC)WndProc;
	wc.cbClsExtra		= 0;
	wc.cbWndExtra		= 0;
	wc.hInstance		= m_hInstance;
	wc.hIcon			= LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground	= NULL;
	wc.lpszMenuName		= NULL;
	wc.lpszClassName	= m_strClass;
    if (!RegisterClass(&wc))
	{
		MessageBox(NULL,"Fehler beim Registrieren der Windowklasse.","FEHLER",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}
	if (m_bFullscreen)
	{
		DEVMODE dmScreenSettings;
		memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
		dmScreenSettings.dmSize=sizeof(dmScreenSettings);
		dmScreenSettings.dmPelsWidth	= iWidth;
		dmScreenSettings.dmPelsHeight	= iHeight;
		dmScreenSettings.dmBitsPerPel	= iBits;
		dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
		if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
		{
			if(MessageBox(NULL,"Der benötigte Vollbildmodus wird nicht unterstützt von\ndeiner Grafikkarte. Soll anstelle ein Fenstermodus benutzt werden?","Eingabeaufforderung",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
			{
				m_bFullscreen = false;
			}
			else
			{
				MessageBox(NULL,"Programm wird beendet.","Fehler",MB_OK|MB_ICONSTOP);
				return false;
			}
		}
	}

	if (m_bFullscreen)
	{
		dwExStyle=WS_EX_APPWINDOW;
		dwStyle=WS_POPUP;
		ShowCursor(FALSE);
	}
	else
	{
		dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
		dwStyle=WS_OVERLAPPEDWINDOW;
	}

	AdjustWindowRectEx(&rcWindowRect, dwStyle, FALSE, dwExStyle);
    //m_hWnd = CreateWindowEx(dwExStyle,m_strClass,strTitle,dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,0,0,iWidth,iHeight,NULL,NULL,m_hInstance,NULL);
	m_hWnd = CreateWindow(m_strClass,
                       "Titelleiste",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,          /* X-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Y-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Fensterbreite              */
                       CW_USEDEFAULT,          /* Fensterhoehe               */
                       NULL,
                       NULL,
                       m_hInstance,
                       NULL);
	if (m_hWnd == NULL)
	{
		int i = GetLastError();
		KillWindow();

		MessageBox(NULL,"Fehler beim Erstellen des Fensters.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	static PIXELFORMATDESCRIPTOR pfd =
	{
		sizeof(PIXELFORMATDESCRIPTOR),
		1,
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA,								// Request An RGBA Format
		iBits,										// Select Our Color Depth
		0, 0, 0, 0, 0, 0,							// Color Bits Ignored
		0,											// No Alpha Buffer
		0,											// Shift Bit Ignored
		0,											// No Accumulation Buffer
		0, 0, 0, 0,									// Accumulation Bits Ignored
		16,											// 16Bit Z-Buffer (Depth Buffer)  
		0,											// No Stencil Buffer
		0,											// No Auxiliary Buffer
		PFD_MAIN_PLANE,								// Main Drawing Layer
		0,											// Reserved
		0, 0, 0										// Layer Masks Ignored
	};

	if (!(m_hDC=GetDC(m_hWnd)))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Erstellen des Device Contextes.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	if (!(iPixelFormat=ChoosePixelFormat(m_hDC,&pfd)))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Finden des richtigen Pixel Formates.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	if(!SetPixelFormat(m_hDC,iPixelFormat,&pfd))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Setzen des Pixel Formates.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	if (!(m_hRC=wglCreateContext(m_hDC)))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Erstellen des Render Contextes.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	if(!wglMakeCurrent(m_hDC,m_hRC))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Aktivieren des Device und Render Contextes.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}
	ShowWindow(m_hWnd,SW_SHOW);
	SetForegroundWindow(m_hWnd);
	SetFocus(m_hWnd);
	ReSizeScene(iWidth, iHeight,100.0f);
	if(!Init())
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Initalisieren.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}
	return true;
}

void CWindow::KillWindow()
{
	if(m_bFullscreen)
	{
		ChangeDisplaySettings(NULL,0);
		ShowCursor(true);
	}
	if (m_hRC)
	{
		if (!wglMakeCurrent(NULL,NULL))
		{
			MessageBox(NULL,"Fehler beim Freigeben des Render und Device Kontextes.","Fehler",MB_OK | MB_ICONINFORMATION);
		}

		if (!wglDeleteContext(m_hRC))
		{
			MessageBox(NULL,"Fehler beim Löschen des Device Kontextes.","Fehler",MB_OK | MB_ICONINFORMATION);
		}
		m_hRC=NULL;
	}

	if (m_hDC && !ReleaseDC(m_hWnd,m_hDC))
	{
		MessageBox(NULL,"Fehler beim Freigeben des Device Kontextes des Fensters.","Fehler",MB_OK | MB_ICONINFORMATION);
		m_hDC=NULL;
	}

	if (m_hWnd && !DestroyWindow(m_hWnd))
	{
		MessageBox(NULL,"Fehler beim Freigeben des Fenster Handles.","Fehler",MB_OK | MB_ICONINFORMATION);
		m_hWnd=NULL;
	}

	if (!UnregisterClass(m_strClass,m_hInstance))
	{
		MessageBox(NULL,"Fehler beim Deregistrieren der Klasse.","Fehler",MB_OK | MB_ICONINFORMATION);
		m_hInstance=NULL;
	}
}

bool CWindow::Init()
{
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	m_bActive = true;
	return true;
}

void CWindow::ReSizeScene(unsigned int iWidth, unsigned int iHeight,float fDepth)
{
	if(iHeight==0)
	{
		iHeight=1;
	}
	glViewport(0,0,iWidth,iHeight);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0f,(GLfloat)iWidth/(GLfloat)iHeight,0.1f,fDepth);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

void CWindow::DrawScene()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();

	SwapBuffers(m_hDC);
}

LRESULT CALLBACK CWindow::WindowProc(unsigned int iMsg, WPARAM wParam, LPARAM lParam)
{
	switch (iMsg)
	{
		case WM_ACTIVATE:
		{
			if (!HIWORD(wParam)) m_bActive = true;
			else m_bActive = false;
			return 0;
		}
		case WM_SYSCOMMAND:
		{
			switch (wParam)
			{
				case SC_SCREENSAVE:
				case SC_MONITORPOWER:
				return 0;
			}
			break;
		}
		case WM_CLOSE:
		{
			PostQuitMessage(0);
			return 0;
		}
		case WM_CREATE:
		{
			return 0;
		}
		case WM_KEYDOWN:
		{
			m_bKeys[wParam] = true;
			return 0;
		}
		case WM_KEYUP:
		{
			m_bKeys[wParam] = false;
			return 0;
		}
		case WM_SIZE:
		{
			ReSizeScene(LOWORD(lParam),HIWORD(lParam),100.0f);
			return 0;
		}
	}
	return DefWindowProc(m_hWnd,iMsg,wParam,lParam);
}

bool CWindow::MainLoop()
{
	if(m_bActive)
	{
		if(m_bKeys[VK_ESCAPE]) return true;
		DrawScene();
	}
	return false;
}

#include "Main.h"
#ifndef _WINDOW_H
#define _WINDOW_H

class CWindow  
{
public:
	bool MainLoop();
	LRESULT CALLBACK WindowProc(unsigned int iMsg,WPARAM wParam,LPARAM lParam);
	void DrawScene();
	void ReSizeScene(unsigned int iWidth,unsigned int iHeight,float fDepth);
	bool Init();
	void KillWindow();
	bool CreateGLWindow(const char *strClass,const char *strTitle,int iWidth,int iHeight, bool bSizeFixed,int iBits, bool bFullscreen, HINSTANCE hInstance);
	CWindow();
	~CWindow();
private:
	bool m_bActive;
	char m_strClass[256];
	bool m_bKeys[256];
	bool m_bFullscreen;
	HGLRC m_hRC;
	HINSTANCE m_hInstance;
	HWND m_hWnd;
	HDC m_hDC;
};

#endif

und die Main.cpp

#include "Main.h"

CWindow Window;

LRESULT CALLBACK WndProc(HWND hWnd,UINT	uMsg,WPARAM	wParam,LPARAM lParam)
{
    return Window.WindowProc(uMsg,wParam,lParam);
}

int WINAPI WinMain(	HINSTANCE	hInstance,HINSTANCE	hPrevInstance,LPSTR	lpCmdLine,int nCmdShow)
{
	MSG msg;
	if (!Window.CreateGLWindow("Simple WinClass","Simple WinTitle",800,600,false,32,false,hInstance))
	{
		return 0;
	}
	while(true)
	{
		if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
		{
			if (msg.message==WM_QUIT) break;
			TranslateMessage(&msg);
			DispatchMessage(&msg);

		}
		else
		{
			if(Window.MainLoop()) break;
		}
	}
    Window.KillWindow();
	return (msg.wParam);							// Exit The Program
}

Sry das ich jetzt den ganzen Code poste aber ich komm da nicht weiter... typisch Windoof