Mac4Ever Refurb Guide d'achat Apple - Des conseils sur toute la gamme Apple Débuter sur Mac
La programmation Open GL sur OS X
Actu Dossiers Forum Photos/Podcasts Petites Annonces V.I.P.
4380 connectés

La programmation Open GL sur OS X

Le 06/11/2001 à 00h00
Petit avertissement...


Tout d'abord, un petit avertissement : pour programmer en Open GL, il faut utiliser le langage C. Si vous n'en connaissez pas les bases, vous allez vous sentir un peu perdu. Toutefois, cet article est plutôt simple à comprendre, et vous pouvez toujours faire un simple copier coller et suivre les instructions. Sachez seulement qu'il faut respecter les majuscules et la syntaxe. Les passages situés derrière // ou entre /* et */ sont des commentaires qui ne sont pas nécessaire ni pris en charge par le compilateur mais je vous conseille fortement d'en mettre si vous voulez vous y retrouver.

Vous allez aussi devoir installer les developpers tools inclus dans la boite de Mac OS X.

Créer un projet


La programmation Open GL sur OS X
Pour commencer, vous devez créer un nouveau projet. Faites 'newproject' dans le menu file. Choisissez 'empty project' et faites next. Donnez un nom et un emplacement au nouveau projet. Une fenêtre s'ouvre: c'est votre environnement de travail. A gauche, vous pourrez voir tout les fichiers qui composent votre programme et les visualiser dans la fenêtre principale en cliquant dessus.

Faites 'new target' dans le menu project, choisissez "cocoa application" et faites next. Donnez lui un nom et ajoutez la à votre projet. Elle apparaîtra à gauche dans l'onglet targets.

Vous devez maintenant ajouter les librairies glut à votre programme. Faite add framework dans le menu project et sélectionnez "GLUT.framework", "AppKit.framework" et "OpenGL.framework". Ajoutez le à votre projet. Il devrait apparaître dans l'onglet files.

Faites maintenant new file dans le menu file et sélectionnez "C file". Appelez le fichier "source.c".

Vous devriez normalement avoir quelquechose qui ressemble à la copie d'écran ci-dessus (attention ! le point à gauche de source.c et des trois ".framework" doit être présent, sinon cliquez à leur gauche pour qu'il apparaisse).

Le programme


Cliquez sur source.c dans l'onglet files. Son contenu apparaît au centre.
Rajoutez "#include ‹GLUT/glut.h›" en dessous de "#include ‹CARBON/carbon.h›" afin d'établir un lien entre les librairies openGL et votre programme.

Nous avons maintenant besoin de définir quelques valeurs:
tapez ces 2 lignes :

#define kWWidth 500
#define kWHeight 500


Le programme se compose pour l'instant de 3 fonctions: une d'initialisation, une pour donner des instructions (en l'occurrence, dessiner quelque chose) et une pour exécuter le tout.

Voici la première qui se contente d'initialiser les fonctions openGL :

GLvoid initialisation(GLvoid) { // n'oubliez pas l'accolade pour ouvrir et fermer la fonction
glClearColor(0.0f,0.0f,0.0f,0.0f); /* les f après les valeurs sont nécessaires pour indiquer qu'il s'agit de décimaux*/
glClearDepth(1.0);

// Ça, c'est juste pour tout remettre à 0
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)kWWidth/(GLfloat)kWHeight,0.1f,100.0f);
glMatrixMode(GL_MODELVIEW);
/*et tout ça, c'est des histoires de modes de projections. On va pas rentrer dans les details, Vous les mettez, sans vous en occuper.
N'oubliez pas l'accolade pour signaler au programme la fin de votre fonction.*/
}


La prochaine étape consiste à écrire une fonction qui va créer des polygones

Pour cela, il faut définir les coordonnées de chaque point dans l'espace. On peut régler 3 valeurs par point : x,y et z: respectivement la longueur, la hauteur et la profondeur. Le plus difficile est de se représenter les points dans l'espace. Je vous conseille pour cela de faire un petit schéma. Les points sont calculés à partir du centre que l'on peut déplacer avec la fonction "translatef(x,y,z)". On utilise la fonction glVertex3f(x,y,z) pour définir la position des points.

