Je voudrais commencer à écrire un moteur 3D, mais pour lequel ou pourrait
choisir entre OpenGL et DirectX. En fait, mon probleme C++ est le suivant :
certaines fonctions seront écrites 2x : une fois pour OpenGL et une fois
pour DirectX. Je voudrais avoir qu'un seul nom de fonction pour ces 2
fonctions.
J'ai pensé à 2 solutions :
1. Avoir 2 dll séparées, contenant les fonctions concernées, et charger
dynamiquement la bonne au démarrage. Est-ce possible (je n'ai encore jamais
programmé de dll) ?
2. Avoir une classe mère CMaClasse avec des fonctions membres virtuelles (ex
: virtual MaFonction()=0 ). Puis créer 2 classe filles : CMaClasse_gl et
CMaClasse_dx. Et faire :
CMaClasse *Objet;
if (OpenGL)
Objet = new CMaClass_gl;
else
Objet = new CMaClass_dx;
Qu'en pensez vous ? Avez d'autres solutions ? Sachant que je recherche la
méthode la plus rapide...
Quel est l'avantage de cela, pourquoi ne pas renvoyer directement une instance de CScene ?
Parce qu'une scène fonctionnant avec DirectX n'est pas nécessairement de la même classe qu'une autre pour OpenGL...
Je crois que je me suis mal exprimé : je voulais dire : pourquoi ne renvoie-t-on pas directement une instance de SceneDX ou de SceneOGL, sans passer par une fabrique ? Ce serait un peu comme une fabrique intégrée dans Moteur....
Hum, j'ai du mal à suivre...
Les scènes sont créées par le moteur, ce qui fait qu'on a juste à changer le moteur pour avoir des types de scènes différents. Tu proposes
Scene * s = new SceneDX;
à la place de
Scene* s = m->fabriqueScene().create();
?
Dans le premier cas, il faut changer la ligne dès que tu changes de moteur. Ou plutôt *les* lignes, vu qu'il y a peu de chances que ce soit le seul endroit où l'appli ait besoin d'en créer une.
Dans le second, tu n'as rien à changer, tous les objets sont automatiquement de types différents rien qu'en changeant le moteur, c'est à dire en modifiant une ligne et une seule...
Chris
Spoofix wrote:
Quel est l'avantage de cela, pourquoi ne pas renvoyer directement
une instance de CScene ?
Parce qu'une scène fonctionnant avec DirectX n'est pas
nécessairement de la même classe qu'une autre pour OpenGL...
Je crois que je me suis mal exprimé : je voulais dire : pourquoi ne
renvoie-t-on pas directement une instance de SceneDX ou de SceneOGL,
sans passer par une fabrique ? Ce serait un peu comme une fabrique
intégrée dans Moteur....
Hum, j'ai du mal à suivre...
Les scènes sont créées par le moteur, ce qui fait qu'on a juste à changer le
moteur pour avoir des types de scènes différents. Tu proposes
Scene * s = new SceneDX;
à la place de
Scene* s = m->fabriqueScene().create();
?
Dans le premier cas, il faut changer la ligne dès que tu changes de moteur.
Ou plutôt *les* lignes, vu qu'il y a peu de chances que ce soit le seul
endroit où l'appli ait besoin d'en créer une.
Dans le second, tu n'as rien à changer, tous les objets sont automatiquement
de types différents rien qu'en changeant le moteur, c'est à dire en
modifiant une ligne et une seule...
Quel est l'avantage de cela, pourquoi ne pas renvoyer directement une instance de CScene ?
Parce qu'une scène fonctionnant avec DirectX n'est pas nécessairement de la même classe qu'une autre pour OpenGL...
Je crois que je me suis mal exprimé : je voulais dire : pourquoi ne renvoie-t-on pas directement une instance de SceneDX ou de SceneOGL, sans passer par une fabrique ? Ce serait un peu comme une fabrique intégrée dans Moteur....
Hum, j'ai du mal à suivre...
Les scènes sont créées par le moteur, ce qui fait qu'on a juste à changer le moteur pour avoir des types de scènes différents. Tu proposes
Scene * s = new SceneDX;
à la place de
Scene* s = m->fabriqueScene().create();
?
Dans le premier cas, il faut changer la ligne dès que tu changes de moteur. Ou plutôt *les* lignes, vu qu'il y a peu de chances que ce soit le seul endroit où l'appli ait besoin d'en créer une.
Dans le second, tu n'as rien à changer, tous les objets sont automatiquement de types différents rien qu'en changeant le moteur, c'est à dire en modifiant une ligne et une seule...
Chris
Spoofix
"Christophe Lephay" a écrit dans le message de news:bo63lo$skt$
Tu proposes
Scene * s = new SceneDX;
à la place de
Scene* s = m->fabriqueScene().create();
?
Non, je propose que la fonction fabriqueScene() de Moteur ne renvoie pas une instance de la classe fabriqueScene, mais directement une instance de SceneDX ou SceneOGL ? Ou alors j'ai mal compris....
Clément
"Christophe Lephay" <christophe-lephay@wanadoo.fr> a écrit dans le message
de news:bo63lo$skt$1@news-reader3.wanadoo.fr...
Tu proposes
Scene * s = new SceneDX;
à la place de
Scene* s = m->fabriqueScene().create();
?
Non, je propose que la fonction fabriqueScene() de Moteur ne renvoie pas une
instance de la classe fabriqueScene, mais directement une instance de
SceneDX ou SceneOGL ? Ou alors j'ai mal compris....
"Christophe Lephay" a écrit dans le message de news:bo63lo$skt$
Tu proposes
Scene * s = new SceneDX;
à la place de
Scene* s = m->fabriqueScene().create();
?
Non, je propose que la fonction fabriqueScene() de Moteur ne renvoie pas une instance de la classe fabriqueScene, mais directement une instance de SceneDX ou SceneOGL ? Ou alors j'ai mal compris....
Clément
Benoit Rousseau
Non, je propose que la fonction fabriqueScene() de Moteur ne renvoie pas une instance de la classe fabriqueScene, mais directement une instance de SceneDX ou SceneOGL ? Ou alors j'ai mal compris....
En général, c'est au début de l'execution que tu sais si tu vas utiliser OGL ou DX. Par contre tu pourrais avoir besoin de plusieurs Scenes basées sur l'un ou l'autre des moteurs. Et dans ce cas, tu n'as qu'à appeler m->fabriqueScene() pour obtenir une nouvelle scene.
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Non, je propose que la fonction fabriqueScene() de Moteur ne renvoie pas une
instance de la classe fabriqueScene, mais directement une instance de
SceneDX ou SceneOGL ? Ou alors j'ai mal compris....
En général, c'est au début de l'execution que tu sais si tu vas utiliser
OGL ou DX. Par contre tu pourrais avoir besoin de plusieurs Scenes
basées sur l'un ou l'autre des moteurs. Et dans ce cas, tu n'as qu'à
appeler m->fabriqueScene() pour obtenir une nouvelle scene.
--
--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/
Non, je propose que la fonction fabriqueScene() de Moteur ne renvoie pas une instance de la classe fabriqueScene, mais directement une instance de SceneDX ou SceneOGL ? Ou alors j'ai mal compris....
En général, c'est au début de l'execution que tu sais si tu vas utiliser OGL ou DX. Par contre tu pourrais avoir besoin de plusieurs Scenes basées sur l'un ou l'autre des moteurs. Et dans ce cas, tu n'as qu'à appeler m->fabriqueScene() pour obtenir une nouvelle scene.
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Christophe Lephay
Spoofix wrote:
"Christophe Lephay" a écrit dans le message de news:bo63lo$skt$
Tu proposes
Scene * s = new SceneDX;
à la place de
Scene* s = m->fabriqueScene().create();
?
Non, je propose que la fonction fabriqueScene() de Moteur ne renvoie pas une instance de la classe fabriqueScene, mais directement une instance de SceneDX ou SceneOGL ? Ou alors j'ai mal compris....
Ah ok :)
Je suis d'accord que celà revient au même du point de vue du code utilisateur.
L'intérêt réside plus dans la classe Moteur. Dans le premier cas, tu choisis ta fabrique lorsque tu initialises le moteur, puis elle te renvoies par la suite les objets du type aproprié. Dans le second, il faut que Moteur détermine le type de scène à renvoyer à chaque fois que tu dois en créer une. Par ailleurs, celà permet de garantir plus facilement que tous tes objets (pas seulement les scènes) seront bien compatibles avec DirectX ou OpenGL (selon l'initialisation du moteur), dans la mesure où tous les processus créateurs sont déterminés quand tu l'initialises (alors que ce doit être testé à chaque création d'objet sinon, ce qui n'est pas insurmontable, mais potentiellement plus dur à contrôler).
Pour finir, le jour où tu décides de supporter une nouvelle API graphique, tu es obligé de parser tous les endroits dans ton moteur où tu créais des objets, ce qui n'est pas le cas si les créations sont déléguées à la fabrique (il suffit de sélectionner les fabriques correspondant à ta nouvelle API à l'initialisation du moteur)...
Chris
Spoofix wrote:
"Christophe Lephay" <christophe-lephay@wanadoo.fr> a écrit dans le
message de news:bo63lo$skt$1@news-reader3.wanadoo.fr...
Tu proposes
Scene * s = new SceneDX;
à la place de
Scene* s = m->fabriqueScene().create();
?
Non, je propose que la fonction fabriqueScene() de Moteur ne renvoie
pas une instance de la classe fabriqueScene, mais directement une
instance de SceneDX ou SceneOGL ? Ou alors j'ai mal compris....
Ah ok :)
Je suis d'accord que celà revient au même du point de vue du code
utilisateur.
L'intérêt réside plus dans la classe Moteur. Dans le premier cas, tu choisis
ta fabrique lorsque tu initialises le moteur, puis elle te renvoies par la
suite les objets du type aproprié. Dans le second, il faut que Moteur
détermine le type de scène à renvoyer à chaque fois que tu dois en créer
une. Par ailleurs, celà permet de garantir plus facilement que tous tes
objets (pas seulement les scènes) seront bien compatibles avec DirectX ou
OpenGL (selon l'initialisation du moteur), dans la mesure où tous les
processus créateurs sont déterminés quand tu l'initialises (alors que ce
doit être testé à chaque création d'objet sinon, ce qui n'est pas
insurmontable, mais potentiellement plus dur à contrôler).
Pour finir, le jour où tu décides de supporter une nouvelle API graphique,
tu es obligé de parser tous les endroits dans ton moteur où tu créais des
objets, ce qui n'est pas le cas si les créations sont déléguées à la
fabrique (il suffit de sélectionner les fabriques correspondant à ta
nouvelle API à l'initialisation du moteur)...
"Christophe Lephay" a écrit dans le message de news:bo63lo$skt$
Tu proposes
Scene * s = new SceneDX;
à la place de
Scene* s = m->fabriqueScene().create();
?
Non, je propose que la fonction fabriqueScene() de Moteur ne renvoie pas une instance de la classe fabriqueScene, mais directement une instance de SceneDX ou SceneOGL ? Ou alors j'ai mal compris....
Ah ok :)
Je suis d'accord que celà revient au même du point de vue du code utilisateur.
L'intérêt réside plus dans la classe Moteur. Dans le premier cas, tu choisis ta fabrique lorsque tu initialises le moteur, puis elle te renvoies par la suite les objets du type aproprié. Dans le second, il faut que Moteur détermine le type de scène à renvoyer à chaque fois que tu dois en créer une. Par ailleurs, celà permet de garantir plus facilement que tous tes objets (pas seulement les scènes) seront bien compatibles avec DirectX ou OpenGL (selon l'initialisation du moteur), dans la mesure où tous les processus créateurs sont déterminés quand tu l'initialises (alors que ce doit être testé à chaque création d'objet sinon, ce qui n'est pas insurmontable, mais potentiellement plus dur à contrôler).
Pour finir, le jour où tu décides de supporter une nouvelle API graphique, tu es obligé de parser tous les endroits dans ton moteur où tu créais des objets, ce qui n'est pas le cas si les créations sont déléguées à la fabrique (il suffit de sélectionner les fabriques correspondant à ta nouvelle API à l'initialisation du moteur)...
Chris
Spoofix
L'intérêt réside plus dans la classe Moteur. Dans le premier cas, tu choisis
ta fabrique lorsque tu initialises le moteur, puis elle te renvoies par la suite les objets du type aproprié. Dans le second, il faut que Moteur détermine le type de scène à renvoyer à chaque fois que tu dois en créer une. Par ailleurs, celà permet de garantir plus facilement que tous tes objets (pas seulement les scènes) seront bien compatibles avec DirectX ou OpenGL (selon l'initialisation du moteur), dans la mesure où tous les processus créateurs sont déterminés quand tu l'initialises (alors que ce doit être testé à chaque création d'objet sinon, ce qui n'est pas insurmontable, mais potentiellement plus dur à contrôler).
Je comprend ce que tu veux dire, mais, dis moi si je me trompe, tu considères qu'il n'existe qu'une classe Moteur, non ? Alors qu'en fait, la classe moteur est dérivée en 2 classes : MoteurDX et MoteurOGL. Donc la fonction fabriqueScene est differente pour ces 2 classes, pas besoin de tester a chaque fois si on est en OpenGL ou DirectX, non ?
Pour finir, le jour où tu décides de supporter une nouvelle API graphique, tu es obligé de parser tous les endroits dans ton moteur où tu créais des objets, ce qui n'est pas le cas si les créations sont déléguées à la fabrique (il suffit de sélectionner les fabriques correspondant à ta nouvelle API à l'initialisation du moteur)...
Sachant que les scenes DX ou OGL seront toutes créée dans ma fonction fabriqueScene, cela fait, comme dans le cas d'une fabrique, un seul endroit a changer....
En fait, je ne vois aucune difference entre le 2 methodes, mise a part que la 1ere est un peu plus complexe. Dans la seconde, c'est un peu comme si chaque fabrique de Scene etait intégrée dans MoteurDX et MoteurOGL.
En tout cas, merci beaucoup pour tes réponses claires, détaillées... et rapides ! Clément.
L'intérêt réside plus dans la classe Moteur. Dans le premier cas, tu
choisis
ta fabrique lorsque tu initialises le moteur, puis elle te renvoies par la
suite les objets du type aproprié. Dans le second, il faut que Moteur
détermine le type de scène à renvoyer à chaque fois que tu dois en créer
une. Par ailleurs, celà permet de garantir plus facilement que tous tes
objets (pas seulement les scènes) seront bien compatibles avec DirectX ou
OpenGL (selon l'initialisation du moteur), dans la mesure où tous les
processus créateurs sont déterminés quand tu l'initialises (alors que ce
doit être testé à chaque création d'objet sinon, ce qui n'est pas
insurmontable, mais potentiellement plus dur à contrôler).
Je comprend ce que tu veux dire, mais, dis moi si je me trompe, tu
considères qu'il n'existe qu'une classe Moteur, non ? Alors qu'en fait, la
classe moteur est dérivée en 2 classes : MoteurDX et MoteurOGL. Donc la
fonction fabriqueScene est differente pour ces 2 classes, pas besoin de
tester a chaque fois si on est en OpenGL ou DirectX, non ?
Pour finir, le jour où tu décides de supporter une nouvelle API graphique,
tu es obligé de parser tous les endroits dans ton moteur où tu créais des
objets, ce qui n'est pas le cas si les créations sont déléguées à la
fabrique (il suffit de sélectionner les fabriques correspondant à ta
nouvelle API à l'initialisation du moteur)...
Sachant que les scenes DX ou OGL seront toutes créée dans ma fonction
fabriqueScene, cela fait, comme dans le cas d'une fabrique, un seul endroit
a changer....
En fait, je ne vois aucune difference entre le 2 methodes, mise a part que
la 1ere est un peu plus complexe. Dans la seconde, c'est un peu comme si
chaque fabrique de Scene etait intégrée dans MoteurDX et MoteurOGL.
En tout cas, merci beaucoup pour tes réponses claires, détaillées... et
rapides !
Clément.
L'intérêt réside plus dans la classe Moteur. Dans le premier cas, tu choisis
ta fabrique lorsque tu initialises le moteur, puis elle te renvoies par la suite les objets du type aproprié. Dans le second, il faut que Moteur détermine le type de scène à renvoyer à chaque fois que tu dois en créer une. Par ailleurs, celà permet de garantir plus facilement que tous tes objets (pas seulement les scènes) seront bien compatibles avec DirectX ou OpenGL (selon l'initialisation du moteur), dans la mesure où tous les processus créateurs sont déterminés quand tu l'initialises (alors que ce doit être testé à chaque création d'objet sinon, ce qui n'est pas insurmontable, mais potentiellement plus dur à contrôler).
Je comprend ce que tu veux dire, mais, dis moi si je me trompe, tu considères qu'il n'existe qu'une classe Moteur, non ? Alors qu'en fait, la classe moteur est dérivée en 2 classes : MoteurDX et MoteurOGL. Donc la fonction fabriqueScene est differente pour ces 2 classes, pas besoin de tester a chaque fois si on est en OpenGL ou DirectX, non ?
Pour finir, le jour où tu décides de supporter une nouvelle API graphique, tu es obligé de parser tous les endroits dans ton moteur où tu créais des objets, ce qui n'est pas le cas si les créations sont déléguées à la fabrique (il suffit de sélectionner les fabriques correspondant à ta nouvelle API à l'initialisation du moteur)...
Sachant que les scenes DX ou OGL seront toutes créée dans ma fonction fabriqueScene, cela fait, comme dans le cas d'une fabrique, un seul endroit a changer....
En fait, je ne vois aucune difference entre le 2 methodes, mise a part que la 1ere est un peu plus complexe. Dans la seconde, c'est un peu comme si chaque fabrique de Scene etait intégrée dans MoteurDX et MoteurOGL.
En tout cas, merci beaucoup pour tes réponses claires, détaillées... et rapides ! Clément.
Spoofix
"Benoit Rousseau" a écrit dans le message de news:3fa698ec$0$1862$
En général, c'est au début de l'execution que tu sais si tu vas utiliser OGL ou DX. Par contre tu pourrais avoir besoin de plusieurs Scenes basées sur l'un ou l'autre des moteurs.
Je ne vois pas trop pourquoi je voudrais une Scene OpenGL en DirectX....
Et dans ce cas, tu n'as qu'à appeler m->fabriqueScene() pour obtenir une nouvelle scene.
C'est justement ce que je propose, non ?
Merci, Clément.
"Benoit Rousseau" <not.provided@no.spam> a écrit dans le message de
news:3fa698ec$0$1862$ba620e4c@reader0.news.skynet.be...
En général, c'est au début de l'execution que tu sais si tu vas utiliser
OGL ou DX. Par contre tu pourrais avoir besoin de plusieurs Scenes
basées sur l'un ou l'autre des moteurs.
Je ne vois pas trop pourquoi je voudrais une Scene OpenGL en DirectX....
Et dans ce cas, tu n'as qu'à
appeler m->fabriqueScene() pour obtenir une nouvelle scene.
"Benoit Rousseau" a écrit dans le message de news:3fa698ec$0$1862$
En général, c'est au début de l'execution que tu sais si tu vas utiliser OGL ou DX. Par contre tu pourrais avoir besoin de plusieurs Scenes basées sur l'un ou l'autre des moteurs.
Je ne vois pas trop pourquoi je voudrais une Scene OpenGL en DirectX....
Et dans ce cas, tu n'as qu'à appeler m->fabriqueScene() pour obtenir une nouvelle scene.
C'est justement ce que je propose, non ?
Merci, Clément.
Christophe Lephay
Spoofix wrote:
L'intérêt réside plus dans la classe Moteur. Dans le premier cas, tu choisis ta fabrique lorsque tu initialises le moteur, puis elle te renvoies par la suite les objets du type aproprié. Dans le second, il faut que Moteur détermine le type de scène à renvoyer à chaque fois que tu dois en créer une. Par ailleurs, celà permet de garantir plus facilement que tous tes objets (pas seulement les scènes) seront bien compatibles avec DirectX ou OpenGL (selon l'initialisation du moteur), dans la mesure où tous les processus créateurs sont déterminés quand tu l'initialises (alors que ce doit être testé à chaque création d'objet sinon, ce qui n'est pas insurmontable, mais potentiellement plus dur à contrôler).
Je comprend ce que tu veux dire, mais, dis moi si je me trompe, tu considères qu'il n'existe qu'une classe Moteur, non ? Alors qu'en fait, la classe moteur est dérivée en 2 classes : MoteurDX et MoteurOGL. Donc la fonction fabriqueScene est differente pour ces 2 classes, pas besoin de tester a chaque fois si on est en OpenGL ou DirectX, non ?
Peut-être, là on est un peu trop dans l'abstrait pour juger...
Une fabrique pourrait, pourquoi pas, créer des scènes différentes selon la résolution ou le nombre de couleur choisie, selon la vitesse du processeur ou que sais-je encore...
Après, c'est au cas par cas qu'il faut voir...
Chris
Spoofix wrote:
L'intérêt réside plus dans la classe Moteur. Dans le premier cas, tu
choisis ta fabrique lorsque tu initialises le moteur, puis elle te
renvoies par la suite les objets du type aproprié. Dans le second,
il faut que Moteur détermine le type de scène à renvoyer à chaque
fois que tu dois en créer une. Par ailleurs, celà permet de garantir
plus facilement que tous tes objets (pas seulement les scènes)
seront bien compatibles avec DirectX ou OpenGL (selon
l'initialisation du moteur), dans la mesure où tous les processus
créateurs sont déterminés quand tu l'initialises (alors que ce doit
être testé à chaque création d'objet sinon, ce qui n'est pas
insurmontable, mais potentiellement plus dur à contrôler).
Je comprend ce que tu veux dire, mais, dis moi si je me trompe, tu
considères qu'il n'existe qu'une classe Moteur, non ? Alors qu'en
fait, la classe moteur est dérivée en 2 classes : MoteurDX et
MoteurOGL. Donc la fonction fabriqueScene est differente pour ces 2
classes, pas besoin de tester a chaque fois si on est en OpenGL ou
DirectX, non ?
Peut-être, là on est un peu trop dans l'abstrait pour juger...
Une fabrique pourrait, pourquoi pas, créer des scènes différentes selon la
résolution ou le nombre de couleur choisie, selon la vitesse du processeur
ou que sais-je encore...
L'intérêt réside plus dans la classe Moteur. Dans le premier cas, tu choisis ta fabrique lorsque tu initialises le moteur, puis elle te renvoies par la suite les objets du type aproprié. Dans le second, il faut que Moteur détermine le type de scène à renvoyer à chaque fois que tu dois en créer une. Par ailleurs, celà permet de garantir plus facilement que tous tes objets (pas seulement les scènes) seront bien compatibles avec DirectX ou OpenGL (selon l'initialisation du moteur), dans la mesure où tous les processus créateurs sont déterminés quand tu l'initialises (alors que ce doit être testé à chaque création d'objet sinon, ce qui n'est pas insurmontable, mais potentiellement plus dur à contrôler).
Je comprend ce que tu veux dire, mais, dis moi si je me trompe, tu considères qu'il n'existe qu'une classe Moteur, non ? Alors qu'en fait, la classe moteur est dérivée en 2 classes : MoteurDX et MoteurOGL. Donc la fonction fabriqueScene est differente pour ces 2 classes, pas besoin de tester a chaque fois si on est en OpenGL ou DirectX, non ?
Peut-être, là on est un peu trop dans l'abstrait pour juger...
Une fabrique pourrait, pourquoi pas, créer des scènes différentes selon la résolution ou le nombre de couleur choisie, selon la vitesse du processeur ou que sais-je encore...
Après, c'est au cas par cas qu'il faut voir...
Chris
Benoit Rousseau
Spoofix wrote:
"Benoit Rousseau" a écrit dans le message de news:3fa698ec$0$1862$
Et dans ce cas, tu n'as qu'à appeler m->fabriqueScene() pour obtenir une nouvelle scene.
C'est justement ce que je propose, non ?
En effet ; toutes mes excuses, j'avais mal compris ton mail. Je prefère aussi que le moteur retourne directement la scene plutôt que de passer par une seconde classe FabriqueScene, et c'est un post précédent qui m'avait embrouillé l'esprit.
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Spoofix wrote:
"Benoit Rousseau" <not.provided@no.spam> a écrit dans le message de
news:3fa698ec$0$1862$ba620e4c@reader0.news.skynet.be...
Et dans ce cas, tu n'as qu'à
appeler m->fabriqueScene() pour obtenir une nouvelle scene.
C'est justement ce que je propose, non ?
En effet ; toutes mes excuses, j'avais mal compris ton mail.
Je prefère aussi que le moteur retourne directement la scene plutôt que
de passer par une seconde classe FabriqueScene, et c'est un post
précédent qui m'avait embrouillé l'esprit.
--
--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/
"Benoit Rousseau" a écrit dans le message de news:3fa698ec$0$1862$
Et dans ce cas, tu n'as qu'à appeler m->fabriqueScene() pour obtenir une nouvelle scene.
C'est justement ce que je propose, non ?
En effet ; toutes mes excuses, j'avais mal compris ton mail. Je prefère aussi que le moteur retourne directement la scene plutôt que de passer par une seconde classe FabriqueScene, et c'est un post précédent qui m'avait embrouillé l'esprit.
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Spoofix
En effet ; toutes mes excuses, j'avais mal compris ton mail. Je prefère aussi que le moteur retourne directement la scene plutôt que de passer par une seconde classe FabriqueScene, et c'est un post précédent qui m'avait embrouillé l'esprit.
OK, donc on est d'accord, pas besoin de classe FabriqueScene ?
En tout cas, merci beaucoup pour vos conseils a tous, j'ai bien progressé !
En effet ; toutes mes excuses, j'avais mal compris ton mail.
Je prefère aussi que le moteur retourne directement la scene plutôt que
de passer par une seconde classe FabriqueScene, et c'est un post
précédent qui m'avait embrouillé l'esprit.
OK, donc on est d'accord, pas besoin de classe FabriqueScene ?
En tout cas, merci beaucoup pour vos conseils a tous, j'ai bien progressé !
En effet ; toutes mes excuses, j'avais mal compris ton mail. Je prefère aussi que le moteur retourne directement la scene plutôt que de passer par une seconde classe FabriqueScene, et c'est un post précédent qui m'avait embrouillé l'esprit.
OK, donc on est d'accord, pas besoin de classe FabriqueScene ?
En tout cas, merci beaucoup pour vos conseils a tous, j'ai bien progressé !
Spoofix
Peut-être, là on est un peu trop dans l'abstrait pour juger...
Une fabrique pourrait, pourquoi pas, créer des scènes différentes selon la résolution ou le nombre de couleur choisie, selon la vitesse du processeur ou que sais-je encore...
Après, c'est au cas par cas qu'il faut voir...
Oui, je vois, mais je crois que je vais integrer la fabrique a la classe moteur (cf. discussion avec Benoit)
En tout cas, merci a tous. Clément.
Peut-être, là on est un peu trop dans l'abstrait pour juger...
Une fabrique pourrait, pourquoi pas, créer des scènes différentes selon la
résolution ou le nombre de couleur choisie, selon la vitesse du processeur
ou que sais-je encore...
Après, c'est au cas par cas qu'il faut voir...
Oui, je vois, mais je crois que je vais integrer la fabrique a la classe
moteur (cf. discussion avec Benoit)
Peut-être, là on est un peu trop dans l'abstrait pour juger...
Une fabrique pourrait, pourquoi pas, créer des scènes différentes selon la résolution ou le nombre de couleur choisie, selon la vitesse du processeur ou que sais-je encore...
Après, c'est au cas par cas qu'il faut voir...
Oui, je vois, mais je crois que je vais integrer la fabrique a la classe moteur (cf. discussion avec Benoit)
