Convertissez le framework VC OPENGL de NeHe traduit par CKER en version Delphi.
J'espère que cela sera utile aux frères qui utilisent Delphi pour apprendre OPENGL.
Je ne sais pas pourquoi, mais il ne peut pas s'exécuter directement dans mon environnement Delphi, mais cela semble bien fonctionner sur d'autres machines.
Ma machine ne peut compiler et exécuter que des fichiers EXE.
Merci à NeHe pour avoir fourni un si bon cadre et merci à CKER pour la traduction des informations VC.
PROgramme Projet1 ;
Utilisations
ouvert,
les fenêtres,
Messages ;
Const
WND_TITLE = 'Cadre de base OPenGl'; //Titre
Var
//================================================= ===========================
// Chaque OpenGL est connecté à un contexte d'ombrage. La table de contexte d'ombrage connecte tous les appels OpenGL à
// Recevoir le contexte du périphérique (table de description du périphérique) et définir la table de description d'ombrage OpenGL comme hRC, afin que le programme puisse
// S'il suffit de dessiner la fenêtre, vous devez également créer une table de description des appareils Windows est définie comme hdc,
// DC connecte la fenêtre à GDI (Graphics Device Interface). Et RC connecte OpenGL
// à DC.
//================================================= ===========================
h_RC : HGLRC ; // Contexte de rendu (tableau de description d'ombrage).
h_DC : HDC ; // Contexte du périphérique (tableau de description du périphérique)
h_Wnd : HWND ; // handle de fenêtre
h_Instance : HINST ; // Instance de programme (instance).
keys : Array[0..255] Of Boolean; // Tableau pour les routines de clavier
{$R *.res}
//================================================= ==============================
// Réinitialise la taille de la scène OpenGL, que la taille de la fenêtre ait changé ou non (en supposant que le mode plein écran n'est pas utilisé).
//Même lorsque la fenêtre ne peut pas être redimensionnée (par exemple en mode plein écran), elle s'exécutera toujours au moins une fois————————
//Définit la perspective au début du programme. La taille de la scène OpenGL sera définie sur la taille de la fenêtre dans laquelle elle est affichée.
//================================================= ==============================
Procédure glResizeWnd(Width, Height: Integer); //Réinitialise et initialise la taille de la fenêtre GL
Commencer
If (Height = 0) Then // Empêche la hauteur d'être 0 et de provoquer une exception de division par 0.
Hauteur := 1;
glViewport(0, 0, Largeur, Hauteur); //Réinitialiser la fenêtre actuelle (Viewport)
//Les lignes suivantes configurent l'écran de perspective. Cela signifie que les choses plus éloignées semblent plus petites. Cela crée une réalité
//Scène d'apparition. La perspective ici est calculée comme un angle de vision de 45 degrés en fonction de la largeur et de la hauteur de la fenêtre. 0,1f, 100,0f sont
//Le point de départ et le point final de la profondeur que nous pouvons dessiner dans la scène.
//glMatrixMode(GL_PROJECTION) spécifie que les deux prochaines lignes de code affecteront la matrice de projection.
//La matrice de projection est chargée d'ajouter de la perspective à notre scène.
//glLoadIdentity() est similaire à réinitialiser. Il restaure l'état matriciel sélectionné à son état d'origine.
//Après avoir appelé glLoadIdentity(), nous définissons la perspective de la scène.
glMatrixMode(GL_PROJECTION); //Sélectionnez la matrice de projection
glLoadIdentity(); // Réinitialise la matrice de projection
gluPerspective(45.0, Largeur / Hauteur, 0.1, 100.0); // Calcule la proportion d'apparence de la fenêtre
//glMatrixMode(GL_MODELVIEW) spécifie que toute nouvelle transformation affectera la matrice modelview (matrice d'observation du modèle).
//Nos informations sur les objets sont stockées dans la matrice d'observation du modèle.
glMatrixMode(GL_MODELVIEW); //Sélectionner la matrice d'observation du modèle
glLoadIdentity(); //Réinitialiser la matrice d'observation du modèle
//Si vous ne comprenez pas encore ce que signifient ces termes, ne vous inquiétez pas.
// Sachez simplement que vous devez le faire si vous voulez obtenir une superbe scène en perspective.
Fin;
//================================================= ==============================
// Effectuez tous les paramètres pour OpenGL. Définissez la couleur pour effacer l'écran, activez le cache de profondeur,
// Activer l'ombrage fluide (lissage des ombres), etc. Cette routine n'est appelée qu'une fois la fenêtre OpenGL créée.
// Ce processus aura une valeur de retour. Mais l'initialisation ici n'est pas si compliquée et il n'y a pas encore lieu de s'inquiéter de la valeur de retour.
//================================================= ==============================
Procédure glInit();
Commencer
//Définit la couleur utilisée lors de l'effacement de l'écran. Si vous n'êtes pas sûr du fonctionnement de la couleur, voici une explication rapide.
//Les valeurs de couleur vont de 0,0f à 1,0f. 0,0f représente la situation la plus sombre et 1,0f la situation la plus lumineuse.
//Le premier paramètre après glClearColor est l'intensité du rouge (composant rouge), le deuxième est vert et le troisième est bleu.
//La valeur maximale est également de 1,0f, ce qui représente le cas le plus brillant d'un composant de couleur spécifique. Le dernier paramètre est la valeur Alpha.
//Lorsqu'il est utilisé pour effacer l'écran, ne vous souciez pas du quatrième chiffre. Maintenant, que ce soit 0,0f.
//En mélangeant trois couleurs primaires (rouge, vert, bleu), vous pouvez obtenir des couleurs différentes
//Donc, utilisez glClearColor(0.0f,0.0f,1.0f,0.0f), votre bleu pour effacer l'écran.
//Si vous utilisez glClearColor(0.5f,0.0f,0.0f,0.0f), le rouge moyen sera utilisé pour effacer l'écran.
//Pas le plus brillant (1,0f), ni le plus sombre (0,0f). Pour obtenir un fond blanc, toutes les couleurs doivent être réglées au maximum (1.0f).
//Si vous voulez un fond noir, définissez toutes les couleurs sur les plus sombres (0,0f).
glClearColor(0.0, 0.0, 0.0, 0.0); // fond noir
// Le lissage des ombres mélange finement les couleurs à travers les polygones et lisse la lumière externe.
glShadeModel(GL_SMOOTH); // Activer le lissage des ombres
//La prochaine chose à faire concerne le tampon de profondeur. Considérez le tampon de profondeur comme une couche derrière l'écran.
//Le tampon de profondeur garde en permanence une trace de la profondeur à laquelle l'objet entre dans l'écran. Ce programme n’utilise pas réellement le cache de profondeur.
//Mais presque tous les programmes OpenGL qui affichent des scènes 3D à l'écran utilisent des tampons de profondeur. Son ordre détermine quel objet est dessiné en premier.
//De cette façon, vous ne dessinez pas de carré derrière un cercle sur le cercle. Le tampon de profondeur est une partie très importante d'OpenGL.
glClearDepth(1.0); //Définit le tampon de profondeur
glEnable(GL_DEPTH_TEST); // Activer les tests de profondeur
glDepthFunc(GL_LESS); // Type de test de profondeur effectué
// Ensuite, dites à OpenGL que nous voulons la meilleure correction de perspective possible.
//Cela affectera très légèrement les performances. Mais cela rend la perspective un peu meilleure.
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Correction de perspective vraiment fine
Fin;
//================================================= ==============================
//Tout le code du dessin. Tout ce que vous souhaitez afficher à l'écran apparaîtra dans ce code.
//Chaque programme futur ajoutera un nouveau code ici.
//================================================= ==============================
Procédure glDraw();
Commencer
glClear(GL_COLOR_BUFFER_BIT Ou GL_DEPTH_BUFFER_BIT); // Effacer l'écran et le tampon de profondeur
glLoadIdentity(); //Réinitialiser la matrice d'observation du modèle actuel
Fin;
Fonction WndProc(hWnd: HWND; // handle de fenêtre
Msg : UINT ; // Message de la fenêtre
wParam : WPARAM ; // Contenu supplémentaire du message
lParam : LPARAM // Contenu supplémentaire du message
) : LRESULT ;
Commencer
Résultat := 0;
Cas (Msg) de // Vérifier les messages Windows
WM_ACTIVATE : // Message d'activation de la fenêtre du moniteur
Commencer
Fin;
WM_CREATE : // Créer
Commencer
Fin;
WM_CLOSE : // ferme
Commencer
PostQuitMessage(0); //Envoyer un message de sortie
Résultat := 0
Fin;
WM_KEYDOWN : // touche enfoncée
Commencer
keys[wParam] := True; // Si oui, défini sur TRUE
Résultat := 0;
Fin;
WM_KEYUP : // Libère la clé
Commencer
keys[wParam] := False; // Si oui, défini sur FALSE
Résultat := 0;
Fin;
WM_SIZE : //Ajuster la taille de la fenêtre OpenGL
Commencer
glResizeWnd(LOWord(lParam), HIWORD(lParam)); //LoWord=Largeur,HiWord=Hauteur
Résultat := 0;
Fin;
WM_TIMER : //minuteries
Commencer
Fin;
Sinon //Laissez Windows gérer le reste.
Résultat := DefWindowProc(hWnd, Msg, wParam, lParam); // Passe tous les messages non traités à DefWindowProc.
Fin;
Fin;
//================================================= ==============================
// Appelé uniquement avant la fin du programme. La fonction consiste à libérer la table de contexte de coloration, la table de contexte de périphérique et le handle de fenêtre en séquence.
// Ajout de nombreuses vérifications d'erreurs. Si le programme ne parvient pas à détruire une partie de la fenêtre, un message d'erreur approprié apparaîtra.
// fenêtre de message,
//================================================= ==============================
Procédure glKillWnd(Plein écran : Booléen);
Commencer
//La première chose à faire dans KillGLWindow() est de vérifier s'il est en mode plein écran.
//Si oui, revenez au bureau. La fenêtre aurait dû être détruite avant de désactiver le mode plein écran,
//Mais faire cela sur certaines cartes graphiques peut faire planter le bureau. Il est donc préférable de désactiver d’abord le mode plein écran.
//Cela évitera les plantages du bureau et fonctionnera très bien sur les cartes graphiques Nvidia et 3dfx !
Si Plein écran Alors // En mode plein écran ?
Commencer
// Utilisez ChangeDisplaySettings(NULL,0) pour revenir au bureau d'origine.
// Prend NULL comme premier paramètre,
// Passer 0 comme deuxième paramètre oblige Windows à utiliser la valeur actuellement stockée dans le registre
// (résolution par défaut, profondeur de couleur, taux de rafraîchissement, etc.) pour restaurer efficacement mon bureau d'origine.
// Après être revenu au bureau, le pointeur de la souris doit être à nouveau visible.
ChangeDisplaySettings(devmode(Nil^), 0); // Si oui, revenez au bureau
ShowCursor(True); //Afficher la souris
Fin;
// S'il dispose d'une table de description des couleurs (hRC).
Si h_RC > 0 Alors
//Voir si nous pouvons le libérer (séparer hRC de hDC).
Si (Pas wglMakeCurrent(h_DC, 0)) Alors
MessageBox(0, 'DC et RC ne peuvent pas être libérés !', 'Erreur', MB_OK ou
MB_ICONERROR);
// La table de description des ombres peut-elle être supprimée ?
Si (Pas wglDeleteContext(h_RC)) Alors
Commencer
MessageBox(0, 'Échec de la suppression de la table de contexte d'ombrage !', 'Erreur', MB_OK Ou
MB_ICONERROR);
h_RC := 0;
Fin;
//Si la table contextuelle du périphérique existe, et si c'est le cas, essayez de la publier.
Si ((h_DC > 0) Et (ReleaseDC(h_Wnd, h_DC) = 0)) Alors
Commencer
MessageBox(0, 'Échec de la libération du contexte du périphérique !', 'Erreur', MB_OK ou
MB_ICONERROR);
h_DC := 0;
Fin;
//S'il existe un handle de fenêtre, appelez DestroyWindow(hWnd) pour essayer de détruire la fenêtre
Si ((h_Wnd <> 0) Et (Not DestroyWindow(h_Wnd))) Alors
Commencer
MessageBox(0, 'Impossible de détruire le formulaire !', 'Erreur', MB_OK Ou
MB_ICONERROR);
h_Wnd := 0;
Fin;
// Classe de fenêtre de déconnexion
//Cela nous permet de détruire la fenêtre normalement puis d'ouvrir d'autres fenêtres,
//Vous ne recevrez pas de messages d'erreur tels que "Classe Windows déjà enregistrée" (classe de fenêtre déjà enregistrée).
Si (Not UnRegisterClass('OpenGL', hInstance)) Alors
Commencer
MessageBox(0, 'Impossible de se déconnecter de la classe de fenêtre !', 'Erreur', MB_OK Ou
MB_ICONERROR);
hInstance := 0;
Fin;
Fin;