|
OpenGL-Fenster :
Die Windows-Programmierung in C/C++ kann schnell zu unübersichtlichen Listings führen.
In dieser ersten OpenGL-Anwendung sind daher einige
Programmschritte bereits zu Prozeduren zusammengefaßt, die sich
später leicht in Header-Dateien auslagern lassen.
Die wohl wichtigste ist EnableOpenGL, die nahezu jedes Fenster
(auch Labels, Buttons etc.) zur OpenGL-Anzeige umfunktionieren kann.
Perspektive paßt die Betrachterperspektive den Fensterproportionen an,
und InitialPosition hebt vorangegangene Dreh- und Verschiebungen auf,
damit ein neueingefügtes 3D-Objekt an seiner Initialposition erscheint.
Die ZeitProzedur ruft alle 40ms OpenGL_Zeichnen auf (25 Bilder/Sekunde).
|
|
|
Die folgenden OpenGL-Anwendungen benötigen die Bibliotheken opengl32.lib und glu32.lib
(in Dev-C++ sind es die Dateien libopengl32.a und libglu32.a im lib-Verzeichnis;
außerdem unter "Projektoptionen" Win32-GUI wählen),
sowie user32.lib und gdi32.lib. Ebenfalls müssen die beiden Header-Dateien gl.h
und glu.h eingebunden werden.
|
// Win32-API: Simple OpenGL-Window (Author: Claude Jacobs, 2013)
// req: opengl32.lib glu32.lib user32.lib gdi32.lib
//-------------------------------------------------
#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>
//============== Globale Variablen deklarieren =================
HWND hFenster ; // Handle des Fensters deklarieren
int Breite=400, Hoehe=300; // Fenstergröße
int Timer1Nummer;
HDC hDCopenGL; HGLRC hRCopenGL; // für OpenGL
GLfloat xrot=20, yrot=70, xpan=0.0, ypan=0.0, Distanz= -4.0; // Sicht
float winkel=0.0; // Animation
//============== Eigene Prozeduren =============================
void Perspektive (int b,int h)
{glMatrixMode(GL_PROJECTION); glLoadIdentity();
if (b*h >= 1) {glViewport(0, 0, b, h); gluPerspective(45.0, (float)b/h, 0.1, 2000);}
glMatrixMode(GL_MODELVIEW);}
//-------------------------------------------------
void InitialPosition (float xr, float yr, float xp, float yp, float dist)
{glLoadIdentity();
glTranslatef(xp, yp, dist); // Sichtpunkt
glRotatef(-yr, 1.0f, 0.0f, 0.0f); glRotatef(xr, 0.0f, 0.0f, 1.0f);} // Sichtwinkel
//-------------------------------------------------
void EnableOpenGL(HWND hFen, HDC * hDCopenGL, HGLRC * hRCopenGL)
{PIXELFORMATDESCRIPTOR Pix;
*hDCopenGL = GetDC(hFen); // get the device context (DC)
ZeroMemory( &Pix, sizeof(Pix) ); // set the pixel format for the DC
Pix.nSize = sizeof(Pix);
Pix.dwFlags = PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER;
Pix.iPixelType = PFD_TYPE_RGBA; Pix.iLayerType = PFD_MAIN_PLANE;
Pix.cColorBits = 24; Pix.cDepthBits = 16; Pix.nVersion = 1;
SetPixelFormat( *hDCopenGL, ChoosePixelFormat(*hDCopenGL, &Pix), &Pix);
*hRCopenGL = wglCreateContext(*hDCopenGL); wglMakeCurrent(*hDCopenGL, *hRCopenGL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_BLEND); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.0);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glClearDepth(1.0f); glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);glDepthMask(TRUE);
glShadeModel(GL_SMOOTH);
}
//-------------------------------------------------
void DisableOpenGL(HWND hFen, HDC hDCopenGL, HGLRC hRCopenGL)
{KillTimer(hFenster,Timer1Nummer);
wglMakeCurrent(hDCopenGL, NULL);
wglDeleteContext( hRCopenGL );
ReleaseDC(hFen, hDCopenGL);}
//-------------------------------------------------
void OpenGL_Zeichnen(void)
{
glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glPushMatrix();
//---
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_CULL_FACE);
InitialPosition(xrot, yrot, xpan, ypan, Distanz);
glRotatef(winkel, 0.0f, 0.0f, 1.0f);
glBegin(GL_QUADS);
glColor4f (1.0,0.0, 0.0, 1.0); glVertex3f(-1.0, -1.0, 0.0);
glColor4f (0.0,0.0, 1.0, 1.0); glVertex3f(1.0, -1.0, 0.0);
glColor4f (0.0,1.0, 0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
glColor4f (1.0,1.0, 0.0, 1.0); glVertex3f(-1.0, 1.0, 0.0);
glEnd();
glPopMatrix();
SwapBuffers(hDCopenGL);
}
//================= Timer-Prozedur ===============================
void CALLBACK ZeitProzedur(HWND hFenster, UINT Befehle, UINT idEvent, DWORD dwTime)
{winkel=winkel+1.0; OpenGL_Zeichnen();}
//============== Prozedur des Fensters ===========================
LRESULT CALLBACK FensterProzedur (HWND hFenster, UINT Befehle, WPARAM wParam, LPARAM lParam)
{ switch (Befehle) // Befehle unterscheiden
{case WM_SIZE: {Perspektive (LOWORD(lParam), HIWORD(lParam)); break;}
case WM_DESTROY: {DisableOpenGL(hFenster, hDCopenGL,hRCopenGL); PostQuitMessage (0); break;} // Programm beenden
default: {return DefWindowProc (hFenster, Befehle, wParam, lParam);}
}
return 0; }
//============== HAUPTFUNKTION (und das Fenster erzeugen) ========
int WINAPI WinMain (HINSTANCE hInstanz, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFensterStil)
{ MSG Befehle; // eine Message-Variable deklarieren
WNDCLASSEX Klasse; // eine Fensterklassen-Variable deklarieren (für wichtige Parameter des Fensters)
Klasse.lpszClassName = "Hauptfenster" ; // Klassenname
Klasse.lpfnWndProc = FensterProzedur ; // Name der Prozedur dieses Fensters
Klasse.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
Klasse.hCursor = LoadCursor (NULL, IDC_ARROW);
Klasse.cbSize = sizeof (WNDCLASSEX);
Klasse.hInstance = hInstanz;
Klasse.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
Klasse.hIcon = LoadIcon (NULL, IDI_APPLICATION);
Klasse.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
Klasse.lpszMenuName = NULL; // Fenster hat kein Menü
Klasse.cbClsExtra = 0;
Klasse.cbWndExtra = 0;
if ( ! RegisterClassEx (&Klasse)) // Klasse registrieren (oder Fehler anzeigen)
{MessageBox(hFenster,"Fensterklasse konnte\n nicht registriert werden","Fehler", MB_OK); return 0;}
hFenster = CreateWindow ("Hauptfenster", "Titel des Fensters", WS_OVERLAPPEDWINDOW,
// Hauptfenster erzeugen :
40, 20, Breite, Hoehe, HWND_DESKTOP, NULL, hInstanz, NULL);
ShowWindow (hFenster, nFensterStil); // ... und sichtbar machen
EnableOpenGL(hFenster, &hDCopenGL, &hRCopenGL);
Perspektive (Breite, Hoehe);
Timer1Nummer=SetTimer(hFenster, 1, 40, ZeitProzedur); // Timer starten
while (GetMessage (&Befehle, NULL, 0, 0)) // Dauerschleife (sendet Befehle an obige Fensterprozedur)
{TranslateMessage(&Befehle); DispatchMessage(&Befehle);}
return Befehle.wParam; }
|
|
OpenGL mit Maus und Tastatur :
Die Maus- und Tastaturabfrage erfolgt vorwiegend in der Prozedur des OpenGL-Fensters, um
den Eindruck der Interaktivität zu vermitteln.
Da die OpenGL-Anzeige ständig gelöscht und neugezeichnet wird (hier von einem Timer),
können Variablen oder typische OpenGL-Parameter auch in den Prozeduren anderer Fenster
verändert werden.
In dieser Vorlage sind die obigen Prozeduren bereits in der Headerdatei
cj3d.h
ausgelagert, die man im Hauptprogramm mit #include "cj3d.h" einbindet. (Beim Kompilieren
muß sie sich im Verzeichnis befinden.)
|
|
// Win32-API: Interactive OpenGL-Window (Author: Claude Jacobs, 2013)
// req: opengl32.lib glu32.lib user32.lib gdi32.lib
//-------------------------------------------------
#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <stdbool.h>
#include "cj3d.h"
// Header-Datei mit Funktionen
//============== Globale Variablen deklarieren =================
HWND hFenster ; // Handle des Fensters deklarieren
int Breite=400, Hoehe=320; // Fenstergröße
GLfloat xrot=20, yrot=70, xpan=0.0, ypan=0.0, Distanz= -4.0; // Sicht
int xmaus, ymaus, xmprev, ymprev, dxmaus, dymaus; float MausFaktor=1.0;
bool Tasten[256], ToggleTasten[256];
//============== OpenGL Zeichnen ===============================
//-------------------------------------------------
void OpenGL_Zeichnen(void)
{Loeschen();
glPushMatrix();
glDisable(GL_CULL_FACE);
InitialPosition(xrot, yrot, xpan, ypan, Distanz);
glBegin(GL_QUADS);
glColor4f (1.0,0.0, 0.0, 1.0); glVertex3f(-1.0, -1.0, 0.0);
glColor4f (0.0,0.0, 1.0, 1.0); glVertex3f(1.0, -1.0, 0.0);
glColor4f (0.0,1.0, 0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
glColor4f (1.0,1.0, 0.0, 1.0); glVertex3f(-1.0, 1.0, 0.0);
glEnd();
glPopMatrix();
SwapBuffers(hDCopenGL);
}
//================= Timer-Prozedur ===============================
void CALLBACK ZeitProzedur(HWND hFenster, UINT Befehle, UINT idEvent, DWORD dwTime)
{OpenGL_Zeichnen();}
//============== Prozedur des Fensters ===========================
LRESULT CALLBACK FensterProzedur (HWND hFenster, UINT Befehle, WPARAM wParam, LPARAM lParam)
{ switch (Befehle) // Befehle unterscheiden
{
case WM_KEYDOWN :
{
if (Tasten[wParam] == FALSE)
{Tasten[wParam] = TRUE; ToggleTasten[wParam] = Tasten[wParam]^ToggleTasten[wParam];}
if (ToggleTasten['W']) {glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);}
else {glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);}
break;}
case WM_KEYUP : {Tasten[wParam] = FALSE; break;}
//----
case WM_MOUSEMOVE:{
if (wParam & MK_SHIFT) {MausFaktor=5.0;} else {MausFaktor=1.0;}
xmaus = LOWORD(lParam); ymaus = HIWORD(lParam);
if(xmaus & 1 << 15) xmaus -= (1 << 16);
if(ymaus & 1 << 15) ymaus -= (1 << 16);
if(wParam & MK_LBUTTON)
{dxmaus=xmaus-xmprev; dymaus=ymaus-ymprev;
xrot=xrot+0.2*MausFaktor*dxmaus; yrot=yrot-0.2*MausFaktor*dymaus;}
if (wParam & MK_RBUTTON)
{dxmaus=xmaus-xmprev; dymaus=ymaus-ymprev;
xpan=xpan+0.005*MausFaktor*dxmaus; ypan=ypan-0.005*MausFaktor*dymaus;}
xmprev=xmaus; ymprev=ymaus;
return 0;}
case WM_MOUSEWHEEL: {
if (LOWORD(wParam) & MK_SHIFT) {MausFaktor=5.0;} else {MausFaktor=1.0;}
if (((short)HIWORD(wParam))/120.0 > 0) {Distanz = Distanz-Distanz*0.02*MausFaktor;}
if (((short)HIWORD(wParam))/120.0 < 0) {Distanz = Distanz+Distanz*0.02*MausFaktor;}
if (Distanz<-20.0) {Distanz=-20.0;}
if (Distanz>-2.0) {Distanz=-2.0;}
return 0;}
//----
case WM_SIZE: {Perspektive (LOWORD(lParam), HIWORD(lParam)); break;}
case WM_DESTROY: {DisableOpenGL(hFenster, hDCopenGL,hRCopenGL); PostQuitMessage (0); break;} // Programm beenden
default: {return DefWindowProc (hFenster, Befehle, wParam, lParam);}
}
return 0; }
//============== HAUPTFUNKTION (und das Fenster erzeugen) ========
int WINAPI WinMain (HINSTANCE hInstanz, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFensterStil)
{ MSG Befehle; // eine Message-Variable deklarieren
WNDCLASSEX Klasse; // eine Fensterklassen-Variable deklarieren (für wichtige Parameter des Fensters)
Klasse.lpszClassName = "Hauptfenster" ; // Klassenname
Klasse.lpfnWndProc = FensterProzedur ; // Name der Prozedur dieses Fensters
Klasse.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
Klasse.hCursor = LoadCursor (NULL, IDC_ARROW);
Klasse.cbSize = sizeof (WNDCLASSEX);
Klasse.hInstance = hInstanz;
Klasse.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
Klasse.hIcon = LoadIcon (NULL, IDI_APPLICATION);
Klasse.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
Klasse.lpszMenuName = NULL; // Fenster hat kein Menü
Klasse.cbClsExtra = 0;
Klasse.cbWndExtra = 0;
if ( ! RegisterClassEx (&Klasse)) // Klasse registrieren (oder Fehler anzeigen)
{MessageBox(hFenster,"Fensterklasse konnte\n nicht registriert werden","Fehler", MB_OK); return 0;}
hFenster = CreateWindow ("Hauptfenster", "Titel des Fensters", WS_OVERLAPPEDWINDOW,
// Hauptfenster erzeugen :
40, 20, Breite, Hoehe, HWND_DESKTOP, NULL, hInstanz, NULL);
ShowWindow (hFenster, nFensterStil); // ... und sichtbar machen
EnableOpenGL(hFenster, &hDCopenGL, &hRCopenGL);
Perspektive (Breite, Hoehe);
Timer1Nummer=SetTimer(hFenster, 1, 40, ZeitProzedur); // Timer starten
while (GetMessage (&Befehle, NULL, 0, 0)) // Dauerschleife (sendet Befehle an obige Fensterprozedur)
{TranslateMessage(&Befehle); DispatchMessage(&Befehle);}
return Befehle.wParam; }
|
|
Vorschau und Vollbild mit einem POPUP-Fenster :
Die kleinere OpenGL-Anzeige ist hier ein POPUP-Fenster, dessen Position
bei Größen- oder Positionsveränderungen des Hauptfensters mit FenPos stets an die gleiche
Stelle gerückt wird. (Das Beispiel benötigt die Headerdatei
cj3d.h
).
F1: Normal-/Vollbild-Modus (ESC)
w: Flächen-/Fadenmodell (Wireframe)
Maus oder Pfeiltasten: Drehung (linke Maustatste) bzw. Verschiebung (rechte Maustaste)
Mausrad oder PgUp/PgDn: Zoom
Shift-Taste: größerer Mausfaktor
|
|
// Win32-API: Interactive OpenGL-Child-Window (Author: Claude Jacobs, 2013)
// F1=full/normal (ESC), w=wire/filled, Mouse=rotate/pan, MouseWheel=zoom
// Shift+Mouse/M.Wheel=fast, Arrows=rotate, PgUp/PgDn=zoom,
// req: opengl32.lib glu32.lib user32.lib gdi32.lib
//-------------------------------------------------
#include <windows.h>
#include <stdbool.h>
#include "cj3d.h"
// Header-Datei mit Funktionen
//============== Globale Variablen deklarieren =================
HWND hFenster, hChildFenster ; // Handles der beiden Fenster deklarieren
int Breite=300, Hoehe=240; // Child-Fenstergröße
GLfloat xrot=20, yrot=70, xpan=0.0, ypan=0.0, Distanz= -4.0; // Sicht
int xmaus, ymaus, xmprev, ymprev, dxmaus, dymaus; float MausFaktor=1.0;
bool Tasten[256], ToggleTasten[256];
//-------------------------------------------------
void FenPos(void) // OpenGL-Fenster neu-positionieren
{RECT Rechteck1, Rechteck2; int fPosX, fPosY; UINT EinAus=SWP_SHOWWINDOW;
GetWindowRect(hFenster,&Rechteck1); GetClientRect(hFenster,&Rechteck2);
fPosX=Rechteck1.left +4 + (Rechteck2.right-Breite) / 2;
fPosY=20+Rechteck1.top + (Rechteck2.bottom-Hoehe) / 2;
if ((Rechteck2.right < Breite+20)||(Rechteck2.bottom < Hoehe+20)) {EinAus = SWP_HIDEWINDOW;}
SetWindowPos( hChildFenster,HWND_TOP,fPosX,fPosY,Breite,Hoehe, EinAus);
SetFocus(hFenster);}
//============== OpenGL Zeichnen ===============================
void OpenGL_Zeichnen(void)
{Loeschen();
glPushMatrix();
glDisable(GL_CULL_FACE);
InitialPosition(xrot, yrot, xpan, ypan, Distanz);
glBegin(GL_QUADS);
glColor4f (1.0,0.0, 0.0, 1.0); glVertex3f(-1.0, -1.0, 0.0);
glColor4f (0.0,0.0, 1.0, 1.0); glVertex3f(1.0, -1.0, 0.0);
glColor4f (0.0,1.0, 0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
glColor4f (1.0,1.0, 0.0, 1.0); glVertex3f(-1.0, 1.0, 0.0);
glEnd();
glPopMatrix();
SwapBuffers(hDCopenGL);
}
//================= Timer-Prozedur ===============================
void CALLBACK ZeitProzedur(HWND hFenster, UINT Befehle, UINT idEvent, DWORD dwTime)
{
if (Tasten[VK_LEFT]) {xrot=xrot+0.5;}
if (Tasten[VK_RIGHT]) {xrot=xrot-0.5;}
if (Tasten[VK_DOWN]) {yrot=yrot+0.5;}
if (Tasten[VK_UP]) {yrot=yrot-0.5;}
if (Tasten[VK_NEXT])
{Distanz=Distanz+Distanz*0.01; if (Distanz< -20.0) {Distanz=-20.0;}}
if (Tasten[VK_PRIOR])
{Distanz=Distanz-Distanz*0.01; if (Distanz>-2.0) {Distanz=-2.0;}}
OpenGL_Zeichnen();}
//============== Prozeduren der Fenster ===========================
LRESULT CALLBACK FensterProzedur (HWND hFenster, UINT Befehle, WPARAM wParam, LPARAM lParam)
{ switch (Befehle) // Befehle unterscheiden
{
case WM_MOVE: {FenPos(); break;}
case WM_SIZE: {FenPos(); break;}
case WM_DESTROY: {DisableOpenGL(hChildFenster, hDCopenGL,hRCopenGL); PostQuitMessage (0); break;} // Programm beenden
default: {return DefWindowProc (hFenster, Befehle, wParam, lParam);}
}
return 0; }
LRESULT CALLBACK ChildFensterProzedur (HWND hFen, UINT Befehle, WPARAM wParam, LPARAM lParam)
{ switch (Befehle) // Befehle unterscheiden
{
case WM_KEYDOWN :
{
if (Tasten[wParam] == FALSE)
{Tasten[wParam] = TRUE; ToggleTasten[wParam] = Tasten[wParam]^ToggleTasten[wParam];}
if (Tasten['W']) {
if (ToggleTasten['W']) {glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);}
else {glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);}}
if (Tasten[VK_F1]) {
if (ToggleTasten[VK_F1]) {ShowWindow(hFen,SW_MAXIMIZE); ShowCursor(FALSE);}
else {ShowWindow(hFen,SW_RESTORE); ShowCursor(TRUE); }}
if (Tasten[VK_ESCAPE]) {
if (ToggleTasten[VK_F1]) {ToggleTasten[VK_F1]=FALSE;
ShowWindow(hFen,SW_RESTORE); ShowCursor(TRUE);}}
break;}
case WM_KEYUP : {Tasten[wParam] = FALSE; break;}
//----
case WM_MOUSEMOVE:{
if (wParam & MK_SHIFT) {MausFaktor=5.0;} else {MausFaktor=1.0;}
xmaus = LOWORD(lParam); ymaus = HIWORD(lParam);
if(xmaus & 1 << 15) xmaus -= (1 << 16);
if(ymaus & 1 << 15) ymaus -= (1 << 16);
if(wParam & MK_LBUTTON)
{dxmaus=xmaus-xmprev; dymaus=ymaus-ymprev;
xrot=xrot+0.2*MausFaktor*dxmaus; yrot=yrot-0.2*MausFaktor*dymaus;}
if (wParam & MK_RBUTTON)
{dxmaus=xmaus-xmprev; dymaus=ymaus-ymprev;
xpan=xpan+0.005*MausFaktor*dxmaus; ypan=ypan-0.005*MausFaktor*dymaus;}
xmprev=xmaus; ymprev=ymaus;
return 0;}
case WM_MOUSEWHEEL: {
if (LOWORD(wParam) & MK_SHIFT) {MausFaktor=5.0;} else {MausFaktor=1.0;}
if (((short)HIWORD(wParam))/120.0 > 0) {Distanz = Distanz-Distanz*0.02*MausFaktor;}
if (((short)HIWORD(wParam))/120.0 < 0) {Distanz = Distanz+Distanz*0.02*MausFaktor;}
if (Distanz<-20.0) {Distanz=-20.0;}
if (Distanz> -2.0) {Distanz=-2.0;}
return 0;}
//----
case WM_SIZE: {Perspektive (LOWORD(lParam), HIWORD(lParam)); break;}
case WM_DESTROY: {PostQuitMessage (0); break;} // Programm beenden
default: {return DefWindowProc (hFen, Befehle, wParam, lParam);}
}
return 0; }
//============== HAUPTFUNKTION (und das Fenster erzeugen) ========
int WINAPI WinMain (HINSTANCE hInstanz, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFensterStil)
{ MSG Befehle; // eine Message-Variable deklarieren
WNDCLASSEX Klasse; // eine Fensterklassen-Variable deklarieren (für wichtige Parameter des Fensters)
Klasse.lpszClassName = "Hauptfenster" ; // Klassenname
Klasse.lpfnWndProc = FensterProzedur ; // Name der Prozedur dieses Fensters
Klasse.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
Klasse.hCursor = LoadCursor (NULL, IDC_ARROW);
Klasse.cbSize = sizeof (WNDCLASSEX);
Klasse.hInstance = hInstanz;
Klasse.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
Klasse.hIcon = LoadIcon (NULL, IDI_APPLICATION);
Klasse.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
Klasse.lpszMenuName = NULL; // Fenster hat kein Menü
Klasse.cbClsExtra = 0;
Klasse.cbWndExtra = 0;
if ( ! RegisterClassEx (&Klasse)) // Klasse registrieren (oder Fehler anzeigen)
{MessageBox(hFenster,"Fensterklasse konnte\n nicht registriert werden","Fehler", MB_OK); return 0;}
hFenster = CreateWindow ("Hauptfenster", "Titel des Fensters", WS_OVERLAPPEDWINDOW,
// Hauptfenster erzeugen :
40, 20, 400, 320, HWND_DESKTOP, NULL, hInstanz, NULL);
//-------- Child-Fenster:
Klasse.lpszClassName = "Childfenster" ; // Klassenname
Klasse.lpfnWndProc = (WNDPROC)ChildFensterProzedur; // Name der Prozedur dieses Fensters
Klasse.hCursor = LoadCursor(NULL, IDC_CROSS); // Cursor als Kreuz
Klasse.style = CS_HREDRAW|CS_VREDRAW|CS_OWNDC;
if ( ! RegisterClassEx (&Klasse)) // Klasse registrieren (oder Fehler anzeigen)
{MessageBox(hFenster,"ChildFensterklasse konnte\n nicht rgistriert werden","Fehler", MB_OK); return 0;}
hChildFenster = CreateWindowEx (0, "Childfenster", "Titel des Child-Fensters",
WS_POPUP | WS_VISIBLE |WS_CLIPSIBLINGS,
300, 250, Breite, Hoehe, hFenster, NULL, hInstanz, NULL);
FenPos();
//--------
ShowWindow (hFenster, nFensterStil); // ... und sichtbar machen
EnableOpenGL(hChildFenster, &hDCopenGL, &hRCopenGL);
Perspektive (Breite, Hoehe);
Timer1Nummer=SetTimer(hFenster, 1, 40, ZeitProzedur); // Timer starten
SetFocus(hChildFenster);
while (GetMessage (&Befehle, NULL, 0, 0)) // Dauerschleife (sendet Befehle an obige Fensterprozedur)
{TranslateMessage(&Befehle); DispatchMessage(&Befehle);}
return Befehle.wParam; }
|
DISCLAIMER: THIS SITE CONTAINS LINKS TO THIRD-PARTY WEBSITES, WHICH ARE NOT UNDER THE CONTROL OF STS.
THESE LINKS ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
|
© 2013: STS Selected Technology Sites, all rights reserved.
|
|
