Historique du message - Irrlicht France

Historique des modifications - Message

Message #8639

Sujet: [PC]Ray-tracer en temps réel

Type Date Auteur Contenu

Type	Date	Auteur	Contenu
Correction acceptée	01-09-2010 18:54:31	Zorian	Texte original: ah ah sa parle architecture j'adort bon perso je ferais le truc en une dizaine de fichier, forcement des que l'on comence a songer a faire un moteur sa deviens un peut volumineux avec pas grand chose pour que sa reste organiser, il faut forcement des dossier bon en restant dans un truc modeste ... ( tu fait comme tu veut pour les nom des fichiés, je fait ça vite fait ) device/device.* device/device_sdl.* // dérivé du device device/device_glut.* // dérivé du device device/device_win.* // dérivé du device device/device_w11.* // dérivé du device node/scene.* // implemente un array<node> node/light. // dériver de node node/node.* // base pour les node dériver, ne contient que les donner superflux ( texture, mesh, ... ) node/real.* // node de rendue de mesh ( standar ) node/skybox.* // dériver de node node/geometry.* // class qui va généré les mesh node/mesh.h // juste une structe avec des float* ( vertices, indices, TCoord et ... et normales ) render/draw.* // rendue graphique des élément ( utiliser par les nodes ) render/raytracer.* // implenter dans draw, au final je pensse que c'est le mieux redner/texture.* // chargement intégré pour pas se casser la tête ( tga c'est pas compliquer a charger ) math/vector2d.h math/vector3d.h math/line2d.h math/line3d.h // utiliser par le raytracer math/matrix4.h // utiliser dans le device pour modifier la matrice de perspective, enfin sauf si tu veut utiliser les fonctions standar, donc optionel je pensse math/array.h // pas indispensable, mais dans la "scene" il te faudras utiliser des std::vector et pas des std::array, trop lent vite fait, je pensse que c'est tout, mais tu veras vite fait que tu voudras rajouter des fonctionnalite ... ps: ne faire que des headler n'est pas la solusion je dirais même que c'est super emmerdent après, a chaque modif sa va recompiler chaque fichier ou ton headler est inclue, directement ou non edit: oublier la spec de real Correction proposée: ah ah ça parle architecture j'adore bon perso je ferais le truc en une dizaine de fichiers, forcément dès que l'on commence à songer à faire un moteur ça devient un peu volumineux avec pas grand chose pour que ça reste organisé, il faut forcément des dossiers bon en restant dans un truc modeste ... ( tu fais comme tu veux pour les noms des fichiers, je fai ça vite fait ) device/device.* device/device_sdl.* // dérivé du device device/device_glut.* // dérivé du device device/device_win.* // dérivé du device device/device_w11.* // dérivé du device node/scene.* // implémente un array<node> node/light. // dérivé de node node/node.* // base pour les nodes dérivés, ne contient que les données superflues ( texture, mesh, ... ) node/real.* // node de rendu de mesh ( standard) node/skybox.* // dérivé de node node/geometry.* // classe qui va générer les meshs node/mesh.h // juste une structure avec des float* ( vertices, indices, TCoord et ... et normales ) render/draw.* // rendu graphique des éléments ( utilisé par les nodes ) render/raytracer.* // implémenté dans draw, au final je pense que c'est le mieux redner/texture.* // chargement intégré pour pas se casser la tête ( tga c'est pas compliqué à charger ) math/vector2d.h math/vector3d.h math/line2d.h math/line3d.h // utilisé par le raytracer math/matrix4.h // utilisé dans le device pour modifier la matrice de perspective, enfin sauf si tu veux utiliser les fonctions standard, donc optionnel je pense math/array.h // pas indispensable, mais dans la "scène" il te faudra utiliser des std::vector et pas des std::array, trop lent vite fait, je pense que c'est tout, mais tu verras vite fait que tu voudras rajouter des fonctionnalités ... ps: ne faire que des headesr n'est pas la solution je dirais même que c'est super emmerdant après, à chaque modif ça va recompiler chaque fichier où ton header est inclus, directement ou non edit: oublié la spec de real
Dernière modification	29-08-2010 13:34:54	Magun	ah ah ça parle architecture j'adore bon perso je ferais le truc en une dizaine de fichiers, forcément dès que l'on commence à songer à faire un moteur ça devient un peu volumineux avec pas grand chose pour que ça reste organisé, il faut forcément des dossiers bon en restant dans un truc modeste ... ( tu fais comme tu veux pour les noms des fichiers, je fai ça vite fait ) device/device.* device/device_sdl.* // dérivé du device device/device_glut.* // dérivé du device device/device_win.* // dérivé du device device/device_w11.* // dérivé du device node/scene.* // implémente un array<node> node/light. // dérivé de node node/node.* // base pour les nodes dérivés, ne contient que les données superflues ( texture, mesh, ... ) node/real.* // node de rendu de mesh ( standard) node/skybox.* // dérivé de node node/geometry.* // classe qui va générer les meshs node/mesh.h // juste une structure avec des float* ( vertices, indices, TCoord et ... et normales ) render/draw.* // rendu graphique des éléments ( utilisé par les nodes ) render/raytracer.* // implémenté dans draw, au final je pense que c'est le mieux redner/texture.* // chargement intégré pour pas se casser la tête ( tga c'est pas compliqué à charger ) math/vector2d.h math/vector3d.h math/line2d.h math/line3d.h // utilisé par le raytracer math/matrix4.h // utilisé dans le device pour modifier la matrice de perspective, enfin sauf si tu veux utiliser les fonctions standard, donc optionnel je pense math/array.h // pas indispensable, mais dans la "scène" il te faudra utiliser des std::vector et pas des std::array, trop lent vite fait, je pense que c'est tout, mais tu verras vite fait que tu voudras rajouter des fonctionnalités ... ps: ne faire que des headesr n'est pas la solution je dirais même que c'est super emmerdant après, à chaque modif ça va recompiler chaque fichier où ton header est inclus, directement ou non edit: oublié la spec de real
Création du message	29-08-2010 13:32:55	Magun	ah ah ça parle architecture j'adore bon perso je ferais le truc en une dizaine de fichiers, forcément dès que l'on commence à songer à faire un moteur ça devient un peu volumineux avec pas grand chose pour que ça reste organisé, il faut forcément des dossiers bon en restant dans un truc modeste ... ( tu fais comme tu veux pour les noms des fichiers, je fai ça vite fait ) device/device.* device/device_sdl.* // dérivé du device device/device_glut.* // dérivé du device device/device_win.* // dérivé du device device/device_w11.* // dérivé du device node/scene.* // implémente un array<node> node/light. // dérivé de node node/node.* // base pour les nodes dérivés, ne contient que les données superflues ( texture, mesh, ... ) node/real.* // node de rendu de mesh ( standard) node/skybox.* // dérivé de node node/geometry.* // classe qui va générer les meshs node/mesh.h // juste une structure avec des float* ( vertices, indices, TCoord et ... et normales ) render/draw.* // rendu graphique des éléments ( utilisé par les nodes ) render/raytracer.* // implémenté dans draw, au final je pense que c'est le mieux redner/texture.* // chargement intégré pour pas se casser la tête ( tga c'est pas compliqué à charger ) math/vector2d.h math/vector3d.h math/line2d.h math/line3d.h // utilisé par le raytracer math/matrix4.h // utilisé dans le device pour modifier la matrice de perspective, enfin sauf si tu veux utiliser les fonctions standard, donc optionnel je pense math/array.h // pas indispensable, mais dans la "scène" il te faudra utiliser des std::vector et pas des std::array, trop lent vite fait, je pense que c'est tout, mais tu verras vite fait que tu voudras rajouter des fonctionnalités ... ps: ne faire que des headesr n'est pas la solution je dirais même que c'est super emmerdant après, à chaque modif ça va recompiler chaque fichier où ton header est inclus, directement ou non edit: oublié la spec de real

