Comment s'y retrouver, parmis toute les fonctions ?

Est-ce qu'il y a un guide de base, qui coordonne les fonctions ? C'est-à-dire une connaissance d'un principe de base, qui fait qu'on peut savoir tout de suite ce que ça nous prend chaque fois qu'on veut créer quelque chose ? Pouvoir se dire: Je veux créer un terrain, alors j'ai besoin de ceci, cela, cette fonction-ci et ceux-là ..

J'ai regardé des tutoriels sur opengl, j'ai suivit les exemples, mais ça ne me dit pas plus, comment procéder lorsque par exemple je veux faire un terrain sur lequel un personnage pourrait marcher.

Faire des cubes et changer l'angle de vue et y placer une lumière c'est bien jolie, mais comment faire des trucs complexe ? J'aurais seulement besoin de l'idée de base .. Car j'essaie de classifier les fonctions de opengl dans ma tête, afin de savoir lorsque je veux réaliser quelque chose, mon terrain par exemple, pour savoir tout de suite ce que j'ai besoin comme fonctions. C'est-à-dire: bon pour faire mon terrain, j'ai besoin de le modéliser dans un soft 3d comme bryce admettons, ensuite je l'exporte, je vais l'importer dans mon code en temps réel, bon ensuite je dois utiliser quoi comme fonctions de opengl ? je dois y placer une lumière ? quelle sera l'angle de vue ? je dois utiliser quelle objets pour y placer tout les détails de mon terrain ? je doutes fort que ce soit une matrice pour un cube ou une sphère ... Ensuite je dois faire le rendu, mais le principe de base est que le rendu doit logiquement être fait seulement quand on à placer la caméra, déterminer la lumière, et ..est-ce qu'il manque autre chose ?

Et puis le rendu, c'est une chose, mais à partir de là, ou je places ma boucle de jeu ? seulement après le rendu ? donc mes évênements pour bouger la caméra pour me promener sur mon terrain doit être fait après le rendu, donc le rendu ne se fait qu'une seule fois lorsque le jeu démarre et ensuite ce n'est qu'une question de bouger la caméra avec les flèches et de réactions par rapport aux colisions etc ?

Est-ce que je suis dans le champs ?

Svp, le me donnez pas de lien, car j'ai regardé pas mal partout et je n'ai pas trouvé de réponse précise à ces questions, j'apprécierait beaucoup une réponse personnelle de la part de gens qui ont déjà commencé leur jeu 3d :)

Car les primitives c'est jolie en pratique, mais à moins que je me trompes, ça n'a rien à voir avec la création d'un terrain, non ? :)

Merci :D

--- Est-ce qu'il y a un guide de base, qui coordonne les fonctions ?
http://msdn.microsoft.com/library/de...unc01_9u3y.asp

--- J'ai regardé des tutoriels sur opengl, j'ai suivit les exemples, mais ça ne me dit pas plus.
As-tu bien regardé tous les tutos NeHe? Ils sont plutot bien foutus et t'apprennent tout ce dont tu as besoin pour commencer à coder en OpenGL.

--- Faire des cubes et changer l'angle de vue et y placer une lumière c'est bien jolie, mais comment faire des trucs complexe ?
En faisant des fonctions de plus haut niveau utilisant celles que tu viens de citer ;). Tu peut commencer par exemple à charger des formats de fichiers comme le MD2, 3DS pour les objets (ou TGA,BMP pour les images) ou faire tes propres formats de fichiers (par exemple pour une génération de terrain en HeightMap). Si tu recherches vraiment la complecité et une fois que tu auras BIEN compris les principes de base OpenGL(Translation,Rotation,Matrices,Normales,Texturing,............) tu pourra ptet commencer a faire des shaders (utilisant CG par ex) pour faire des effets un peu plus complexes comme les Volumetric Shadows...