Par exemple, un simple carré aura donc besoin de 4 points :
1er point: en haut à droite -> glVertex3f(1.0f,1.0f,0.0f);
c'est à dire 1 unité au dessus du centre et une unité à droite du centre.
2e point: en haut à gauche -> glVertex3f(-1.0f,1.0f,0.0f);
c'est à dire 1 unité au dessus du centre et une unité à gauche du centre.
3e point: en bas à gauche -> glVertex(-1.0f,-1.0f,0.0f);
c'est à dire 1 unité en dessous du centre et une unité à gauche du centre.
4e point: en bas à droite -> glVertex3f(1.0f,1.0f,0.0f);
c'est à dire 1 unité en dessous du centre et une unité à droite du centre.

Note: il est impératif de suivre cet ordre sinon vous allez vous retrouver avec des formes bizarres n'ayant rien à voir avec votre carré.

Mais ce n'est pas tout, il faut aussi définir une couleur sinon, vous ne verrez pas vos polygones. On utilise la fonction glColor3f(r,g,b) où r,g et b sont red green et blue. En mélangeant ces 3 trois couleurs, vous pouvez obtenir toutes les couleurs. Pour trouver à quelles couleurs correspondent les valeurs, utilisez n'importe quel logiciel de dessin (graphic converter par exemple) et choisissez le mode rgb, faites des essais et une fois la couleur trouvée, retenez les valeurs pour le rouge le bleu et le vert (100 % correspond à1.0f et 50% correspond à 0.5f). Le moyen le plus simple est d'utiliser seulement le bleu, le rouge ou le vert : il suffit de mettre 1.0f pour la couleur désirée et 0.0f pour les autres.

La programmation Open GL sur OS X


Exemple : pour du bleu, on donnera les valeurs suivantes "glColor3f(0.0f,0.0f,1.0f);" -> 0% de rouge, 0% de vert et 100% de bleu mais pour du violet, il faudra utiliser plusieurs couleurs :

"glColor3f(0.5f,0.0f,1.0f);" -> 50% de rouge, 0% de vert et 100% de bleu

Sachez aussi que 100% de chaque couleur donne du blanc et 0 % de chaque couleur donne du noir.

Voici donc la fonction de dessin :

GLvoid creation(GLvoid) {

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // le signe | s'obtient avec shift alt l
glLoadIdentity();
glTranslatef(0.0f,0.0f,-5.0f); // recule le centre de 5
glBegin(GL_QUADS); // mode de dessin : carrés

/*face frontale*/

glColor3f(0.0f,0.0f,1.0f); // couleur: bleu
glVertex3f(-1.0f,1.0f,0.0f);
glVertex3f(1.0f,1.0f,0.0f);
glVertex3f(1.0f,-1.0f,0.0f);
glVertex3f(-1.0f,-1.0f,0.0f);

/*face arrière*/

glColor3f(1.0f,0.0f,0.0f);
glVertex3f(-1.0f,1.0f,-1.0f);
glVertex3f(1.0f,1.0f,-1.0f);
glVertex3f(1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);

/*dessus du cube*/

glColor3f(0.0f,1.0f,0.0f);
glVertex3f( 1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);

/*dessous du cube */

glColor3f(1.0f,0.0f,0.0f);
glVertex3f( 1.0f,-1.0f, 1.0f);
glColor3f(1.0f,1.0f,1.0f);
glVertex3f(-1.0f,-1.0f, 1.0f);
glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f( 1.0f,-1.0f,-1.0f);

La programmation Open GL sur OS X
/*côté gauche du cube*/

glColor3f(0.0f,0.5f,1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f, 1.0f);

/*côté droit du cube */

glColor3f(0.5f,0.0f,1.0f);
glVertex3f( 1.0f, 1.0f,-1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f,-1.0f, 1.0f);
glVertex3f( 1.0f,-1.0f,-1.0f);

glEnd(); // fin du mode carré
glPushMatrix(); //valider le tout
glutSwapBuffers(); // afficher
}