Correction acceptée

01-09-2010 18:54:31

Zorian

Texte original:

ah ah sa parle architecture j'adort

bon perso je ferais le truc en une dizaine de fichier, forcement des que l'on comence a songer a faire un moteur sa deviens un peut volumineux avec pas grand chose

pour que sa reste organiser, il faut forcement des dossier

bon en restant dans un truc modeste ... ( tu fait comme tu veut pour les nom des fichiés, je fait ça vite fait )

device/device.*
device/device_sdl.* // dérivé du device
device/device_glut.* // dérivé du device
device/device_win.* // dérivé du device
device/device_w11.* // dérivé du device
node/scene.* // implemente un array<node*>
node/light.* // dériver de node
node/node.* // base pour les node dériver, ne contient que les donner superflux ( texture, mesh, ... )
node/real.* // node de rendue de mesh ( standar )
node/skybox.* // dériver de node
node/geometry.* // class qui va généré les mesh
node/mesh.h // juste une structe avec des float* ( vertices, indices, TCoord et ... et normales )
render/draw.* // rendue graphique des élément ( utiliser par les nodes )
render/raytracer.* // implenter dans draw, au final je pensse que c'est le mieux
redner/texture.* // chargement intégré pour pas  se casser la tête ( tga c'est pas compliquer a charger )
math/vector2d.h
math/vector3d.h
math/line2d.h
math/line3d.h // utiliser par le raytracer
math/matrix4.h // utiliser dans le device pour modifier la matrice de perspective, enfin sauf si tu veut utiliser les fonctions standar, donc optionel je pensse
math/array.h // pas indispensable, mais dans la "scene" il te faudras utiliser des std::vector et pas des std::array, trop lent

vite fait, je pensse que c'est tout, mais tu veras vite fait que tu voudras rajouter des fonctionnalite ...

ps: ne faire que des headler n'est pas la solusion je dirais même que c'est super emmerdent après, a chaque modif sa va recompiler chaque fichier ou ton headler est inclue, directement ou non