--- Et puis le rendu, c'est une chose, mais à partir de là, ou je places ma boucle de jeu ?
Si tu utilises GLUT (bibliothèque bien utilise pour le développement d'applis OpenGL), tu as une boucle de rendu qui se cale automatiquement sur le taux de rafraichissement (Vertical Sync). Tu peut utiliser cette boucle dans le jeu pour timer ton prog (avec utilisation de glutGet(GLUT_ELAPSED_TIME) qui te renvoie le temps écoulé depuis le lancement) ou si vraiment tu en as besoin créer un nouveau thread mais alors la attention au problèmes de concurrence par rapport à la boucle d'affichage (rendu).

--- Est-ce que je suis dans le champs ?
Tu parles surement d'un algo archi connu dans le monde de la 3D qui s'appelle 'Frustum Culling' qui te permet de savoir si un objet et dans le plan de clipping de ta caméra(champs de vision).

--- j'apprécierait beaucoup une réponse personnelle de la part de gens qui ont déjà commencé leur jeu 3d
si tu veut tu peut matter le site de mon projet perso :P http://vinvin.dyndns.org/silmarillion
http://vinvin.dyndns.org/~tomcat
c'est un jeu de stratégie temps réel avec gestion du réseau, IA, scripting, ... (désolé pour la pub ;) )

--- Car les primitives c'est jolie en pratique, mais à moins que je me trompes, ça n'a rien à voir avec la création d'un terrain, non ?
Disons que pour la création de ton terrain tu vas avoir besoin de ces primitives car ton terrain doit etre vu comme une série de triangles(texturés, normalisés,...).

Si jamais tu as des question plus précises et plus ciblées je serai ravi d'essayer d'y répondre mais la sur ce post c'est un peu trop général on pourrait y écrire un bouquin ;)

"génération de terrain en HeightMap"

cette phrase me frappe :D il y a donc plusieurs sortes de terrains ? quand je fais un terrain avec bryce ou vue d'esprit, c'est quel genre de terrain ? est-il possible d'avoir une liste complète de tout les terrains ?

tu pourra ptet commencer a faire des shaders (utilisant CG par ex) pour faire des effets un peu plus complexes comme les Volumetric Shadows...

Qu'est-ce que des shaders et CG ?? et que veux dire volumetric shadows ? ;)

Si tu utilises GLUT (bibliothèque bien utilise pour le développement d'applis OpenGL), tu as une boucle de rendu qui se cale automatiquement sur le taux de rafraichissement (Vertical Sync). Tu peut utiliser cette boucle dans le jeu pour timer ton prog (avec utilisation de glutGet(GLUT_ELAPSED_TIME) qui te renvoie le temps écoulé depuis le lancement) ou si vraiment tu en as besoin créer un nouveau thread mais alors la attention au problèmes de concurrence par rapport à la boucle d'affichage (rendu).

la je ne comprends pas trop, moi ce que je me demande c'est lorsque quelque chose bouge dans ma scène, animation ou modification quelconque, je dois refaire le rendu à chaque changement ??

Disons que pour la création de ton terrain tu vas avoir besoin de ces primitives car ton terrain doit etre vu comme une série de triangles(texturés, normalisés,...).

Si je comprends bien, un terrain, un modèle, toute modélisation est en fait une suite de primitives formés et collés les une aux autres avec des textures ? Donc en exportant mon terrain dans un fichier texte, je vais devoir lire mon fichier texte, mettre toutes les infos dans un tableau selon une structure par primitives et ensuite parcourir ce tableau pour créer et positionner toute les primitives sur ma scène, et finalement faire le rendu ? mais comment je sais quelle primitives afficher en premier ? dois-je tout simplement lire mon fichier de haut en bas ??

Merci pour les infos :D

Citation:

---

Envoyé par AsmCode

Est-ce qu'il y a un guide de base, qui coordonne les fonctions ? C'est-à-dire une connaissance d'un principe de base, qui fait qu'on peut savoir tout de suite ce que ça nous prend chaque fois qu'on veut créer quelque chose ? Pouvoir se dire: Je veux créer un terrain, alors j'ai besoin de ceci, cela, cette fonction-ci et ceux-là ..

---

Je n'ai pas connaissance d'un tel guide et combien même je pense que c'est impossible à faire car il n'y a pas 1 façon de dessiner un terrain, un objet, un personnage animé... mais plusieurs dizaines qui dépendent des contraintes du moteur, du type de jeu, du but fixé par le créateur etc

le mieux vu les questions que tu te pose serai que tu t'achète un bouquin du style : http://www.amazon.fr/exec/obidos/ASIN/1584503521/qid=1129707076/sr=8-4/ref=sr_8_xs_ap_i4_xgl14/171-2101632-7637033
(là c'est la v5, les précédentes sont trouvables d'ocaz moins chères)
par contre ce genre de bouquin va t'orienter sur des méthodes qui ne concernent pas forcément OpenGL

en gros si tu veux faire un jeu, commence par connaitre les API que tu vas utiliser et ne te lance pas dans le code tête baissée, met sur papier tes étapes, tes situations, ce que tu auras besoin etc, c'est un travail de longue haleine et si tu n'est pas un minimum structuré tu abandonneras rapidement

bon courage

Plutot d'accord avec shenron666, ne te lance pas dessuite dans la programmation d'un moteur 3D. La prog OpenGL n'est pas compliquée mais le nombre de lignes de code grossit assez facilement, donc si tu as pas une architecture bien conçue et que tu te lances dans du code sans réfléchir, tu vas vite arriver à un nombre de lignes impressionnant et tu vas t'y perdre. Donc commence tout doucement à faire les tutoriaux NeHe et une fois que tu seras arrivé au 30-35éme tu pourra commencer à coder ton propres moteur. Pour répondre à tes questions:

--- il y a donc plusieurs sortes de terrains ?
Pas tout à fait, il y a juste plusieurs manières de représenter un terrain dans un fichier. Le HeightMapping comme son nom l'indique, ne garde dans le fichier que la hauteur des points. Il te siffit de parcourir le fichier "de haut en bas" et d'afficher un nouveau point à chaque ligne qui va former un triangle avec le point précédent.

--- Qu'est-ce que des shaders et CG ?? et que veux dire volumetric shadows ?
C'est pas pour tout dessuite, mais les shaders te permettront de faire des effets complexes très performants (car utilisant directement le GPU de ta carte graphique) comme de la réflection sur l'eau, etc. Les Volumetric Shadows est une technique permettant à un objet de projeter une ombre sur n'importe quel autre objet, y compris l'objet lui-meme. Et tu peut (c'est meme conseillé) utiliser des shaders pour le faire.

--- je dois refaire le rendu à chaque changement ?
OpengGL le fait automatiquement pour toi! Comme je te l'ai dit, il rafraichit tout seul à la meme fréquenence que ton taux de rafraichissement(60-75-80Hz). Il suffit donc par exemple de changer la position d'un objet (obj.x += 5 ;) par ex) pour que au prochain rafraichissement il se trouve à un endroit différent.

--- dois-je tout simplement lire mon fichier de haut en bas ?
Oui par exemple.

Citation:

---

--- je dois refaire le rendu à chaque changement ?
OpengGL le fait automatiquement pour toi! Comme je te l'ai dit, il rafraichit tout seul à la meme fréquenence que ton taux de rafraichissement(60-75-80Hz).

---

Pour moi tu dois refaire le rendu à chaque image après modification des positions, rotations ... les bases de toute l'animation quoi
OpenGL ne le fait pas tout seul, il faut le lui demander, lui retransmettre les nouvelles positions bref c'est tout un travail pas si simple qu'il en a l'air surtout dans un jeu complet

exacte, tu doit refaire le rendu de ta scene a chaque frame... apres tu peut utiliser des feinte comme dans far cry qui consistent a effectuer le rendu des objets lointains dans une texture, puis a afficher un billboard avec cette texture pour faire croire que tu affiche tout l'objet, ca reduit le cout du rendu mais ca fait quand même partit du rendu...

--- Pour moi tu dois refaire le rendu à chaque image après modification des positions, rotations
Oui bien sur que tu refais un rendu à chaque image mais ce que je veux dire par "OpenGL le fait pour toi" c'est que tu as pas à dire à OpenGL de modifier la position de ton objet. Par exmple tu aura dans ta boucle de rendu:
glTranslatef(x,y,z);
drawObjet();

ce qui fait que en modifiant juste x y ou z ton objet va automatiquement se trouver à une position différente sans que tu ai à dire à opengl qu'il a bougé.

Ok :D

Je comprends mieux maintenant ;)

Mais pour ce qui est des objets sur le terrain, par exemple, je charges mon terrain, je l'affiches, mais admettons qu'il y ait des choses sur le terrains, prenons par exemple un arbre. Il faudrait que je me fasse un format de fichier personnel dans lequel je vais stocké les objets qu'il y a sur mon terrain ? un peu comme une genre de base de données..

par exemple:

terrain objet position
terrain1 arbre1 x,y,z

bon, considérant, admettons le fait que quand je lis arbre1 je dois aller prendre les infos dans arbre1.3ds admettons ..

mais pour la position je suis un peu embêté, car x,y,z est une position relative par rapport à la position de mon terrain à l'écran. Comment lier cela ? parce que visuellement, je sais que mon arbre est à côté de la roche blanche dans une partie de mon terrain, mais admettons que au chargement de mon terrain la "vue" commence à l'autre bout complètement du terrain, quand je vais me "promener" sur mon terrain, quelle genre de boucle je vais devoir faire pour savoir quand il est temps d'afficher à l'horizon mon arbre ? De plus, il faudra qu'il apparaisse graduellement, car quand on voit quelque chose à l'horizon, habituellement on le voit un peu flou et progressivement, à mesure qu'on se rapproche il grossi et devient plus clair.

Ah oui et si je veux animer cet arbre, admettons je veux du vent et les feuilles doivent bouger, quelle est la meilleure technique dans ce cas ? j'aimerais bien faire de l'animation temps réel et non les calculer d'avance pour les importer, car je ne voudrais pas que les feuilles bougent toujours de la même façon en boucle. :wink:

Merci pour les infos :D

Tu es programmeur non ? programmer un jeu ne se résume pas à programmer un moteur, il va aussi faloir que tu te crée des outils, et justement il va te faloir un outil pour modéliser ton petit monde, un outil dans lequel tu importerais un terrain et des objets, où tu pourrais voir ton terrain, placer tes objets et sauvegarder un fichiers contenant les informations que tu auras besoin dans ton jeu...

Citation:

---

Ah oui et si je veux animer cet arbre, admettons je veux du vent et les feuilles doivent bouger, quelle est la meilleure technique dans ce cas ?

---

Il n'y a pas de meilleure technique, définitivement, tout dépend de ce que tu veux, du résultat que tu vises, des moyens que tu y met, tu n'animes pas un arbre dans un fps comme tu animes un arbre dans un jeu de stratégie
Si tu veux animer un objet particulier comme un arbre, crées toi une classe arbre qui va s'en occuper, cette classe contiendra les informations comme la taille les branches le feuillage etc ton arbre peut être un objet comme il peut etregénéré par un algorithme fractal ou un algo maison ou ... il y en a des tas qui existent et plus encore qui n'existent pas encore

C'est un exemple parmis tant d'autres, et il y a moins de personnes dans ce forum que de réponses possibles à ta requête

non non, la solution pour les arbres c'est de créer un arbre a partir d'un algo prenant en parametre un seed, puis de simuler les mouvements des branches a partir de physique des fluides (les branches ne sont pas des coprs solide mais semi-rigide), ce qui permet de simuler le vent dans les branches a partire de moteurs de particules qui bien entendu sera devié par les branches. ainsi tu a une simulation tres realiste de ton arbre... d'ailleurs la GeForce 9 XPTO permet de simuler ca fres facilement couplé avec une carte PPU physX :lol:

bon treve de plaisanterie, comme l'a dit shenron666 il existe des centaines de possibilitée et a mon avis tu aura a crée la tienne en fonction de ce que tu veut atteindre comme resultat...

Ok :)

