Problemes et questions sur le tutoriel Yes::Engine(moteur3D)

Version imprimable

17/09/2005, 03h44
filsdugrand

Problemes et questions sur le tutoriel Yes::Engine(moteur3D)

salut a tous,
je voulais developper un (petit) moteur 3d depuis un petit moment mais la difficulte de l'operation et le manque de documentation en francais(mon anglais est tres moyen) m'avaient rebutées, jusqu'a ce que je decouvre le tutu de Laurent (merci pour ce tutu au fait) tres bien fait et EN FRANCAIS donc...(je vais pas vous raconter ma vie j'ai juste pensé qu'une petite intro etait de rigeure!!) apres quelques mise a jour de mes connaissances en C++ je me suis lancée mais... il reste touours quelque interrogation et points pas tres clairs... donc 'ai decidé de créer ce topic pour poser les question qui ne manquerons pas de se poser au fur et a mesure de mon avancement dans le moteur mais aussi pour que tous ceux qui sont dans le meme cas que moi puissent poser les leurs(en esperent que le topic restera clair!!)

j'ai trouvé quelques topics sur le sjuet mais il posaient seulement une question ou deux et la plus part ne mentionnaient meme pas le moteur(je metterai les liens plus tard et si vous en trouvez envoyez les moi par MP) donc ce topic est fait pour regrouper toutes les questions/remarques(et pourquoi pas ameliorations???!) sur le tutu donc priére de garder le topic LISIBLE!!!
a tous les programeurs avancees vos conseils et votre aide est la bien venue... voila :D .

lien vers le tutoriel:
http://loulou.developpez.com/tutoriels/moteur3d/

ps: pour la lisibilite du topic priere de poser une serie de question et attendre que toutes soit resolue avant de poster un autre sujet ceci pour eviter que plusieurs reponces a des sujets differents se melengent...
17/09/2005, 04h10
filsdugrand
on commencent tout de suite avec 2 questions :

1)
dans DebugNew on surcharge l'operateur new (entre autres)
Code:

1 2 3 4 5 inline void* operator new(std::size_t Size, const char* File, int Line) { return Yes::CMemoryManager::Instance().Allocate(Size, File, Line, false); }
en augmentant le nombre de ses arguments et on defini une macro

Code:

#define new new(__FILE__, __LINE__)

pour pouvoir lui passer __LINE__ et __FILE__ (des macros???), la ligne et le ficher courent

mais..., mais ou est la question???!... j'y viens:
quelqun pourrai m'explquer comment on surcharge un operateur en augmentant le nombre de ses arguments(je ne pensais meme pas ca possible et apparament parfois ca l'est pas apparament...??!!) parceque la l'ordre des argument definis dans la macro me semble un peut bizarre(dans la macro on passe d'abord la ligne et le fichier mais dans la declaration ils sont passees en dernier).

2)
ensuite pour l'operateur delete on defini une macro qui va appeler une fonction (en plus de delete) a chaque appel de l'operateur:

Code:

#define delete Yes::CMemoryManager::Instance().NextDelete(__FILE__, __LINE__), delete

mais on ne devrais pas mettre un point virgule a la place de la virgule ici?? (en rouge):
#define delete Yes::CMemoryManager::Instance().NextDelete(__FILE__, __LINE__), delete

de plus l'auteur dit:

Citation:

partout où l'on va appeler delete, elle va insérer un appel à une fonction de notre gestionnaire de mémoire, qui va permettre de stocker la ligne et le fichier source correspondants. Pour ce faire l'opérateur virgule est tout à fait approprié, puisqu'on aura toujours au final qu'une seule instruction pour nos deux appels, cela ne perturbera pas le code avoisinant.

esqu'il parle de notre fameuse virgule et il dit qu'on aura une instruction mais on a bien deux instructions...??

merci d'avence por vos reponses!!

ps: impossible de trouver ne seraice que le prototype de l'operateur new(ou alors je suis devenu nul en google... ah tiens!) donc si qqun connait une adresse...
17/09/2005, 08h13
elekis

Citation:

quelqun pourrai m'explquer comment on surcharge un operateur en augmentant le nombre de ses arguments(je ne pensais meme pas ca possible et apparament parfois ca l'est pas apparament...??!!) parceque la l'ordre des argument definis dans la macro me semble un peut bizarre(dans la macro on passe d'abord la ligne et le fichier mais dans la declaration ils sont passees en dernier).

ici --> http://c.developpez.com/tutcpp/x3232.php (un peu plus bas dans la page )

Citation:

mais on ne devrais pas mettre un point virgule a la place de la virgule ici?? (en rouge):
#define delete Yes::CMemoryManager::Instance().NextDelete(__FILE__, __LINE__), delete

ici --> http://c.developpez.com/tutcpp/x475.php

ps, je t'avoue que je me suis poser les memes questions que toi. (et puis je suis tomber sur ce court -> http://c.developpez.com/tutcpp/book1.php
17/09/2005, 16h21
filsdugrand

ok merci je vais essayer de voir ca de plus pres.

je reviens a la charge avec une serie de petites questions:

1) dans la classe CExeption on trouve la declaration suivante

Code:

virtual const char* what() const throw();

on notera un "const throw()" je sais que throw() signifie que la fonction ne levera pas d'exeption mais le const...???

2)un peut plus tard on trouve la macro suivante
Code:

1 2 3 4 5 # define Assert(condition) if (!(condition)) \ throw CAssertException(__FILE__, __LINE__, "Condition non satisfaite\n\n" #condition) #else inline void DoNothing(bool) {} # define Assert(condition) DoNothing(!(condition))
pourquoi vouloir evaluer la condition avec DoNothingsi elle revoie TRUE c'est qu'elle a deja ete evaluée????

3)dans la classe tamplate CPlugin (qui prend en parametre tamplate T) on trouve la ligne suivante:

Code:

typedef T* (*PtrFunc)();

je ne comprend absolument pas ce typedef???!!

17/09/2005, 21h36
elekis

ben le const, ca veux simplement dire que tu ne touche pas a ce qu'il ya dans la fonction. en d'autre therme, ce qu'il y a dans la fonction n'est qu'en lectrure et non en ecriture. et donc le what ne fait q'afficher un mesage il ne fait pas de calcul ou autre, (sa sert au compilateur pour accelerer)

comprend pas tres bien ta deuxieme question ,
le

#else
inline void DoNothing(bool) {}
# define Assert(condition) DoNothing(!(condition))

n'arrive que tu est en mode normal (donc pas en mode debug) et qu'en est en mode normal, tu sait que tout ce passe bien donc tu veux que Assert ne fasse rien. .
quand tu fais un assert, c'est que en mode debug, tu n'es pas sur du code et en cas d'erreur tu veux lever une exeption, mais n mode normal, il faut rien faire car tu sais que tout fonctionne (enfin, on est jamais sur)

typedef T* (*PtrFunc)(); je ne suis pas sur de ce qui suit, mais je crois que c'est un foncteur. voial c'est tout e que je peux te dire la dessus. si c'est ca (et j'en suis pas sur)

http://c.developpez.com/tutcpp/x5256.php

mais bon, a etre sur

a+++
17/09/2005, 22h21
filsdugrand

merci pour tes reponses...
donc si g bien compris la premier const signifie que la fonction renvoi un const char* et le second qu'elle est const... ouai ca doit etre ca je suis bete des fois...
pour ce qui est de la macro (NB: meme la partie avec DoNothing est definie meme dans le mode DEBUG) je viens de comprendre
pour ce qui est du foncteur e vais essayer de creuser ca...
17/09/2005, 22h34
filsdugrand

meme apres avoir lu l'article sur les foncteurs je ne suis touours pas plus avance avec cette declaration

Code:

typedef T* (*PtrFunc)();

donc si tu a reussi apercé ce mystere ou si une ame charitable a la solution (pouquoi pas le createur du tutoriel qu'on a touours pas vu dans les parages....) votre aide est la bienvenue!!!
17/09/2005, 22h52
JolyLoic

Ce typedef indique que PtrFunc est un pointeur de fonction ne prenant pas d'argument et retournant un T*.

Pour comprendre les déclarations pointeurs de fonction, ce n'est pas si compliqué. Recharche le nom précédé d'une étoile, et réécrit tout en supprimant le typedef, et en remplaçant ce nom précédé d'un étoile entre parenthèses par f :

T* f();

Et tu obtiens une fonction qui peut être pointée par un pointeur du type crée plus tôt.
17/09/2005, 23h36
filsdugrand

ok merci pour ces explications eclairees
18/09/2005, 07h24
elekis

Citation:

Envoyé par JolyLoic

Ce typedef indique que PtrFunc est un pointeur de fonction ne prenant pas d'argument et retournant un T*.

Pour comprendre les déclarations pointeurs de fonction, ce n'est pas si compliqué. Recharche le nom précédé d'une étoile, et réécrit tout en supprimant le typedef, et en remplaçant ce nom précédé d'un étoile entre parenthèses par f :

T* f();

Et tu obtiens une fonction qui peut être pointée par un pointeur du type crée plus tôt.

exactement ce que je disais pas. :-)

merci

a++
21/09/2005, 03h56
filsdugrand

ola!!!! ca se complique un peu au chapitre 2... parceque la prog directX je connais pas, mais alors pas du tout.. donc je suis allé a la bbliotheque et le seul bouquin que j'ai trouve: "Direct 3D: 3d temps reel sous windows" chez Eyrolles ne m'aide pas beaucoup(c super confus il parlent de trucs qu'ils n'on meme pas expliques...bref c pas fait pour debuter!!) donc je me retourne vers vous pour me conseiller, un tutoriel ou un livre ou une methode pour pouvoire poursuivre le tutoriel
merci d'avance

ps: j'ai trouve un livre sur DX "Directx 9" chez Campuspress et un sur openGL "Open Gl 1.4 Guide Officiel" chez Campuspress pour 45E les deux mais je sais pas si ils m'aiderons pour la suite et ca me ferai c..ier de perdre 45E pour rien...