Et enfin, la fonction principale, qui va faire appel à toutes les autres :

int main(int argc,char** argv) {
glutInit(&argc, argv); //initialisation ...
glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | GLUT_DOUBLE); // encore de l'initialisation
glutInitWindowSize(kWWidth,kWHeight); // initialisation de la taille d la fenetre du programme
glutInitWindowPosition(250,250); // initialisation de la position de la fenêtre du programme
glutCreateWindow("mac4ever"); // création de la fenêtre du programme avec le nom mac4ever
initialisation(); // appel à la fonction initialisation
glutDisplayFunc(creation); // le programme se sert de la fonction creation pour afficher le contenu
glutMainLoop();
return 0; // cette instruction est requise par l' ANSI C
}


Voilà ! Une fois que vous avez écrit tout ça, compilez et lancez le programme (ou faites directement pomme R).
C'est bien beau me direz vous, mais on voit qu'un côté. Logique !

Nous allons donc rajouter de quoi faire tourner notre cube:
Tout d'abord, rajoutez la variable "GLfloat r = 0.0f;" après "#define kWHeight 500" au début du fichier:

Puis il nous faut une 4e fonction :

GLvoid Idle(GLvoid) {
r += 0.5f; // augmente la vitesse de 0.5
glutPostRedisplay(); // redessine l'objet
}


Dans la fonction main(),
après "glutDisplayFunc(creation);" , ajoutez à la ligne "glutIdleFunc(Idle);"
puis ajoutez "r=0;" avant "return 0;"

Ensuite, dans la fonction creation() rajoutez juste ceci avant "glBegin(GL_QUADS)"
"glRotatef(r,1.0f,1.0f,0.0f);" où r indique la vitesse de rotation, les 3 autres valeurs correspondant
aux trois axes. Dans ce cas-ci, le cube tourne autour d'un axe vertical et horizontal.

La source complète en une seule partie


#include ‹GLUT/glut.h›

#define kWWidth 500
#define kWHeight 500

GLfloat r = 0.0f;

GLvoid initialisation(GLvoid) {

glClearColor(0.0f,0.0f,0.0f,0.0f);
glClearDepth(1.0);
/* Ca, c'est juste pour tout remettre à 0 */
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)kWWidth/(GLfloat)kWHeight,0.1f,100.0f);
glMatrixMode(GL_MODELVIEW);

/*N'oubliez pas l'accolade pour signaler au programme la fin de votre fonction.*/
}

GLvoid Idle(GLvoid) {

r += 0.5f; // augmente la vitesse de 0.5
glutPostRedisplay(); // redessine l'objet
}

GLvoid creation(GLvoid) {

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f,0.0f,-5.0f); // recule le centre de 5
glRotatef(r,1.0f,1.0f,0.0f); /*r indique la vitesse de rotation, les 3 autres valeurs correspondant
aux trois axes. Dans ce cas-ci, le cube tourne autour d'un axe vertical et horizontal. */
glBegin(GL_QUADS); // mode de dessin : carrés

/*face frontale*/

glColor3f(0.0f,0.0f,1.0f); // couleur: bleu
glVertex3f(-1.0f,1.0f,1.0f); // en haut àgauche
glVertex3f(1.0f,1.0f,1.0f); // en haut à droite
glVertex3f(1.0f,-1.0f,1.0f); // en bas à droite
glVertex3f(-1.0f,-1.0f,1.0f); // en bas à gauche

/*face arrière*/

glColor3f(1.0f,0.0f,0.0f); rouge
glVertex3f(-1.0f,1.0f,-1.0f); // en haut à gauche
glVertex3f(1.0f,1.0f,-1.0f); // en haut à droite
glVertex3f(1.0f,-1.0f,-1.0f); // en bas à droite
glVertex3f(-1.0f,-1.0f,-1.0f); // en bas à gauche