Je comprends bien qu'il y ait des tas de façons, mais ça me prendrait un exemple pour pouvoir visualiser un peu comment faire, car je n'en ait pas la moindre idée, je ne saurais même pas par quoi commencer ..mis à part que je dois dabord créer l'arbre en question, mais ensuite ..

bafman, ce que tu dis m'intrigue beaucoup :D

Je ne doute pas qu'il existe des tas de façons, mais si je pouvais connaître l'adresse de certains algo ce serait déjà bien, car ce que je me demandes surtout, c'est la qualité des algos, c'est-à-dire ceux qu'on peut trouver vs. ce qui est à l'heure du jour (comme ceux qui sont utilisé dans les derniers jeux) Comment savoir ou on se situe ? Savoir si on utilise le dernier algo dernier cri ou si c'est un algo dépassé et qu'il y a mieux. Bien sûr on peut créer le nôtre, mais comme je débutes je préférerais utiliser ce qui est déjà inventé avant de ré-inventer la roue ;)

Mais j'aimerais en savoir plus sur le concept de seed pour simuler le smouvements des branches à partir de physique.

Mais que siginifie aussi quand on dit par exemple que la GeForce 9 XPTO permet de simuler cela facilement ?

Je n'arrives pas à comprendre le lien de opengl avec les cartes graphiques. On dit que Opengl est maintenant gravé sur les cartes, mais il faut tou de même inclure les dll de opengl pour notre jeux. Et quand on veut utiliser quelque chose que seule la carte x,y,z peut faire comme l'exemple mentionné ci-haut avec la GeForce, ça veut dire que il y a des fonctions dans les libs de Opengl que l'on peut utiliser, mais que dans certaines cartes, ces fonctions ne sont pas disponible alors si quelqu'un utilise le jeu avec une carte différente, on a utilisé notre fonction pour rien ? Si quelqu'un pouvait m'expliquer le lien ça serait sympa :D