edit: oublier la spec de real

Correction proposée:

ah ah ça parle architecture j'adore

bon perso je ferais le truc en une dizaine de fichiers, forcément dès que l'on commence à songer à faire un moteur ça devient un peu volumineux avec pas grand chose

pour que ça reste organisé, il faut forcément des dossiers

bon en restant dans un truc modeste ... ( tu fais comme tu veux pour les noms des fichiers, je fai ça vite fait )

device/device.*
device/device_sdl.* // dérivé du device
device/device_glut.* // dérivé du device
device/device_win.* // dérivé du device
device/device_w11.* // dérivé du device
node/scene.* // implémente un array<node*>
node/light.* // dérivé de node
node/node.* // base pour les nodes dérivés, ne contient que les données superflues ( texture, mesh, ... )
node/real.* // node de rendu de mesh ( standard)
node/skybox.* // dérivé de node
node/geometry.* // classe qui va générer les meshs
node/mesh.h // juste une structure avec des float* ( vertices, indices, TCoord et ... et normales )
render/draw.* // rendu graphique des éléments ( utilisé par les nodes )
render/raytracer.* // implémenté dans draw, au final je pense que c'est le mieux
redner/texture.* // chargement intégré pour pas  se casser la tête ( tga c'est pas compliqué à charger )
math/vector2d.h
math/vector3d.h
math/line2d.h
math/line3d.h // utilisé par le raytracer
math/matrix4.h // utilisé dans le device pour modifier la matrice de perspective, enfin sauf si tu veux utiliser les fonctions standard, donc optionnel je pense
math/array.h // pas indispensable, mais dans la "scène" il te faudra utiliser des std::vector et pas des std::array, trop lent

vite fait, je pense que c'est tout, mais tu verras vite fait que tu voudras rajouter des fonctionnalités ...

ps: ne faire que des headesr n'est pas la solution je dirais même que c'est super emmerdant après, à chaque modif ça va recompiler chaque fichier où ton header est inclus, directement ou non

edit: oublié la spec de real

Dernière modification

29-08-2010 13:34:54

Magun

ah ah ça parle architecture j'adore

bon en restant dans un truc modeste ... ( tu fais comme tu veux pour les noms des fichiers, je fai ça vite fait )

device/device.*
device/device_sdl.* // dérivé du device
device/device_glut.* // dérivé du device
device/device_win.* // dérivé du device
device/device_w11.* // dérivé du device
node/scene.* // implémente un array<node*>
node/light.* // dérivé de node
node/node.* // base pour les nodes dérivés, ne contient que les données superflues ( texture, mesh, ... )
node/real.* // node de rendu de mesh ( standard)
node/skybox.* // dérivé de node
node/geometry.* // classe qui va générer les meshs
node/mesh.h // juste une structure avec des float* ( vertices, indices, TCoord et ... et normales )
render/draw.* // rendu graphique des éléments ( utilisé par les nodes )
render/raytracer.* // implémenté dans draw, au final je pense que c'est le mieux
redner/texture.* // chargement intégré pour pas  se casser la tête ( tga c'est pas compliqué à charger )
math/vector2d.h
math/vector3d.h
math/line2d.h
math/line3d.h // utilisé par le raytracer
math/matrix4.h // utilisé dans le device pour modifier la matrice de perspective, enfin sauf si tu veux utiliser les fonctions standard, donc optionnel je pense
math/array.h // pas indispensable, mais dans la "scène" il te faudra utiliser des std::vector et pas des std::array, trop lent

Création du message

29-08-2010 13:32:55

Magun

ah ah ça parle architecture j'adore

bon en restant dans un truc modeste ... ( tu fais comme tu veux pour les noms des fichiers, je fai ça vite fait )

device/device.*
device/device_sdl.* // dérivé du device
device/device_glut.* // dérivé du device
device/device_win.* // dérivé du device
device/device_w11.* // dérivé du device
node/scene.* // implémente un array<node*>
node/light.* // dérivé de node
node/node.* // base pour les nodes dérivés, ne contient que les données superflues ( texture, mesh, ... )
node/real.* // node de rendu de mesh ( standard)
node/skybox.* // dérivé de node
node/geometry.* // classe qui va générer les meshs
node/mesh.h // juste une structure avec des float* ( vertices, indices, TCoord et ... et normales )
render/draw.* // rendu graphique des éléments ( utilisé par les nodes )
render/raytracer.* // implémenté dans draw, au final je pense que c'est le mieux
redner/texture.* // chargement intégré pour pas  se casser la tête ( tga c'est pas compliqué à charger )
math/vector2d.h
math/vector3d.h
math/line2d.h
math/line3d.h // utilisé par le raytracer
math/matrix4.h // utilisé dans le device pour modifier la matrice de perspective, enfin sauf si tu veux utiliser les fonctions standard, donc optionnel je pense
math/array.h // pas indispensable, mais dans la "scène" il te faudra utiliser des std::vector et pas des std::array, trop lent

Retour