La programmation Open GL sur OS X
/*dessus du cube*/

glColor3f(0.0f,1.0f,0.0f); vert
glVertex3f( 1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);

/*dessous du cube */

glColor3f(1.0f,0.0f,0.0f); rouge
glVertex3f( 1.0f,-1.0f, 1.0f);
glColor3f(1.0f,1.0f,1.0f);
glVertex3f(-1.0f,-1.0f, 1.0f);
glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f( 1.0f,-1.0f,-1.0f);

/*côté gauche du cube*/

glColor3f(0.0f,0.5f,1.0f); orange
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f, 1.0f);

/*côté droit du cube */

glColor3f(0.5f,0.0f,1.0f); violet
glVertex3f( 1.0f, 1.0f,-1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f,-1.0f, 1.0f);
glVertex3f( 1.0f,-1.0f,-1.0f);

glEnd(); // fin du mode carrés
glPushMatrix(); //valider le tout
glutSwapBuffers(); // afficher
}

int main(int argc,char** argv) {

glutInit(&argc, argv); //initialisation ...
glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | GLUT_DOUBLE); // encore de l'initialisation
glutInitWindowSize(kWWidth,kWHeight); /* initialisation de la taille de la fenêtre du programme */
glutInitWindowPosition(250,250); /* initialisation de la position de la fenetre du programme*/
glutCreateWindow("mac4ever"); /* création de la fenêtre du programme avec le nom mac4ever*/
initialisation(); /*appel à la fonction initialisation*/
glutDisplayFunc(creation); /*le programme se sert de la fonction creation pour afficher le contenu */
glutIdleFunc(Idle); /* appel de la fonction pour augmenter la vitesse et ainsi fair tourner le cube */
glutMainLoop();
r=0;
return 0; // cette instruction est requise par l' ANSI C
}


A vous de jouer...


Et voilà le travail ! Vous avez maintenant un joli cube qui tourne sur lui même ! Et ça sert à quoi ? A rien ! C'est juste pour faire joli ;-).

Maitenant que vous connaissez la marche à suivre pour programmer des scènes OpenGL, à vous d'étendre et de nous développer des Quake IV ou Unreal II...
partage email

Protéger un dossier grâce à Applescript.

Les bases de la programmation

chargement des réactions

Réagissez à ce dossier !