Car en fait, comment fait-on pour savoir si on utilise les dernières technologies de opengl ? si je comprends bien, quand on utilise une technologie de opengl il faut aussi que les cartes graphiques le supporte sinon ça ne sert à rien ?

merci :D

Je pense vraiment que le mieux c'est que tu fasses les tutoriaux NeHe (recherche Nehe+tutorial+opengl) pour commencer et tu vas progressivement avoir des réponses aux questions que tu te poses parceque essayer de faire des arbres avec gestion du vent etc... c'est un peu trop pour un début.
Je te conseilles de commencer par essayer de faire bouger (rotations, translations, ...) un cube texturé, normalisé, éclairé,... par exemple puis après une fois que tu auras ça tu pourra commencer à voir pour la génération de ton terrain et tout doucement commencer à coder ton moteur. Mais tant que tu ne connais pas bien les concepts OpenGL c'est pas la peine de commencer à penser à des choses trop compliquées.

Ok ;) mais ça ne répond pas à ma question concernant les cartes graphiques :D

Et je voulais savoir une chose, dans les tutoriaux, on utilise par exemple pour faire un cube des valeurs entre 0 et 1. Mais je ne trouves pas cela bien précis, comment fait-on pour utiliser des valeurs précises ? par exemple si je veux un rectangle 2d de 91 pixel de largeur par 53 pixel de hauteur ?

