{
Les textures peuvent considérablement économiser du temps CPU. Haha, mais cette section m'a pris beaucoup de temps :(
Parce que la bibliothèque auxiliaire OpenGL est utilisée, peu de gens utilisent les fonctions de cette bibliothèque maintenant, mais je l'ai quand même trouvée grâce à zdcnow (Magnetic Effect), il m'a fourni la version Delphi de cette bibliothèque auxiliaire. Avant d'étudier cette section, veuillez télécharger en ligne les fichiers glaux.dll et Glaux.pas et les ajouter au projet.
Bon, continuons sur la route OPENGL.
Nous devons d’abord ajouter l’unité SysUtils, car nous allons utiliser les opérations sur les fichiers dans cette section, et nous devons également ajouter l’unité Glaux.
Ensuite, nous ajoutons plusieurs variables, xrot, yrot et zrot, basées sur la première leçon. Ces variables sont utilisées pour faire pivoter le cube autour des axes X, Y et Z. texture[] alloue un espace de stockage pour une texture. Si vous avez besoin de plus d'une texture, vous devez remplacer le numéro 1 par le numéro dont vous avez besoin.
}
VAR
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
xrot, // Montant de rotation X (nouveau)
yrot, // montant de la rotation Y (nouveau)
zrot : GLfloat; // Montant de la rotation Z (nouveau)
Texture : Array[0..1] Of GLuint; // Stocke une texture (nouveau)
{Ensuite, chargez les deux processus dans opengl32.dll, nous devons les utiliser}
PRocédure glGenTextures(n : GLsizei ; Var textures : GLuint stdcall );
opengl32;
Procédure glBindTexture(cible : GLenum ; texture : GLuint externe) ;
opengl32;
{Ensuite, nous devons ajouter une nouvelle fonction pour ressaisir l'image. Le type de retour de cette fonction est défini dans Glaux.pas comme suit :
TAUX_RGBImageRec= enregistrement
tailleX, tailleY : GLint ;
données : pointeur ;
fin;
PTAUX_RGBImageRec= ^TAUX_RGBImageRec;
La signification spécifique sera introduite plus tard}
Fonction LoadBmp (nom de fichier : pchar) : PTAUX_RGBImageRec ;
Var
BitmapFile : Thandle ; // descripteur de fichier
Commencer
//Vérifie ensuite si le nom du fichier a été fourni
Si Filename = '' Then // Assurez-vous que le nom de fichier est fourni.
result := Nil; // S'il n'est pas fourni, renvoie NULL
// Vérifiez ensuite si le fichier existe.
BitmapFile := FileOpen(Filename, fmOpenWrite); //Essayez d'ouvrir le fichier
//Si nous pouvons ouvrir le fichier, le fichier existe évidemment.
Si BitmapFile > 0 Alors // Le fichier existe-t-il ?
Commencer
//Ferme le fichier.
FileClose(BitmapFile); //Fermer le handle
//auxDIBImageLoad(Filename) lit les données d'image et les renvoie.
result := auxDIBImageLoadA(filename); //Charge le bitmap et renvoie le pointeur
Fin
Autre
//Si nous ne pouvons pas ouvrir le fichier, nous renverrons NiL.
result := Nil; // Si le chargement échoue, renvoie NiL.
Fin;
// Créez ensuite une nouvelle fonction pour charger la carte de texture
Fonction LoadTexture : booléen ;
//Variable d'état. Nous l'utilisons pour savoir si le bitmap peut être chargé et si la texture peut être créée.
// Le statut est défini sur FALSE par défaut (indiquant que rien n'est chargé ou créé).
//La variable TextureImage de type PTAUX_RGBImageRec stocke l'enregistrement d'image du bitmap.
//Cet enregistrement contient la largeur, la hauteur et les données du bitmap.
Var
Statut : booléen ;
TextureImage : Tableau[0..1] De PTAUX_RGBImageRec;
Commencer
Statut := faux ;
ZeroMemory (@TextureImage, sizeof(TextureImage)); // Place le pointeur sur NULL
TextureImage[0] := LoadBMP('Texture.bmp');
Si TextureImage[0] <> Nil Alors
Commencer
Statut := VRAI ; // Définir le statut sur VRAI
//Utilisez maintenant les données dans TextureImage[0] pour créer une texture.
//glGenTextures(1, texture[0]) indique à OpenGL que nous voulons générer un nom de texture
//(Si vous souhaitez charger plusieurs textures, augmentez le nombre).
//glBindTexture(GL_TEXTURE_2D, texture[0]) indique à OpenGL de lier le nom de texture texture[0] à la cible de texture.
//Les textures 2D n'ont qu'une hauteur (sur l'axe Y) et une largeur (sur l'axe X).
//La fonction principale attribue le nom de la texture aux données de texture.
//Dans cet exemple, nous indiquons à OpenGL que la mémoire de &texture[0] est disponible.
//La texture que nous créons sera stockée dans la zone mémoire pointée par &texture[0].
glGenTextures(1, texture[0]); // Créer une texture
glBindTexture(GL_TEXTURE_2D, texture[0]); //Utiliser une texture typique générée à partir de données bitmap
//En bas, nous créons la vraie texture.
//La ligne suivante indique à OpenGL que cette texture est une texture 2D (GL_TEXTURE_2D).
//Le chiffre zéro représente le niveau de détail de l'image, qui est généralement laissé à zéro.
//Le nombre trois est le nombre de composants des données. Parce que l’image est composée de trois composants : les données rouges, les données vertes et les données bleues.
//TextureImage[0].sizeX est la largeur de la texture.
//Si vous connaissez la largeur, vous pouvez la remplir ici, mais l'ordinateur peut facilement la déterminer pour vous.
// TextureImage[0].sizey est la hauteur de la texture.
//Le nombre zéro est la valeur de la bordure, généralement zéro.
// GL_RGB indique à OpenGL que les données d'image sont constituées de données de couleurs rouge, verte et bleue.
//GL_UNSIGNED_BYTE signifie que les données composant l'image sont de type octet non signé.
//Enfin... TextureImage[0].data indique à OpenGL la source des données de texture.
//Cet exemple pointe vers les données stockées dans l'enregistrement TextureImage[0].
// Générer une texture
glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0].sizeX,
TextureImage[0].sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE,
TextureImage[0].data);
//Les deux lignes suivantes indiquent à OpenGL lors de l'affichage de l'image,
//Quand elle est plus grande que la texture originale agrandie (GL_TEXTURE_MAG_FILTER)
// Ou la méthode de filtrage utilisée par OpenGL lorsque la texture est réduite à une taille inférieure à la texture originale (GL_TEXTURE_MIN_FILTER).
//Habituellement, j'utilise GL_LINEAR dans les deux cas. Cela permet aux textures d'apparaître en douceur de loin comme de très près de l'écran.
//L'utilisation de GL_LINEAR nécessite que le processeur et la carte graphique effectuent plus d'opérations.
//Si votre machine est lente, vous devriez probablement utiliser GL_NEAREST.
//Lorsque la texture filtrée est agrandie, elle semble très mosaïque (mosaïque).
//Vous pouvez également combiner ces deux méthodes de filtrage. Utilisez GL_LINEAR lorsque vous êtes proche et GL_NEAREST lorsque vous êtes loin.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Filtrage linéaire
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Filtrage linéaire
Fin;
//Nous libérons maintenant la mémoire précédemment utilisée pour stocker les données bitmap.
//Nous vérifions d'abord si les données bitmap sont stockées dans.
//Si c'est le cas, vérifiez si les données ont été stockées.
// S'il a été stocké, supprimez-le.
// Libérez ensuite la structure d'image TextureImage[0] pour vous assurer que toute la mémoire peut être libérée.
Si assigné(TextureImage[0]) Alors // Si la texture existe
Si attribué(TextureImage[0].data) Then // Si l'image de texture existe
TextureImage[0].data := Nil; // Libère la mémoire occupée par l'image de texture
TextureImage[0] := Nil; // Libère la structure de l'image
//Enfin, renvoie la variable d'état. Si tout va bien, la variable Status a la valeur TRUE. Sinon FAUX
résultat := Statut ; // Retourne le statut
Fin;