Partage
  • Partager sur Facebook
  • Partager sur Twitter

[OpenGL] 3D isométrique

Sujet résolu
    3 août 2006 à 16:29:01

    Bien le bonjour cher amis.

    J'ai récemment décidé de m'essayer à la 3D en programmation avec OpenGL. J'ai donc suivi le très bon cours de Kayl (au passage, j'espers que ça va s'arranger...), et j'ai presque acquis ce qu'il prsente dans le début de son cours.

    Mon but est de créer une scène en 3D isométrique. J'ai essayé, mais j'ai quelques soucis... (normal hein, sinon je ne serai pas ici).

    Bon, tout d'abord, il faut se demander ce qu'est la 3D isométrique. C'est un peu abstrait, j'ai lu pas mal de choses sur le web, mais à vrai dire, même sur Wikipédia, les experts se contredisent à propos de cette notion. J'ai donc un peu du mal à tout cerner.

    Tout d'abord, un jeu en 3D iso (j'abrégerai le terme isométrique par iso à partir de maintenant) par exemple SimCity...

    Image utilisateur

    On voit tout de suite qu'il s'agit d'une vue en perspective iso. Mais un niveau de la conception 3D, c'est encore un peu flou pour moi.

    Certains caractérisent une telle perspective par une même échelle sur les 3axes. D'autres par une inclinaison de 45° par rapport à la verticale. Bref, j'ai essayé de reproduire une telle vue en 3D à l'aide de OpenGL, et en C++.

    Cependant, je peine un peu, faut il déplacer la scène pour qu'elle s'adapte aux restriction de la perspective iso, faut il placer la caméra d'une certaine manière ?

    Tout d'abord, j'ai choisi le passage à la 3D par l'ajout d'un axe vertical, j'ai donc des axes orientés comme suit :
    Image utilisateur

    Le dessin de la scène ne pose pas trop de problèmes, j'ai juste fais un cube sur un sol (sans textures), très basique quoi.

    Apres vient le possitionnement de la caméra. Pour avoir une bonne vue en perspective, j'ai pensé que les coordonées x et y de la caméra devraient êtres les même. J'ai aussi placé la caméra à la même distance sur l'axe z, ne sachant pas très bien comment procéder.

    De plus, si on y réflechis, ce positionnement donne un angle de 45° avec la verticale non ?
    Image utilisateur

    Bref, cependant, la vue n'est pas satisfaisante... On voit très bien sur la scène que j'ai créé que l'on apperçoi le plan qui s'éloigne au fond, et c'est confirmé si on recule un peu...

    Image utilisateurImage utilisateur
    (cliquez pour agrandir)

    Bref, auriez vous des conseils pour m'aider à avoir une vrai perspective isométrique car là je sèche un peu...

    Voici mes sources :

    Note:
    Dans mon programme, les flèches servent à déplacer le cube selon les axes vertical/horizontal (de l'écran, pas de la scène 3D), etles touches 8 et 2 du pavé numérique pour zoomer/dézoomer.
    Pour revenir aux paramètres d'origine, appuyez sur la touche "Home".

    Code source, executable windows, projet Code::Blocks...


    (en 3 formats pour satisfaire tout le monde)

    3diso.zip
    3diso.tar
    3diso.7z (format de 7-Zip)

    Ma source


    #include <iostream>

    /* SDL Include */
    #include <SDL/SDL.h>

    /* OpenGL Include */
    #include <GL/gl.h>
    #include <GL/glu.h>

    /* Defines */
    #define LARGEUR_ECRAN 640
    #define HAUTEUR_ECRAN 480

    #define VITESSE 0.1
    #define DIST_BASE 10
    #define ORTHO 10

    void dessiner(double distance, double scrollX, double scrollY, int typeSol, int showCube, int showRepaire);
    void drawCube(double echelle = 1);
    void drawRepere(double echelle = 1, int lineWidth = 1);
    void drawGrid(int tailleSol = 100, int lineWidth = 1);
    void drawGround(int tailleSol = 100);

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

        /* Ecran principal */
        SDL_Surface *ecran;

        /* Chargement de la SDL */
        if (SDL_Init(SDL_INIT_VIDEO) == -1)
        {

            fprintf(stderr, "Erreur de chargement de la SDL: %s.\n", SDL_GetError());
            exit(EXIT_FAILURE);

        }

        if ((ecran = SDL_SetVideoMode (LARGEUR_ECRAN, HAUTEUR_ECRAN, 32, SDL_OPENGL)) == NULL)
        {

            fprintf(stderr, "Erreur de chargement du mode vidéo: %s.\n", SDL_GetError());
            exit(EXIT_FAILURE);

        }

        /* Titre de la fenêtre */
        SDL_WM_SetCaption("Programme SDL/OpenGL - 3D iso", NULL);

        /* KeyRepeat */
        SDL_EnableKeyRepeat(10, 10);

        /* Paramètres OpenGL */
        glMatrixMode( GL_PROJECTION );
        glLoadIdentity();
        //gluPerspective(70,(double)LARGEUR_ECRAN/HAUTEUR_ECRAN,1,1000);
        //glOrtho(LARGEUR_ECRAN,LARGEUR_ECRAN,HAUTEUR_ECRAN,HAUTEUR_ECRAN,1,1000);
        glOrtho(-ORTHO,ORTHO,-ORTHO,ORTHO,1,1000);

        /* glEnable */
        glEnable( GL_DEPTH_TEST );

        /* Variables programme */
        bool continuer = true;

        /* Event */
        SDL_Event event;

        /* Variables camera */
        double distance = DIST_BASE, scrollX = 0, scrollY = 0, scale = 1;
        bool showCube = true, showRepere = false, showGround = true, showGrid = false;
        int tailleSol = 10;

        while (continuer)
        {

            while (SDL_PollEvent (&event)) //tant qu'il y a des évenements
            {
                switch (event.type)
                {

                    case SDL_QUIT:
                        continuer = false;
                    break;
                    case SDL_KEYDOWN:
                        switch (event.key.keysym.sym)
                        {

                            case SDLK_ESCAPE:
                                continuer = false;
                            break;
                            case SDLK_LEFT:
                                scrollX += VITESSE;
                            break;
                            case SDLK_RIGHT:
                                scrollX -= VITESSE;
                            break;
                            case SDLK_UP:
                                scrollY -= VITESSE;
                            break;
                            case SDLK_DOWN:
                                scrollY += VITESSE;
                            break;
                            case SDLK_KP8:
                                distance -= VITESSE;
                            break;
                            case SDLK_KP2:
                                distance += VITESSE;
                            break;
                            case SDLK_INSERT:
                                tailleSol += 1;
                            break;
                            case SDLK_DELETE:
                                tailleSol -= 1;
                                if (tailleSol < 0)
                                    tailleSol = 0;
                            break;
                            case SDLK_PAGEUP:
                                scale += VITESSE;
                            break;
                            case SDLK_PAGEDOWN:
                                scale -= VITESSE;
                                if (scale < 0)
                                    scale = 0;
                            break;
                            case SDLK_HOME:
                                scrollX = scrollY = 0;
                                distance = DIST_BASE;
                                showCube = true;
                                showRepere = false;
                                showGround = true;
                                showGrid = false;
                                tailleSol = 10;
                                scale = 1;
                            break;

                        }
                    break;
                    case SDL_KEYUP:
                        switch (event.key.keysym.sym)
                        {

                            case SDLK_s:
                                showGround = (showGround) ? false : true;
                            break;
                            case SDLK_c:
                                showCube = (showCube) ? false : true;
                            break;
                            case SDLK_r:
                                showRepere = (showRepere) ? false : true;
                            break;
                            case SDLK_g:
                                showGrid = (showGrid) ? false : true;

                        }
                    break;

                }

            }

            glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

            glMatrixMode( GL_MODELVIEW );
            glLoadIdentity();

            gluLookAt(distance, distance, distance, 0, 0, 0, 0, 0, 1);

            /* Translation pour placer la scene */
            glPushMatrix(); //sauvegarde de la matrice actuelle
            glTranslated(scrollX, -scrollX, 0);
            glTranslated(scrollY, scrollY, 0);

            if (showGround)
                drawGround(tailleSol);

            if (showGrid)
                drawGrid(tailleSol);

            if (showRepere)
                drawRepere(scale, 2);

            if (showCube)
                drawCube(scale);

            glFlush();
            SDL_GL_SwapBuffers();

            glPopMatrix(); //restitution de la matrice

            /* fprintf */
            //fprintf(stdout, "Distance: %f\n", distance);

        }

        /* Arrêt de la SDL */
        SDL_Quit();

        return EXIT_SUCCESS;

    }

    void drawGrid(int tailleSol, int lineWidth)
    {

        glLineWidth( lineWidth );

        glBegin( GL_LINES );

            glColor3ub(0, 255, 0);

            int i;

            for (i = -tailleSol; i <= tailleSol; i++)
            {

                glVertex3d(-tailleSol, i, 0);
                glVertex3d(tailleSol, i, 0);

                glVertex3d(i, -tailleSol, 0);
                glVertex3d(i, tailleSol, 0);

            }


        glEnd();

    }

    void drawCube(double echelle)
    {

        glBegin( GL_QUADS );

            /* Face devant */
            glColor3ub(255, 0, 0);
            glVertex3d(echelle, echelle, echelle);
            glVertex3d(echelle, echelle, 0);
            glVertex3d(0, echelle, 0);
            glVertex3d(0, echelle, echelle);

            /* Face gauche */
            glColor3ub(0, 255, 0);
            glVertex3d(echelle, echelle, echelle);
            glVertex3d(echelle, 0, echelle);
            glVertex3d(echelle, 0, 0);
            glVertex3d(echelle, echelle, 0);

            /* Face haut */
            glColor3ub(0, 0, 255);
            glVertex3d(echelle, echelle, echelle);
            glVertex3d(0, echelle, echelle);
            glVertex3d(0, 0, echelle);
            glVertex3d(echelle, 0, echelle);

            /* Face arrière */
            glColor3ub(255, 255, 0);
            glVertex3d(echelle, 0, echelle);
            glVertex3d(echelle, 0, 0);
            glVertex3d(0, 0, 0);
            glVertex3d(0, 0, echelle);

            /* Face droite */
            glColor3ub(0, 255, 255);
            glVertex3d(0, echelle, echelle);
            glVertex3d(0, 0, echelle);
            glVertex3d(0, 0, 0);
            glVertex3d(0, echelle, 0);

            /* Face bas */
            glColor3ub(255, 0, 255);
            glVertex3d(echelle, echelle, 0);
            glVertex3d(0, echelle, 0);
            glVertex3d(0, 0, 0);
            glVertex3d(echelle, 0, 0);

        glEnd();

    }

    void drawRepere(double echelle, int lineWidth)
    {

        glLineWidth( lineWidth );

        glBegin( GL_LINES );

            glColor3ub(0, 0, 255); // X
            glVertex3d(0, 0, 0);
            glVertex3d(echelle, 0, 0);

            glColor3ub(0, 255, 0); // Y
            glVertex3d(0, 0, 0);
            glVertex3d(0, echelle, 0);

            glColor3ub(255, 0, 0); // Z
            glVertex3d(0, 0, 0);
            glVertex3d(0, 0, echelle);

        glEnd();

    }

    void drawGround(int tailleSol)
    {

        glBegin( GL_QUADS );

            glColor3ub(255, 255, 0);
                glVertex3d(tailleSol, tailleSol, 0);
            glColor3ub(255, 0, 255);
                glVertex3d(-tailleSol, tailleSol, 0);
            glColor3ub(0, 255, 255);
                glVertex3d(-tailleSol, -tailleSol, 0);
            glColor3ub(255, 255, 255);
                glVertex3d(tailleSol, -tailleSol, 0);

        glEnd();

    }

    /* Toujours un daut de ligne */


    Thanks ! Merci de m'avoir lu !
    • Partager sur Facebook
    • Partager sur Twitter
      3 août 2006 à 16:55:41

      Je me trompe peu etre mais je crois que la 3D isométrique ce n'est justement pas de la 3D mais de la 2D représentant quelque chose en relief (style T4C ou Diablo ?)
      Pour faire de la 3D isométrique SDL doit suffir.

      J'ai peu etre mal compris la question si c'est le cas j'espere que tu m'excusera.

      EDIT : Apres relecture il me semble bien que je n'avais pas compris la question, je vais m'empresser de reflechir à ton problème.
      • Partager sur Facebook
      • Partager sur Twitter
        3 août 2006 à 17:03:53

        Ben en fait, on peut créer une scène de 3D iso effectivement à l'aide de la 2D simplement (en prenant des sprites adaptés penchés à 45°), mais le résultat reste assez limité.

        Perso, même si T4C et DiabloII suivent les grands principes de la 3D iso, je pense pas qu'ils soient réalisés en 2D.

        Bref, c'est ça que je veux reproduire. Mais j'ai du mal pour les réglages de la scène et la visualisation.

        Mais une fois que je serai bien maitriser les différentes vues, j'aurai ma scène 3D, vue en perspective isométrique.

        J'aurai donc les possibilitées du 3D dans la poche. Je pourrai par exemple effectuer une rotation à l'aide d'une touche pour récupérer des objets derrière les murs (exemple dans Warcraft III, si on appuit sur 'Home' ou 'Fin', ça effectue une rotation).

        Bref, ensuite il y a le Z-Buffer qui est très bien géré par OpenGL, et qu'on doit reproduire manuellement avec SDL. Encore un avantage.

        Après, il sera aussi possible d'importer des models 3D (blender, 3DMax...), et d'avoir de meilleurs graphismes.

        Bien entendu, je n'en suis pas encore là (et j'en suis loin), mais j'essaye pour le moment de maîtriser les rudiments de la 3D iso, qui est finallement plus délicat que je ne le pensais !

        Merci à toi en tout cas !
        • Partager sur Facebook
        • Partager sur Twitter
          3 août 2006 à 17:06:56

          T4C n'est pas fait en 3D que de la 2D. En ce qui concerne ton probleme je ne vois pas trop comment le résoudre. En fait il se trouve que dans la 3D iso peu importe la distance les dimensions sont conservées et ce n'est pas le cas lorsque tu fais de la 3D avec openGL. En effet, si un objet s'éoigne il sera plus petit et c'est ca qui crée cette déformation que tu voudrais éviter.

          A moins qu'il n'existe une fonction openGL permettant de passer à la perspective isométrique j'ai peur que tu ne puisse pas résoudre ce problème simplement.

          Citation : Pas de titre


          Dans un moteur 3d de perspective, les objets de la scène sont projetés sur un plan suivant une droite. Cette troite passe par deux points : un point situé sur l'objet et le point où se situe l'observateur. La droite varie d'un point à l'autre de la scène, elle n'a jamais la même direction, c'est pourquoi les calculs sont plus difficiles.
          Pour les moteurs 3d isométrique, cette droite a toujours la même direction : elle est perpendiculaire au plan de l'observateur. La projection est orthogonale, ce qui est simplissime à faire. L'observateur n'est pas défini par une position et une direction, mais seulement par une direction (celle de la droite qui sert à projeter la scène).



          Citation : Pas de titre


          En 3D isométrique, plus un objet est éloigné des axes de référence, plus il est décalé par rapport à ces axes. C'est ce décalage qui produit l'effet de profondeur.
          Le carré est situé dans le plan (xy), z=0. Le carré 2 est situé derrière, dans le plan parallèle à (xy) mais tel que z=3. Le carré 1 est identique (même dimensions, mêmes angles etc.) au carré 2, mais il est décalé (translaté) par rapport à celui-ci.

          • Partager sur Facebook
          • Partager sur Twitter
            3 août 2006 à 18:55:20

            Je confirme ce qu'a dit lexou, Simcity, Diablo, T4C sont faits en 2D. Même ma megadrive gérait la 3D iso, normal vu que c'est de la 2D ;)

            Quand c'est de la 3D ça se voit sans problème. Regarde les sims, c'est de la 3D bien que ça soit un angle de vue généralement fixe. Tu peux d'ailleurs zoomer, faire une rotation etc.
            • Partager sur Facebook
            • Partager sur Twitter

            If you'd like to join us, read "How do we work at OpenClassrooms"! :)

              3 août 2006 à 19:20:56

              arrêtez-moi si je dit une bêtise:

              ya pa la vue orthonomée, avec glOrtho?
              en orthonomé, les proportions sont conservé, nan?

              glOrtho(lien vers la doc OpenGL)
              • Partager sur Facebook
              • Partager sur Twitter
                3 août 2006 à 21:06:23

                Il faut que je test ca mais je crois bien que tu as trouvé l'option qui permet de faire une projection parrallele.
                • Partager sur Facebook
                • Partager sur Twitter
                  4 août 2006 à 0:29:31

                  Citation : M@teo21

                  Je confirme ce qu'a dit lexou, Simcity, Diablo, T4C sont faits en 2D. Même ma megadrive gérait la 3D iso, normal vu que c'est de la 2D ;)

                  Quand c'est de la 3D ça se voit sans problème. Regarde les sims, c'est de la 3D bien que ça soit un angle de vue généralement fixe. Tu peux d'ailleurs zoomer, faire une rotation etc.


                  Ouah ! Sérieusement je suis bluffé en ce qui concerne Diablo, et surtout T4C !!! Je pensais sérieusement que c'était de la 3D, surtout avec les sorts et tout... Je pensais pas qu'on pouvai faire des choses si bien en 2D.

                  Bon, ça change complètement les choses...

                  A propos de ce que dis le grand schtroumpf, je me rapelle du mode de projection utilisé dans l'exercice de la Grue du cours de Kayl :

                  glMatrixMode( GL_PROJECTION );
                  glLoadIdentity( );
                  gluOrtho2D(0,LARGEUR_ECRAN,0,HAUTEUR_ECRAN);


                  On utilise la matrice projection, on l'initialise et on paramètre le mode 2D, mais j'ai bien di 2D, car en procédant comme ça on se retrouve avec un repère (0, ->i, ->j) à deux dimensions comme on pourait très bien avoir en SDL.

                  Donc voilà ou j'en suis à présent, vraiment ... désorienté. Bref, est il possible d'adopter un point de vue en perspective isométrique d'une scène 3D réalisée dans un espace en 3 dimensions bien entendu ?

                  Est ce qu'il est possible de se déplacer facilement* dans ce monde en respectant les règles de la 3D iso ?

                  * J'entend par facilement le fait de ne pas devoir se tordre pour empêcher le fait que les objets rétrécissent avec l'éloignement, en étant obligé d'augmenter l'altitude ou autre supterfuge bizaroïde...

                  J'ai le préssentiment que la réponse à cette question va être non, mais je veux en avoir la certitude ^^

                  Bref. De toute manière, mon objectif est la 3D iso.

                  Pensez vous que je puisse réussir avec OpenGL (en 3D), ce qui me permettrai de faire des truc plus joli, plus rapides aussi certainement, mais peut être plus difficile à mettre en oeuvre ?

                  Ou alors est-ce tout simplement impossible en 3D OpenGL, auquel cas il serait judicieux de rester en SDL, ce qui me permettrai de faire quelque chose de quand même potable et joli, en y mettant assez de soin bien entendu ?

                  Pourtant, mon schéma du cube** me paraîssait pas mal, c'est ... comment dire ... troublant :-°

                  ** Image utilisateur

                  Merci encore de m'avoir lu, et de vous intéresser à mon problème !
                  • Partager sur Facebook
                  • Partager sur Twitter
                    4 août 2006 à 2:01:10

                    Franchement ? j'en sais rien...
                    Faudrais voir avec un expert de l'openGL.. mais bon tout est possible a mon avis. Suffi trouver l'information puis la mettre en oeuvre.
                    • Partager sur Facebook
                    • Partager sur Twitter
                      4 août 2006 à 11:36:59

                      Il faudrait créer un système pour qu'au fur et à mesure qu'on déplace la scène vers le bas par exemple (pour aller vers le haut), la distance entre la caméra et les axes soit réduite de façon à ce que le changement de taille du à l'éloignement ne soit plus ressenti...

                      Une vue un peu comme dans Warcraft III quoi, mais j'ai essayé pas mal de truc, je n'arrive à rien, et comme je ne sais pas encore bien me servir de l'OpenGL...
                      Il faudrait quelqu'un qui a en effet déjà été cofronté à cette interrogation !
                      • Partager sur Facebook
                      • Partager sur Twitter
                        4 août 2006 à 19:33:55

                        le grand schtroumpf a raison:
                        ce que tu veux c'est une vue orthonomée, cependant attention a son utilisation car cela donne un vue que l'on n'a pas l'habitude d'utiliser.
                        Je te previen tu va avoir du mal a t'y faire!

                        deja remplace:

                        Citation : Code C

                        gluPerspective(70,(double)LARGEUR_ECRAN/HAUTEUR_ECRAN,1,1000);
                        par
                        glOrtho(HAUTEUR_ECRAN,HAUTEUR_ECRAN,LARGEUR_ECRAN,LARGEUR_ECRAN,1,1000);


                        ensuite si tu veux voir quelque chose initialise distance à 0.01
                        et change le pas de déplacement a 0.01.

                        maintenant amuse toi bien a comprendre comment sa marche, n'ésite pas à faire des test y a que comme sa qu'on apprend.

                        ps: j'ai quand même passé la journée sur ton probléme mais maintenant je sais comment fonctionne glOrtho.

                        • Partager sur Facebook
                        • Partager sur Twitter
                          4 août 2006 à 20:53:26

                          Citation : Uchuujin-san

                          le grand schtroumpf a raison:
                          ce que tu veux c'est une vue orthonomée, cependant attention a son utilisation car cela donne un vue que l'on n'a pas l'habitude d'utiliser.
                          Je te previen tu va avoir du mal a t'y faire!

                          deja remplace:

                          Citation : Code C

                          gluPerspective(70,(double)LARGEUR_ECRAN/HAUTEUR_ECRAN,1,1000);
                          par
                          glOrtho(HAUTEUR_ECRAN,HAUTEUR_ECRAN,LARGEUR_ECRAN,LARGEUR_ECRAN,1,1000);


                          ensuite si tu veux voir quelque chose initialise distance à 0.01
                          et change le pas de déplacement a 0.01.

                          maintenant amuse toi bien a comprendre comment sa marche, n'ésite pas à faire des test y a que comme sa qu'on apprend.

                          ps: j'ai quand même passé la journée sur ton probléme mais maintenant je sais comment fonctionne glOrtho.



                          c'est pas plutot:
                          glOrtho(0,HAUTEUR_ECRAN,0,LARGEUR_ECRAN,1,1000);

                          ??? :o

                          En tout cas, c'est ce qu'il y a marqué dans la doc(enfin, je crois...).
                          • Partager sur Facebook
                          • Partager sur Twitter
                            4 août 2006 à 21:02:07

                            Oula oula. Merci d'avoir passé tant de temps sur mon problème Uchuujin-san, mais je n'ai pas tout saisi...

                            En fait, glOrtho() parmet de faire une projection orthogonale d'une scène 3D sur un plan.

                            Je connai la projection orthogonale en 2D (cours de maths), mais je ne l'ai jamais utilisé dans l'espace. Wikipédia est mon ami, et voici des points intéressants :

                            Citation : Wikipedia - Projection Orthogonale

                            en géométrie dans l'espace, c'est une projection telle que la droite et le plan — quels que soient leurs rôles respectif — sont perpendiculaires.

                            La projection orthogonale est un type de perspective très utilisée en dessin technique (géométrie descriptive), et en infographie : la génération des figures est simple, par contre, on ne peut pas représenter l'éloignement (la taille des objets ne varie pas avec la distance).



                            Ceci m'a intrigué. Logique qu'on ne puisse pas représenter l'éloignement car c'est un phénomène 3D, et qu'on vien de projeter notre scène sur un plan.

                            Mais alors est ce qu'on pourrait obtenir de la 3D iso ?

                            J'ai essayé ce que tu as dit avec les paramètres suivant :

                            glOrtho(LARGEUR_ECRAN,LARGEUR_ECRAN,HAUTEUR_ECRAN,HAUTEUR_ECRAN,1,1000);

                            (Et avec le tien aussi, mais ça revien au meme il me semble.)

                            Et c'est vraiment, bizarre. Le cube est bien applati, on le voit, mais j'ai du mal à déplacer la scène, le cube se coupe sur des lignes immaginaires on dirait, peut être car la caméra est trop proche...

                            Bref, je ne comprends pas bien. Quel est le résultat créé par glOrtho. Et pourquoi doit-on l'utiliser avant de dessiner la scène. Car si on utilise une matrice paramétrée sur un plan, comment peut on dessiner de la 3D, ou alors les transformations sont directement appliquées lorsqu'on veut dessiner à l'ecran ?

                            Si tu pouvais expliquer un petit peu, car là je suis un peu paumé. Est ce que tu arrive à de bons résultats toi, moi en tout vas je n'obtiens rien de bon...

                            Merci beaucoup à toi en tout cas, ce sujet est très intéressant !

                            Pour ci-dessu, le grand schtroumpf >
                            J'ai essayé avec tes réglages, et je n'obtiens rien de bon. Je vais essayer de bidouiller...
                            • Partager sur Facebook
                            • Partager sur Twitter
                              4 août 2006 à 21:26:16

                              le grand schtroumpf -> yes effectivement je me suis trompé et je viens de comprendre quelque chose grasse a toi! MERCI!

                              bon je vais essayer d'expliquer ce que j'ai compris, pas facile pour moi on m'a souvent dit que je manquait de pédagogie.

                              deja pour bien comprendre la differance entre vue cavaliere et vue orthonormé.
                              vue cavaliere:
                              c'est celle dont on se sert le plus souvent, c'est aussi ainsi que nous voyons le monde qui nous entour.
                              Une image qui represente le "cone" de vision en OPENGL.
                              comme tu peut le voir c'est comme dans le cour de Kayl.
                              Tous ce qui ce trouve dans la pyramide tronque serat affiché a l'ecran.
                              le fais que le champ de vision soit connique donne l'effet que plus un objet et loin plus il parrait petit.
                              ainsi une grille donnerat cette effet avec une vue cavaliere.
                              OK ? OK!

                              Bon maintenant la vue orthonormé, je te previen c'est vraiment pas facile de s'y faire.
                              Une image qui represente le "cone" (c'est pas du tout un cone comme tu peux le voir) de vision orthonormé en OPENGL.
                              comme pour la vue cavaliere tous ce qui ce trouve dans le "cube" serat affiché.
                              comme tu peux t'en douter les 2 cubes de l'exemple auront exatement la même taille bien qu'ils soit a des distances differente.
                              ainsi la grille de l'exemple précedant deviendrat comme ceci.

                              voila suis-je asser claire ? si non n'esite pas à redemande des explications.

                              ps:les images des PDF ne sont pas à moi j'editerait ce post une fois que j'aurait fais des images a MOI.
                              • Partager sur Facebook
                              • Partager sur Twitter
                                5 août 2006 à 0:08:22

                                tu te trompe Uchuujin-sempaï, c'est toi qui vient de m'apprendre beacoup de choses! :p

                                P.S:
                                Je vient d'essayer d'utiliser glOrtho pour la première fois:
                                ça marche pas :p (c'est tout noir)

                                [EDIT] je sui c**!
                                Je vien de relire la doc et j'ai compris(et ça marche!) :p
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  5 août 2006 à 0:49:57

                                  Moi, à vrai dire, je suis un peu paumé.

                                  Citation : Uchuujin-san

                                  comme tu peux t'en douter les 2 cubes de l'exemple auront exatement la même taille bien qu'ils soit a des distances differente. Pas de problèmes, jusque là je comprend.

                                  ainsi la grille de l'exemple précedant deviendrat comme ceci(la grille est coupé en 2 c'est normale!!). C'est là que ça bloque !



                                  Pour la 3D, je comprends parfaitement, j'ai réalisé un croquis (paint power) vite fait, et je comprends l'affichage de la grille.
                                  Image utilisateur
                                  (Cliquez pour agrandir.)

                                  Ensuite, pour ce qui est de la vue orthonormée (cavaliere), je comprends le principe, mais je bloque sur l'affichage de la grille. Je ne comprends pas pourquoi elle serait coupée à un endroit (au milieu de l'écran ?). Bref, j'ai aussi réalisé un croquis, mais là je ne sais pas si il est juste, et c'est sur ce point que j'aimerai des précisions.
                                  Image utilisateur
                                  (Cliquez pour agrandir.)

                                  La je ne suis pas sûr à propos de la position de la grille et des axes...
                                  (X: bleu, Y: vert, Z: rouge)
                                  Est ce que je me trompe ?

                                  En tout cas, dans la logique de mon croquis, on ne devrait rien voir, ou juste un trait horizontal au bas de l'écran. Or ce n'est pas ça, il y a donc quelque chose que je n'ai pas saisi.

                                  Merci à vous deux en tout cas, on progresse bien !
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    5 août 2006 à 11:35:23

                                    effectivement tu devrait voir un trai horizontale moi c'est ce que sa fais.
                                    mais si tu veux optenir un resulta meilleur tu peux mettre par exemple:

                                    Citation : C

                                    glOrtho(-2,2,-2,2,1,1000);


                                    j'ai prie 2 au hazard, mais ainsi la ligne que tu devrait voir ce trouvera au centre de ton ecran.

                                    pour l'histoire de la grille coupée en 2 c'est pas facile a explique.
                                    Je me suis servie de ton programme comme base ainsi ma camera est incliné a 45° comme tu le precise dans le dessin du carre.
                                    Le probleme c'est que j'avais choisi un plan de projection tros grand comme par exemple:

                                    Citation : C

                                    <glOrtho(-5,5,-5,5,1,1000);


                                    alors que distance=2;

                                    avec des valeurs pareille le plan de projection coupait la grille et c'est pour sa que le bas de l'image est noir.

                                    pour corriger il suffit d'éloigner la camera ou de reduire le pland de projection.

                                    actuellement j'ai de bon résultat avec

                                    Citation : C

                                    glOrtho(-2,2,-2,2,1,1000);
                                    et
                                    distance =3;


                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      5 août 2006 à 12:30:53

                                      Citation : Uchuujin-san

                                      effectivement tu devrait voir un trai horizontale moi c'est ce que sa fais.


                                      Moi je n'arrive pas à obtenir un trait horizontal, et je ne sais pas pourquoi... Pourtant, si ce que j'ai supposé est bon, j'aurai dû l'obtenir, mais non.

                                      Moi j'obtiens seulement la grille en gros plan, qui se coupe en haut et/ou en bas en fonction de la distance.

                                      J'ai vraiment envi de réussir, alors j'ai assez perfectionné le programme pour permettre plusieurs choses. J'ai édité le code dans mon premier post, et les fichier de mon ftp (zip, tar, 7z), ont aussi été actualisés (normalement :p). Il y a toujours code source, .exe et projet .cbp.

                                      Voilà les touches et fonctions :

                                      • Flèches pour se déplacer
                                      • pavnum 8 et 2 pour augmenter/réduire la distance
                                      • Page up/Page down pour réduire/augmenter la taille du cube/repère
                                      • Inser/Del pour réduire/augmenter la taille du sol/grille
                                      • 's' pour afficher/masquer le sol
                                      • 'g' pour afficher masquer la grille
                                      • 'c' pour afficher/masquer le cube
                                      • 'r' pour afficher/masquer le repère
                                      • 'home' pour rétablir les variables initiales


                                      Voila, avec ça j'ai pu obtenir de bons résultats, en expérimentant.

                                      J'ai ajouté des defines pour pouvoir changer rapidement les paramètres de glOrtho et la distance de base.

                                      Il y a aussi un fprintf pour voir la distance à laquelle on est (quand on quitte le programme par exemple, pour voir à quelle distance on était). (Là il est désactivé).

                                      Bref, avec ces réglages:

                                      glOrtho(-10,10,-10,10,1,1000);
                                      et
                                      distance = 10;


                                      J'arrive à une vue générale pas trop mal. J'ai essayé aussi avec

                                      glOrtho(0,10.24,0,7.68,1,1000);
                                      et
                                      distance = 1.6;


                                      Histoire de retrouver un peu un ratio 4/3, mais je sais pas trop si c'est bien.

                                      Maintenant qu'on a cerné un peu plus le principe, faudrait trouver de bons réglaces pour la 3Diso. En tout cas on a bien progressé !!!
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        5 août 2006 à 14:32:45

                                        Et bien c'est pas mal du tous tout ça!!

                                        Pour touver les bon réglage ça depant de ce que tu veux faire,
                                        jeu de strategie militaire, sims-like , T4C-like , fallout-like ,....

                                        faut tester!! bon courage
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          6 août 2006 à 11:13:23

                                          Bon...

                                          On a bien progressé dans ce topic, mais je me pose de plus en plus de questions, et j'aimerai des avis/conseils.

                                          Tout d'abord, hier soir j'ai créé le système de déplacement du personnage. Je voulai qu'il se fasse en case par case, mais progressivement (pas d'un coup, normal).

                                          Eh ben j'y ai bavé, et la système actuel qui marche assez bien, avec quelques defauts est la 4ème version de mes efforts oO

                                          Bref, je me pose de plus en plus de questions.

                                          Tout d'abord, j'y vais à tatons pour transférer la scène en 2D, sans trop savoir à quoi correspondent les réglages, le nombre de cases affichées à l'écran, la largeur, le ratio, bref, pas mal de choses.

                                          Ensuite, pour intégrer par exemple, un arbre dans ma scène. Je ne sais pas encore le faire en 3D à l'aide de OpenGL, mais il va sûrement falloir définir tout les points à la main, ou alors le modeler sur blender pour l'importer dans le jeu.

                                          Tout ça pour quoi ? Pour faire un pauvre arbre qui ne sera visible sous qu'un seul angle de vue...

                                          Même si l'OpenGL est plus beau, plus rapide, il faut quand même avouer que c'est assez long et difficile (à moins de prendre un moteur déjà existant).

                                          Bref, venons en au fait. Je n'arrête pas de me demander si je ne devrais pas plutôt réaliser ce projet en SDL uniquement. Le rendu seraipeut être un peu moins beau, mais le travail serait simplifié (sprites par exemple), et j'aurai plus de facilitée à créer l'environnement (je veux dire par là savoir le nombre de cases et tout, car là en OpenGL c'est un peu flou...).

                                          Bref, je me dis sans arrêt : pourquoi ne pas tout simplement se limiter à la SDL, après tout, tous les jeux en 3D iso sont en 2D...

                                          Et c'est pourquoi je demande votre avis à ce propos.

                                          Peut être que la base sera plus difficile à créer en SDL (orienter correctement la grille, le nombre de cases...), car en OpenGL c'était vraiment enfantain (glOrtho et c'est dans la poche), mais la suite sera grandement simplifiée.

                                          Pour reprendre mon exemple, je veux mettre un arbre ? Une joli image, un ColoreKey et c'est dans la poche.

                                          Voilà ce qui m'a trotté dans la tête toute la nuit, et j'aimerai que certains me conseillent pour que je puisse choisir réellement ce qui est le mieux.


                                          Merci à tous !
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            6 août 2006 à 11:47:53

                                            effectivement les choix entre 2D et 3D peut etre assez difficile, ça depent surtout quelle fonctionalité tu désire.
                                            La 2D:
                                            + plus facile a mettre en oeuvre
                                            + peut etre plus jollie dans certain cas
                                            - obligation de dessiner tous les sprites (pour un bonhomme faut dessiner les vue de droite,gauche,devant,derrier,...)
                                            - si tu veux permetre a l'utilisateur de pivoter a 90° comme dans WC3 ça va te demmandé (beaucoup) plus de boulot.

                                            la 3D:
                                            + une fois un modele crée on peut le voir sous toutes les coutures.
                                            + possibilité de regarder la scéne sous tous les point de vue sans grande difficulté.
                                            - il faut faire les objets 3D ou trouver quelqu'un pour les faire (je sais pas si c'est un moin mais c'est difficile de trouver des personne qui veulent bien t'aider dans ce domaine)
                                            - moins facile a mettre en oeuvre, c'est logique
                                            - il faut trouver un moyen pour importer les modéles 3D, OpenGl ne le fais pas.

                                            cette liste n'est pas complette c'est simplement les premier truc qui me vienne à l'esprit.

                                            Il faut que tu definise quelle type de jeu c'est et quelle fonctionalité tu a absolument besoin et celle dont tu peux te passer.

                                            [EDIT] si tu nous dit quel type de jeu tu veux faire on pourait mieux s'imaginer.
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              6 août 2006 à 12:12:24

                                              En effet, je n'avai pas trop réfléchis en fonction des points forts/points faibles, alors je vais essayer de le faire maintenant.

                                              Je souhaite créer un T4C-like, pour ceux qui connaissent.

                                              Qualité graphique / beauté du jeu + 2D


                                              Il est clair que la qualité graphique se laisse apprécier, mais ce n'est pas la chose la plus importante. Regardez T4C, les graphismes ne sont pas géniaux, mais le jeu l'est lui.

                                              Facilité de mise en oeuvre + 2D


                                              De toute manière, ce projet restera amateur, et comme vous le savez la plupart de ces projets n'aboutissent pas (et je ne serai pas surpris que le mien applique lui aussi cette fatalité). C'est pourquoi la facilité de mise en oeuvre est importante, car trop de difficultées = baisse de motivation = projet à terre. (Même si ça doit pas être simple non plus en 2D, mais tout est relatif).

                                              Angles de vue + 2D


                                              Là aussi je vais donner un point à la 2D, car il s'agit d'un jeu en 3D iso, l'angle de vue se doit d'être fixe. Bien sûr, une rotation à la Warcaft III ne serai pas de refus, mais le jeu n'en vaut pas la chandelle, et mieux vaut jouer l'assurance. Il est possible de trouver des subterfuges pour combler ce 'manque' (enfin, si on peu appler ça un manque... T4C et Diablo s'en sortent bien sans cette fonction).

                                              Modles + 3D


                                              Là je l'avoue, c'est vrai qu'une fois qu'on a créé un modle (perso ou autre), on en fait ce qu'on veut. Une fois le module d'importation créé, c'est tout bonheur.

                                              Encore faut il créer ces modles et le module de chargemen de ceux-cis + 2D


                                              Voilà un autre problème. La facilité cache la difficultée, créer ces modles ne va pas être facile, et je n'ai pas encore la moindre idée de comment créer le module pour les intégrer dans OpenGL.

                                              Oui mais en 2D, tu va te taper tous les sprites ! Neutre


                                              Je ne donne pas de point favorable ni à la 2D ni à la 3D, car certes il faut créer les sprites, mais en contre partie en 3D il faut créer les modles et les importer. Chaque système à ses 'problèmes'.

                                              Rapidité + 3D


                                              On dit que OpenGL est plus rapide que SDL, je le conçois (si on code bien bien entendu). Mais la SDL n'est pas lente pour autant, loin de là. Enfin, j'ai quand même mis un + à la 3D, mais à vrai dire ça n'a pas trop d'importance.

                                              Gameplay + 2D


                                              Sélectionner des objets, écrire du texte, gérer les entrées utilisateur, je vais mettre un point à la 2D, car ça me semble plus facile de réaliser un gameplay 2D qu'un gameplay 3D.

                                              Conclusion


                                              Voilà, j'ai listé quelques caractéristiques que je voudrais voir apparaître dans mon jeu, et on voit bien que la 2D présente (enfin je pense) plus d'avantages. Je pense donc me pencher uniquement sur la SDL, tout du moins je vais regarder de ce côté et voir ce qu'il en est !


                                              En tout cas j'ai bien progressé dans ce topic et j'ai appris pas mal de choses. Ca va me permettre de bien avancer, je vous remercie sincèrement. Je vous tiendrai au courant de l'avancement !
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                6 août 2006 à 12:15:40

                                                Tu te laisses influencer par le peu que tu as veux des deux mondes pour l'instant. Si tu planches beaucoup sur quelque chose ca te semblera forcement plus simple. Sache en tout cas que l'importation de models 3D n'est pas si compliqué... mais c'est tout ce qu'il y a autour qui l'est (texturing, lumieres, matériaux...) pour que ca rende bien...
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  6 août 2006 à 12:47:30

                                                  lexou a raison sur un point "C'est en Forgeant... Que l'On Devient Forgeron" (j'aime bien cette expression ;) )

                                                  Mais je pense que le choix de la 2D n'est pas un mauvais choix,
                                                  MAIS je te conseil de prendre encore 1 ou 2 jours pour réflechire.
                                                  choissir le langage (C/C++/JAVA/....) et de faire un planning réaliste de ce que tu veux faire ( c'est le plus dur )
                                                  et oui si tu veux que ton projet aboutisse y a quelque régle a suivre, et ce n'est pas que moi qui le dit, tous ceux qui ce sont lancé dans ce genre de projet le disent.

                                                  - Pas de précipitation ,c'est ton pire ennemi, un jeu sa prend des années a faire.
                                                  - Vas y petit a petit, concentre toi dabord sur sur le principale.
                                                  exemple: dessiner le terrain -> dessiner les perso -> deplacer les perso -> .....
                                                  - et surtout pas de gourmandise, n'imagine pas les sorts avant de deplacer ton perso.

                                                  Je sais c'est facile a dire et vraiment pas facile a appliquer.
                                                  ( conseil: fais toi un post-it et colle le au dessu du PC des fois ça marche ;) )

                                                  A si dernier conseil ne tombe pas dans le piége : "je vais faire un super MMORPG de la mort qui tue tous avec des milions de joueurs et je vais devenir super riche.... ", enfin tu vois le truc...

                                                  Alors bonne continuation et si ta des questions on est là alors essite pas.
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    6 août 2006 à 13:23:43

                                                    Le problème quand on se lance dans ce genre de projet avec peu de connaissance c'est qu'il y a bcp de chances qu'une erreur de conception soit commise des le début... de quoi t'obliger à un moment ou à un autre à tout recoder. C'est ce qu'il faut à tout prix éviter.
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      6 août 2006 à 13:35:37

                                                      mhhh.... c'est vrai mais je ne connais pas le niveau de Benjitheone alors c'est asser difficile d'imaginé les difficultées qu'il va rencontré.

                                                      C'est vrai que la conception du game design du jeu prend normalement beaucoup de temps.
                                                      ( j'utiles game design mais c'est peut être un terme un peut vague...
                                                      on va dir que c'est la partie dans laquelle on decide comment va se comporté le jeu, sa va du choix du moteur 2D ou 3D au choix de la difficulté (reglable ,autoajuste) en passant par les deplacement du joueur (il peut sauter ou pas ...))

                                                      voila...heu j'ai oublié ce que je voulait dir. :euh:

                                                      ha si faut pas ce decourager !! c'est long on rencontre beaucoup de probleme , mais tu apprend tellement de chose a faire un jeu que je pense que sa en vaut la chandelle.
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        6 août 2006 à 23:11:47

                                                        Citation : lexou

                                                        Tu te laisses influencer par le peu que tu as veux des deux mondes pour l'instant. Si tu planches beaucoup sur quelque chose ca te semblera forcement plus simple. Sache en tout cas que l'importation de models 3D n'est pas si compliqué... mais c'est tout ce qu'il y a autour qui l'est (texturing, lumieres, matériaux...) pour que ca rende bien...


                                                        En effet, je viens de le constater en essayant la 3D iso avec SDL, enfin j'en parlerai plus tard.

                                                        Citation : Uchuujin-san

                                                        MAIS je te conseil de prendre encore 1 ou 2 jours pour réflechire.


                                                        C'est ce que je m'étais dit aussi. Enfin je verrai quand j'en aurai vu un peu plus sur les techniques de la 3D iso en 2D.

                                                        Citation : Uchuujin-san

                                                        et de faire un planning réaliste de ce que tu veux faire ( c'est le plus dur )
                                                        et oui si tu veux que ton projet aboutisse y a quelque régle a suivre, et ce n'est pas que moi qui le dit, tous ceux qui ce sont lancé dans ce genre de projet le disent.


                                                        Je vais bien entendu établir un cahier des charges aussi complet que possible, mais je voulai toucher un peu àla programmation avant (même si ce n'est qu'un tout petit peu, mais juste pour voir dans quoi je m'aventure), et j'ai bien fait je pense.

                                                        Citation : Uchuujin-san

                                                        - Pas de précipitation ,c'est ton pire ennemi, un jeu sa prend des années a faire.
                                                        - Vas y petit a petit, concentre toi dabord sur sur le principale.
                                                        exemple: dessiner le terrain -> dessiner les perso -> deplacer les perso -> .....
                                                        - et surtout pas de gourmandise, n'imagine pas les sorts avant de deplacer ton perso.


                                                        Je retrouve là ce qu'on dit à tous ceux qui commencent un projet, et merci de me le rappeler, même si je pense en avoir pris conscience maintenant (j'espers :p).

                                                        Citation : Uchuujin-san

                                                        A si dernier conseil ne tombe pas dans le piége : "je vais faire un super MMORPG de la mort qui tue tous avec des milions de joueurs et je vais devenir super riche.... ", enfin tu vois le truc...


                                                        Ca je l'ai très bien compris, et je l'ai fais comprendre à des gens qui voulaient coder WoW avec RpgMaker je sais pas quoi :p
                                                        Bref, de toute manière, sincèrement mon projet a de grandes chances de ne pas aboutir (et je le sais), mais quoi qu'il arrive, ça m'aura forcément apporté quelque chose.

                                                        Citation : Uchuujin-san

                                                        Alors bonne continuation et si ta des questions on est là alors essite pas.


                                                        Merci, et je pense que je vais avoir quelques questions encore... :(

                                                        Citation : lexou

                                                        Le problème quand on se lance dans ce genre de projet avec peu de connaissance c'est qu'il y a bcp de chances qu'une erreur de conception soit commise des le début... de quoi t'obliger à un moment ou à un autre à tout recoder. C'est ce qu'il faut à tout prix éviter.


                                                        Et je pense qu'avec mon niveau de connaissances et mon expérience, ça risque fort de m'arriver. Mais de toute manière, ca arrive forcément un jour, sinon on apprend jamais...

                                                        Citation : Uchuujin-san

                                                        mhhh.... c'est vrai mais je ne connais pas le niveau de Benjitheone alors c'est asser difficile d'imaginé les difficultées qu'il va rencontré.


                                                        Eh ben il n'est pas très élevé, il se limite à ce qu'enseigne M@téo avec quelques plus et quelques moins sûrement, et quelques notions C++ de base (mais pas ce qui concerne le polymorphisme, l'héritage et tout...).
                                                        Mais je compte m'améliorer, que ce soit avec les cours de C++ que M@téo va sortir, ou avec des bouquins, ou autre.

                                                        Citation : Uchuujin-san

                                                        ha si faut pas ce decourager !! c'est long on rencontre beaucoup de probleme , mais tu apprend tellement de chose a faire un jeu que je pense que sa en vaut la chandelle.


                                                        C'est exactement ce que je me dis ! Enfin, ça ne peux que m'apprendre des choses, même si ça échoue lamentablement (ce qui risque d'arrive, comme à beaucoup de monde :p).

                                                        Sinon, pour ce qui est de la rencontre de nombreux problèmes... j'en ai des tonnes !!!

                                                        Voilà, après avoir répondu à vos messages, je vais vous présenter mon problème...
                                                        Je suis vraiment (mais alors vraiment) paumé en ce qui concerne la 3D iso à partir de la 2D !

                                                        J'ai recherché des techniques sur internet, mais il n'y a pas grand chose, ou alors ce sont des truc très spécifique.

                                                        Bref, je suis dans le flou total.

                                                        J'ai développé le début de l'application, qui ressemble plus à un champ de bataille qu'a autre chose...

                                                        Si vous voulez voir les sources, c'est ici (en zip) ou ici (en tar).

                                                        Bref, voilà ce que j'ai fais:

                                                        J'ai dessiné une grille en 'points', où seule les intersections sont représentées.
                                                        J'ai effectué une rotation de 45°, et j'ai appliqué un coefficient de déformation pour obtenir une vue isométrique.

                                                        Le résultat n'est pas trop mal, mais j'ai vraiment du mal du côté de l'utilisation de tout ça.

                                                        Mon plus gros problème pour le moment est le fait que la grille doit être centrée sur une case (celle du personnage). Je n'arrive jamais à obtenir ce que je veux, et je patauge vraiment.

                                                        Je me dis qu'il faut calculer, à partir de la case principale les cases extrêmes pour limiter l'affichage, mais je ne vois pas vraiment comment faire.

                                                        Enfin, je savai que le début serai plus difficile en SDL, mais pas à ce point là ! Si vous auriez deux trois truc pour me mettre sur la piste, ce serait vraiment bien, car sinon... aie ^^

                                                        Merci d'avoir lu ce long message en tout cas ! Bonne nuit !

                                                        edit: Je vais tout remanier car là c'est vraiment le carnage...
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          7 août 2006 à 12:48:21

                                                          effectivement aprés une petite recherche sur le net (merci google!)
                                                          j'ai trouvé un site intéressant, je n'ai fais que le survoller mais je me pencherait un peu plus dessus ce soir.
                                                          http://www.progzone.free.fr/graphisme/3diso/3diso.html

                                                          Bon sa pas l'air si terrible que ça quand meme.

                                                          parcontre c'est maintenant qu'il faut choissir tu veux un affichage rapide :
                                                          -on se fait pas chier toujour le meme angle de vue, et le terrain est toujours plat.
                                                          -ou l'utilisateur peut changé sa vue et le terrain peut etre accidenté.

                                                          le premier est boucoup plus simple comme tu peut t'en douter.
                                                          le second (beaucoup) plus compliqué nécéssite la creation d'un moteur 3D iso.

                                                          je sais c'est TRES chiant mais fais le cahier des charges maintenant pour voir ce dont tu a besoin.
                                                          il faut savoir definir ses besoins.
                                                          tu veux un jeu qui fonctionne et vite?
                                                          ou un jeu qui prend un peut plus de temps mais qui soit plus facile a evoluer?

                                                          je sais je peut paraitre chiant sur la partie game design , mais c'est souvent parceque les gens ne la font pas que le projet n'abouti jamais est c'est vraiment dommage car certain on vraiment des bonnes idées.

                                                          je suis chiant hein ^^ mais c'est pour ton bien :p

                                                          et puis je pense que c'est vraiment une bonne experience de ce penché sur la 3D isometrique, moi sa m'amuse.

                                                          [EDIT] j'ai pris le temps de regarder le lien ci-dessus et ma fois il est assez intérressant.
                                                          perso je pensait pas que l'on pouvait faire autemp avec de la 3D isometrique.
                                                          Je pense, et si j'ai bien compris, avec la 2eme technique on doit pouvoir se déplacer a 180° degrées sans tros de probléme par contre pour faire un 360° je ne vois pas, peut etre faut-il faire une gymnastique mathématique ( :D sa rime).
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter

                                                          [OpenGL] 3D isométrique

                                                          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                          × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                          • Editeur
                                                          • Markdown