Pour créer un projet Visual Studio 2022 afin de tester le code OpenGL donné, suivez ces étapes.
Vous devez créer une nouvelle application en mode console et la configurer pour utiliser OpenGL et GLUT.
Au préalable , si vous ne l'avez déjà fait, vous devez télécharger GLUT.
Guide Étape par Étape
1 - Ouvrir Visual Studio 2022.
2 - Créer un Nouveau Projet :
Allez dans Fichier > Nouveau > Projet.
Dans la boîte de dialogue "Créer un nouveau projet", sélectionnez Application Console et cliquez sur Suivant.
Nommez votre projet (par exemple, DiceRoller) et choisissez un emplacement pour l'enregistrer. Cliquez sur Créer.
3 - Configurer le Projet pour OpenGL et GLUT :
Faites un clic droit sur le projet dans l'Explorateur de solutions et sélectionnez Propriétés.
Dans les propriétés du projet, allez dans Propriétés de configuration > Répertoires VC++.
4 - Ajouter les Répertoires d'Inclusion :
Sous Répertoires d'inclusion, ajoutez les chemins vers vos fichiers d'en-tête OpenGL et GLUT. Par exemple, si vous avez installé GLUT dans C:\GLUT, vous ajouterez :
C:\GLUT\include
5 - Ajouter les Répertoires de Bibliothèques :
Sous Répertoires de bibliothèques, ajoutez les chemins vers vos bibliothèques OpenGL et GLUT. Par exemple :
C:\GLUT\lib
6 - Ajouter des Dépendances Supplémentaires :
Allez dans Propriétés de configuration > Linker > Entrée.
Sous Dépendances supplémentaires, ajoutez les bibliothèques suivantes :
opengl32.lib; glu32.lib; glut32.lib;
7 - Copier le DLL de GLUT :
Copiez le fichier glut32.dll dans votre répertoire de projet ou dans le répertoire contenant votre exécutable.
Alternativement, vous pouvez le placer dans C:\Windows\System32 (pour 32 bits) ou C:\Windows\SysWOW64 (pour 64 bits) si vous voulez qu'il soit disponible globalement.
8 - Ajouter le Code Fourni :
Remplacez le contenu du fichier main.cpp (ou le fichier source principal) par le code fourni ci-dessous
#include <GL/glut.h>
#include <stdlib.h>
#include <time.h>
// Identifiants de texture
GLuint textureIDs[6];
// Positions des dés
GLfloat dicePositions[5][3] = {
{-2.0f, 0.0f, 0.0f},
{-1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f},
{2.0f, 0.0f, 0.0f}
};
// Fonction pour charger les textures
void loadTextures() {
// Chargez vos textures ici
// Pour simplifier, nous utilisons des données fictives
glGenTextures(6, textureIDs);
for (int i = 0; i < 6; i++) {
glBindTexture(GL_TEXTURE_2D, textureIDs[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Remplacez par le chargement réel de la texture
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
}
}
// Fonction pour dessiner un dé
void drawDie() {
static GLfloat vertices[][3] = {
{-0.5, -0.5, -0.5}, {0.5, -0.5, -0.5}, {0.5, 0.5, -0.5}, {-0.5, 0.5, -0.5},
{-0.5, -0.5, 0.5}, {0.5, -0.5, 0.5}, {0.5, 0.5, 0.5}, {-0.5, 0.5, 0.5}
};
static GLint faces[][4] = {
{0, 1, 2, 3}, {3, 2, 6, 7}, {7, 6, 5, 4}, {4, 5, 1, 0}, {5, 6, 2, 1}, {7, 4, 0, 3}
};
for (int i = 0; i < 6; i++) {
glBindTexture(GL_TEXTURE_2D, textureIDs[i]);
glBegin(GL_QUADS);
for (int j = 0; j < 4; j++) {
glTexCoord2f(j == 0 || j == 3 ? 0.0f : 1.0f, j == 0 || j == 1 ? 0.0f : 1.0f);
glVertex3fv(vertices[faces[i][j]]);
}
glEnd();
}
}
// Callback d'affichage
void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -5.0f);
for (int i = 0; i < 5; i++) {
glPushMatrix();
glTranslatef(dicePositions[i][0], dicePositions[i][1], dicePositions[i][2]);
drawDie();
glPopMatrix();
}
glutSwapBuffers();
}
// Callback clavier
void keyboard(unsigned char key, int x, int y) {
if (key == ' ') {
// Lancer les dés
srand(time(NULL));
for (int i = 0; i < 6; i++) {
glBindTexture(GL_TEXTURE_2D, textureIDs[i]);
// Remplacez par le chargement réel de la texture
// Ici nous utilisons simplement une couleur aléatoire comme donnée fictive
GLubyte textureData[256 * 256 * 3];
for (int j = 0; j < 256 * 256 * 3; j++) {
textureData[j] = rand() % 256;
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, textureData);
}
glutPostRedisplay();
}
}
// Initialiser OpenGL
void init() {
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
loadTextures();
}
// Fonction principale
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Lancer de dés");
init();
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
9 - Construire et Exécuter le Projet :
Appuyez sur Ctrl+Shift+B pour construire le projet.
Appuyez sur F5 pour exécuter le projet.
Cela devrait configurer une application OpenGL basique qui affiche cinq dés et permet de les "lancer" en appuyant sur la barre d'espace.
Assurez-vous d'avoir les bibliothèques OpenGL et GLUT nécessaires installées et correctement référencées dans les paramètres de votre projet.
Si GLUT ne vous convient pas et que vous voulez programmer en pur code OpenGL (ce qui est mon cas).
Vous devez utiliser uniquement les fonctionnalités de base de Windows (Win32 API) pour créer une fenêtre et gérer les événements.
Voici comment vous pouvez adapter le code pour utiliser uniquement OpenGL sans GLUT.
Étapes pour Remplacer GLUT par du Code Win32
1 - Initialisation de la Fenêtre Win32 et du Contexte OpenGL
2 - Gestion des Messages de la Fenêtre
3 - Remplacement des Fonctionnalités GLUT par des Équivalents Win32
Voici le code complet pour créer une fenêtre Win32 et dessiner les dés avec OpenGL :
#include <windows.h>
#include <GL/gl.h>
#include <stdlib.h>
#include <time.h>
// Identifiants de texture
GLuint textureIDs[6];
// Positions des dés
GLfloat dicePositions[5][3] = {
{-2.0f, 0.0f, 0.0f},
{-1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f},
{2.0f, 0.0f, 0.0f}
};
// Fonction pour charger les textures
void loadTextures() {
// Chargez vos textures ici
// Pour simplifier, nous utilisons des données fictives
glGenTextures(6, textureIDs);
for (int i = 0; i < 6; i++) {
glBindTexture(GL_TEXTURE_2D, textureIDs[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Remplacez par le chargement réel de la texture
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
}
}
// Fonction pour dessiner un dé
void drawDie() {
static GLfloat vertices[][3] = {
{-0.5, -0.5, -0.5}, {0.5, -0.5, -0.5}, {0.5, 0.5, -0.5}, {-0.5, 0.5, -0.5},
{-0.5, -0.5, 0.5}, {0.5, -0.5, 0.5}, {0.5, 0.5, 0.5}, {-0.5, 0.5, 0.5}
};
static GLint faces[][4] = {
{0, 1, 2, 3}, {3, 2, 6, 7}, {7, 6, 5, 4}, {4, 5, 1, 0}, {5, 6, 2, 1}, {7, 4, 0, 3}
};
for (int i = 0; i < 6; i++) {
glBindTexture(GL_TEXTURE_2D, textureIDs[i]);
glBegin(GL_QUADS);
for (int j = 0; j < 4; j++) {
glTexCoord2f(j == 0 || j == 3 ? 0.0f : 1.0f, j == 0 || j == 1 ? 0.0f : 1.0f);
glVertex3fv(vertices[faces[i][j]]);
}
glEnd();
}
}
// Initialisation OpenGL
void initOpenGL(HWND hWnd) {
HDC hDC = GetDC(hWnd);
PIXELFORMATDESCRIPTOR pfd = {0};
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 24;
pfd.iLayerType = PFD_MAIN_PLANE;
int iFormat = ChoosePixelFormat(hDC, &pfd);
SetPixelFormat(hDC, iFormat, &pfd);
HGLRC hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
loadTextures();
}
// Fonction de rendu
void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -5.0f);
for (int i = 0; i < 5; i++) {
glPushMatrix();
glTranslatef(dicePositions[i][0], dicePositions[i][1], dicePositions[i][2]);
drawDie();
glPopMatrix();
}
// Swap the buffers
HDC hDC = wglGetCurrentDC();
SwapBuffers(hDC);
}
// Fonction de gestion des messages
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
switch (message) {
case WM_PAINT:
display();
ValidateRect(hWnd, NULL);
break;
case WM_KEYDOWN:
if (wParam == VK_SPACE) {
// Lancer les dés
srand(time(NULL));
for (int i = 0; i < 6; i++) {
glBindTexture(GL_TEXTURE_2D, textureIDs[i]);
// Remplacez par le chargement réel de la texture
// Ici nous utilisons simplement une couleur aléatoire comme donnée fictive
GLubyte textureData[256 * 256 * 3];
for (int j = 0; j < 256 * 256 * 3; j++) {
textureData[j] = rand() % 256;
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, textureData);
}
InvalidateRect(hWnd, NULL, FALSE);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
// Fonction principale
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
WNDCLASS wc = {0};
wc.lpfnWndProc = WndProc;
wc.hInstance = hInstance;
wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND);
wc.lpszClassName = L"DiceRoller";
wc.style = CS_OWNDC;
RegisterClass(&wc);
HWND hWnd = CreateWindow(wc.lpszClassName, L"Lancer de dés", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, 800, 600, NULL, NULL, hInstance, NULL);
initOpenGL(hWnd);
MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
Explication du Code
1 - Initialisation de la Fenêtre et du Contexte OpenGL :
WinMain initialise une fenêtre Win32.
initOpenGL configure le contexte OpenGL.
2 - Gestion des Messages de la Fenêtre :
WndProc gère les messages de la fenêtre, y compris le rendu (WM_PAINT) et les entrées clavier (WM_KEYDOWN).
3 - Fonction de Rendu :
display dessine les dés et échange les buffers pour afficher l'image.
4 - Lancer les Dés :
Lorsque la barre d'espace est pressée (VK_SPACE), les textures des dés sont mises à jour avec des couleurs aléatoires.
Instructions pour la Création du Projet
1 - Suivez les mêmes étapes que celui décrit précédemment pour créer un projet de type Application Console.
2 - Ajoutez le code ci-dessus dans le fichier main.cpp.
3 - Configurez les répertoires d'inclusion et les bibliothèques comme décrit précédemment.
4 - Compilez et exécutez votre projet.
Cela devrait configurer une application OpenGL basique utilisant uniquement l'API Win32 pour l'affichage et le lancement des dés.