Pour réagir directement dans le forum, cliquez ici.
Pour réagir, vous devez être identifié.
Si vous ne possédez pas de compte, créez-en un !
Identifiant :
Mot de passe :
Gras Italique Souligné Image URL Smiley confus Smiley cool Smiley M. Vert Smiley malsain Smiley mort de rire Smiley geek Smiley surpris
Important : soyez concis, courtois et pertinents. (plus d'infos ?) Les messages injurieux et hors sujet seront effacés. En cas de non respect de ces instructions, le compte d'un utilisateur pourra être bloqué sans préavis.
Pour toute erreur dans un article, merci de nous le signaler en nous contactant ici.

Conseils d'achat

  • Macintosh

  • iPhone, iPad & iPod

iMac 27" 5k Indicateur rouge Informations 06/2017 2099 € L'iMac 27" (Retina) a été mis à jour le 5 juin 2017 avec Thunderbolt 3, GPU dédié et puces Kaby-Lake. On attend des modèles Coffee Lake (à 6 coeurs) d'ici le courant du printemps/été 2018.
iMac 21,5" 4k Indicateur rouge Informations 06/2017 1499 € L'iMac 21,5" (Retina) a été mis à jour le 5 juin 2017 avec Thunderbolt 3, GPU dédié et puces Kaby-Lake. On attend des modèles Coffee Lake (à 6 coeurs) d'ici le courant du printemps/été 2018.
Apple TV 4k Indicateur vert Informations 09/2017 199 € L'Apple TV 4k est une petite évolution de l'Apple TV pour les téléviseurs 4k. Il gère le HDR, le HDMI 2a et tous les codecs récents. Si vous avez une télévision OLED 4k, il s'agit du modèle idéal. Son prix est raisonnable par rapport à la version HD, qui reste au catalogue.
iMac Indicateur rouge Informations 06/2017 1299 € L'iMac 21,5" (non Retina) a été mis à jour le 5 juin 2017 avec Thunderbolt 3 et puces Kaby-Lake. On attend des modèles Coffee Lake (à 6 coeurs) d'ici le courant du printemps/été 2018.
iMac Pro Indicateur vert Informations 12/2017 5499 € L'iMac Pro est actuellement le Mac le plus puissant du marché. Il ne sera pas renouvelé avant une bonne année, sauf surprise. N'hésitez pas à consulter nos tests et nos vidéo avant de vous décider ! A noter qu'Apple va sortir un Mac Pro courant 2018 (ou 2019), donc si vous n'êtes pas trop pressé, il sera + modulaire...
Mac Mini Indicateur rouge Informations 10/2014 549 € Le Mac mini a été mis à jour fin 2014, avec quelques améliorations notables, comme Thunderbolt 2, WiFi ac. Son prix a également fortement baissé, mais au prix d'un boiter moins évolutif (RAM soudée) et d'absence de quadri-coeur. Actuellement, la machine est un peu vieillotte, et l'on vous déconseille de l'acheter, sauf pour de la petite bureautique. On espère vraiment qu'Apple renouvellera le Mac mini cette année... Regardez aussi du côté du Refurb, où l'on trouve régulièrement des modèles à partir de 459€ !
Mac Pro Indicateur rouge Informations 10/2013 3339 € Apple a annoncé un nouveau Mac Pro courant 2018 (voire 2019), plus modulaire et moins fermé que la version actuelle. Dans tous les cas, surtout n'achetez pas les modèles "tube" datant de 2013 et désormais assez dépassés.
MBP Retina 13" Indicateur rouge Informations 06/2017 1499 € Le MacBook Pro 13" a été mis à jour le 5 juin 2017, avec peu de nouveautés, en dehors du passage à Kaby-Lake. Une MAJ interviendra sans doute durant le printemps/été 2018 (avec des puces à 4 coeurs en vue !)
MBP Retina 15" Indicateur rouge Informations 06/2017 2799 € Le MacBook Pro 15" a été mis à jour le 5 juin 2017, avec peu de nouveautés, en dehors du passage à Kaby-Lake et de "nouveaux" GPU. Une MAJ interviendra sans doute durant le printemps/été 2018 (avec des puces à 6 coeurs en vue !)
MacBook Air Indicateur rouge Informations 06/2017 1099 € Le MacBook Air a été "mis à jour" le 5 juin 2017, avec des fréquences légèrement supérieures, mais aucune autre nouveauté. Attention ! Alors que l'on pensait la machine en fin de vie, une rumeur insistante évoque la sortie d'un MacBook Air "Low Cost" entre avril et juin.
MacBook Indicateur rouge Informations 06/2017 1499 € Le MacBook a été mis à jour le 5 juin 2017, avec peu de nouveautés, en dehors du passage à Kaby-Lake. Une MAJ interviendra sans doute durant le printemps/été 2018.
Apple TV 2015 Indicateur vert Informations 10/2015 159 € L'Apple TV 2015 est sortie fin 2015 et Apple le garde au catalogue malgré l'arrivée de la version 4k. Avec en prime, une petite baisse de prix ! Si vous n'avez pas de TV 4k, cela reste une bonne affaire.
Téléchargez nos
applications mobiles
À découvrir sur Mac4Ever
b 1  b 2 
Mon Mac4Ever
Pour participer, vous devez être identifié.
Si vous ne possédez pas de compte, vous pouvez en créer un gratuitement !
Identifiant :
Mot de passe :
Sondage
Que manque-t-il au HomePod pour l'acheter ?
2410 votes
app
  • Nouveautés

  • Gratuites

  • Payantes

A propos | Mentions légales | Infos Cookies | Contacts | Emploi | RSS | Apps