Même question, mais pour les couleurs ? que dois-je faire si je veux pouvoir utiliser les 32 bits de couleur si je ne peux utiliser que 0 et 1 ? je ne comprends pas trop ce principe, même chose pour la position de la caméra, on doit mettre des valeur entre 0 et 1 .. :oops:

il faut savoir que en C par exemple les float sont généralement codés sur 4octets(~6 décimales)et les double 8octets(~15 décimales) si mes souvenirs sont bons donc ça reste assez précis. En général pour chaque fonction OpenGL tu as différentes version(entier, doucle et float) déterminées par leur nom, par exemple pour la fonction glColor tu as la version glColor4i (verion entiers, i pour integer), glColor4f (verion flottants, f pour float), glColor4d (verion doubles, d pour double). Par contre pour tout ce qui est déplacement (glTranslate), affichage (glVertex) etc tu n'est pas limité entre 0 et 1, tu peut très bien faire glTranlatef(8000,8000,8000); te permettant de déplacer le repère en 8000(X), 8000(Y) et 8000(Z).
Les valeurs entre 0 et 1 sont généralement pour les couleur, les valeurs d'alpha-test, les valeurs de blend,...

Ah daccord ;) ce sont donc les exemples qui sont écrit avec leur version integer au lieu de nous le montrer avec float par exemple. :oops:

Mais à quoi correspond cette échelle en nombre de pixels :?:

par exemple entre 1i et 0i il y a combien de pixels ?
Si j'utilises des float quelle est l'échelle ? est-ce que ça va toujours de 0.000000000 à 0.999999999 :?:

En ce qui concerne les couleurs, moi je suis habitué en utilisant une forme longue: rouge, vert, bleu
soit: rouge + 256*vert + 65536*bleu
comment dois-je convertir cela en float :?:

Merci encore pour votre aide :D

c'est pas en nombre de pixel car les fonctions te permettant de dessiner ne sont pas limitées entre 0 et 1 c'est juste quelques fonction (comme la fonction glColor) qui le sont, auquel cas ça correspond à un pourcentage pour chaque attribut, par ex:
glColor3f(0,0.5f,1.0f); te fait une couleur avec 0 de rouge, 0.5f de vert et 1 de bleu soit en version 8bits (0,127,255)

Les fonction de dessins ne sont pas limitées entre 0 et 1, tu peut par exemple faire:
glBegin(GL_QUADS);
glVertex3f(0,0,0);
glVertex3f(35,0,0);
glVertex3f(35,72,0);
glVertex3f(0,72,0);
glEnd();

te fait un rectngle de longueur 35 en X et 72 en Y (c'est des unités pas des pixels sauf si tu es en mode ortho, tu verras ça dans les tutos):

(0,72,0) (35,72,0)
______
| |
| |
| |
|_____|
(0,0,0) (35,0,0)

voila je peut pas faire plus simple lol ;)

ah mon dessin a foiré(manke des espaces) menfin tu vois a peut près ce ke je veux dire ;)

Daccord ;)

Mais quel est le système métrique utilisé ? est-ce que ça a un nom ?

glVertex3f(35,0,0); c'est 35 quoi si c'est pas 35 pixels ? ;)

et si par exemple je veux la couleur rgb(127,100,56) comment je fais ? :oops:

Autre question: ce que je trouves laid dans la plupart des jeux, c'est le découpage. par exemple, chaque fois qu'on voit un arbre planté au sol, si on regarde la base de l'arbre, on voit le découpage, l'arrête entre le tronc et le sol, c'est très laid. Comment fait-on pour faire un contour de particules de sables, terres, etc recouvrant la base du tronc pour faire une belle "finition" ? J'imagines que je dois utiliser un système de particules ?

J'ai de la misère à comprendre ce qu'est "une particule" c'est simplement un pixel ou bien une sphère très petite, presque de la taille d'un pixel ?

Si au lieu d'utiliser une texture pour mettre du sable par terre, je voudrais utiliser des vrais grains de sables, je devrais donc utiliser un système de particules ? Donc ça reviendrait à mettre au sol des centaines de spères ou cubes miniatures d'une couleur "sable" et toute les placer au sol dans un tas ? :D

Est-ce que je comprends bien ou si je suis totalement à côté ? :o

C'est sûr que dans ce cas-ci, ça prendrait beaucoup de ressources pour avoir un tas de sable :lol:

--- Mais quel est le système métrique utilisé ? est-ce que ça a un nom ?
Je sais pas si ça a un nom mais c'est une unités de longueur quelconque

--- glVertex3f(35,0,0); c'est 35 quoi si c'est pas 35 pixels ?
Non c'est la position en X du point, un rectangle est composé de 4 points dont tu donnes les coordonnées avec glVertex par exemple.

--- et si par exemple je veux la couleur rgb(127,100,56) comment je fais ?
Pour chaque couleur tu peut la diviser par 255 (si ton intervalle est [0-255], donc ça donnerait glColor3f(127/(float)255,100/(float)255,56/(float)255);

Pour ce qui est du "découpage", dont tu parles c'est généralment le boulot des graphistes de faire des images qui vont bien ensemble. Par exemple si tu prends WarIII, a la base de chaque arbre tu as une image qui fait une sorte de fondu entre le tronc et le sol pour rendre la transition plus douce.

--- J'ai de la misère à comprendre ce qu'est "une particule"
C'est généralement une image que tu plaques sur un carré qui fait toujours face à la caméra (pour éviter d'avoir des sphères et ainsi bcp de points). Après tu peut avoir des générateurs de particules qui sont souvent utilisés pour faire des effets de flammes ou plus souvent des sorts (comme les sorts de EQ par exemple)