Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Invité
    Invité(e)

    Par défaut Algorithme de transformation 3D

    Bonjour,

    Voilà alors j'ai un problème concernant mon algorithme pour faire de la 3D, par avance je n'utilise aucune fonctions du gpu pour faire la 3D.
    Et j'aimerais gardé cette aspect simple/facile, plutôt que faire appel au fonctions matriciel, fonction lookat() et j'en passe et des meilleurs .

    Je passe donc tout par cpu, alors voiçi l'algorithme:


    - Au départ, j'ai un vecteur point correspondant à un point de mon objet.

    - Object_Management:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    - J'addition ce vecteur avec un autre vecteur appeller obj_position[4] 
     
    - Puis je passe ce vecteur à travers mes equation de rotations:
     
                                 X-axe
                 1y  = (1y * cos(phi_x)) - (1z * sin(phi_x))
                 1z  = (1z * cos(phi_x)) + (1y * sin(phi_x))
     
                                 Y-axe
       End.1z  = 1z' = (1z * cos(phi_y)) - (1x * sin(phi_y))
                 1x  = (1x * cos(phi_y)) + (1z * sin(phi_y))
     
                                 Z-axe
       End.1x  = 1x' = (1x * cos(phi_z)) - (1y * sin(phi_z))
       End.1y  = 1y' = (1y * cos(phi_z)) + (1x * sin(phi_z))
     
     
    - J'addition le vecteur sortie avec un autre vecteur appeller obj_repere[4]
    - Camera_Management:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    - J'addition le vecteur sortie avec un autre vecteur appeller world_repere[4] 
     
    - J'addition le vecteur sortie avec un autre vecteur appeller cam_repere[4] 
     
    - Je passe ce vecteur à travers mes equation de rotations une nouvelles fois:
     
                                 X-axe
                 1y  = (1y * cos(phi_x)) - (1z * sin(phi_x))
                 1z  = (1z * cos(phi_x)) + (1y * sin(phi_x))
     
                                 Y-axe
       End.1z  = 1z' = (1z * cos(phi_y)) - (1x * sin(phi_y))
                 1x  = (1x * cos(phi_y)) + (1z * sin(phi_y))
     
                                 Z-axe
       End.1x  = 1x' = (1x * cos(phi_z)) - (1y * sin(phi_z))
       End.1y  = 1y' = (1y * cos(phi_z)) + (1x * sin(phi_z))
    - Screen_Management :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    - J'affiche ce vecteur à l'ecran en le mettant dans un tableaux grace à l'equation: 
     
       x = (x * distance) / z
       y = (y * distance) / z
     
       screen[repere - (x * BPP + PITCH * y)] = color

    Et pour gérée le déplacement de la camera, je change le vecteur cam_repere[] selon sur l'axe où je veut me déplacer, mais si je veut m'avancer selon l'axe forward de la camera, je me retrouve vite coincés.



    Merci d'avance.
    Dernière modification par Invité ; 14/04/2015 à 18h57.

  2. #2
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    mai 2008
    Messages
    24 370
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : mai 2008
    Messages : 24 370
    Points : 178 871
    Points
    178 871
    Billets dans le blog
    49

    Par défaut

    Bonjour,

    Vous vous retrouvez coincer par quoi/pourquoi ?

    Sinon, pourquoi ne pas utiliser le classique système à trois matrices : une pour l'objet, une pour la vue, une pour la projection (mapping 3D vers 2D). Ainsi, il suffit juste d'implémenter toutes les fonctions mathématiques pour les vecteurs et les matrices et voilà, c'est bon, ça marche.
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  3. #3
    Invité
    Invité(e)

    Par défaut

    Salut,

    Pour bien comprendre ce problème, je met ici mon moteur qui utilise cette algorithme.
    Il n'y a que le batch à éxecuté (HackEngine\2.MAKE\5.0-make-HackEngine.bat).

    Une fois le programme en cours, bouger la camera avec la souris puis avancer avec Z, et voilà le problème, c'est que ça avance pas là où je regarde

    Et non merci, je ne veux aucunement utiliser cette méthode là, non merci . Pourquoi ? parceque j'ai envie


    - Pour démarrer le batch, il faut avoir windows 64 bit et avx support, pour le voir metter la marque de votre cpu dans bing (), puis cliquer sur ark.intel, et regarder dans la section: Instruction Set Extensions (ex: http://ark.intel.com/products/53464/...up-to-3_50-GHz)

    - Pour connaitre sa marque de cpu, aller sur le bureau, crée un fichier texte, puis renommer le en .nfo et regarder section Processor.

  4. #4
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    mai 2008
    Messages
    24 370
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : mai 2008
    Messages : 24 370
    Points : 178 871
    Points
    178 871
    Billets dans le blog
    49

    Par défaut

    Dommage, j'ai Linux
    Pourquoi ne pas faire une vidéo ?
    Et de toute façon, si vous n'avez pas envie d'utiliser les méthodes habituelles, je risque de ne pas pouvoir aider.
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  5. #5
    Invité
    Invité(e)

    Par défaut

    Pas de problème, merci quant même ^^

  6. #6
    Membre expérimenté

    Profil pro
    Programmeur
    Inscrit en
    août 2002
    Messages
    1 091
    Détails du profil
    Informations personnelles :
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Programmeur

    Informations forums :
    Inscription : août 2002
    Messages : 1 091
    Points : 1 668
    Points
    1 668

    Par défaut

    Citation Envoyé par glojii Voir le message
    Une fois le programme en cours, bouger la camera avec la souris puis avancer avec Z, et voilà le problème, c'est que ça avance pas là où je regarde .
    Si tu bouges la vue avec la souris, il faut mémoriser le vecteur de vue (dans quelle direction tu regardes) et utiliser cela comme base pour ton déplacement (si tu ne tiens pas compte de la vue dans ton déplacement ça ne va pas marcher).

    Après ce n'est pas si simple puisqu'il y a plein de méthodes différentes de déplacement. Dans la direction de la caméra : tu utilises directement le vecteur de vue -> le problème c'est que ce mode de déplacement est déroutant parce qu'on est habitué à se déplacer sur Terre où il y a un haut, un bas et de la gravité (possible dans l'Espace mais les déplacements dans l'Espace sont déroutants pour l'esprit humain). Dans les FPS (first person shooters), la rotation de la souris est décomposée en YAW/PITCH/ROLL (angles nautiques) ou autres variations basées sur la décomposition en angles d'Euler. Le problème de cette décomposition c'est qu'elle est incomplète (ou "complète" mais ambigüe, je ne rentre pas dans les détails) mais elle satisfait bien le problème du FPS, et donc le mouvement se fait selon le vecteur uniquement modifié par le premier angle (YAW ou rotation sur toi-même). Il y aurait d'autres variantes (pour les avions, ou caméra libre mais qui élimine le roulement libre ou qui ramène tout au repère de la Terre etc..)

    Donc à chaque update de position tu fais :
    - déterminer le vecteur déplacement. Soit le vecteur vue, soit le vecteur horizontal front facing modifié par la première rotation (YAW).
    - nouvelle position = position précédente + vitesse de déplacement * temps écoulé * vecteur déplacement. (<- c'est une forme d'intégration numérique simple qui marche généralement pour les FPS, certains jeux vont nécessiter d'être plus complets en utilisant la notion d'accélération, inertie et calcul des forces selon les formules de Newton. <- la vitesse elle-même sera un vecteur et, en théorie, résultat de l'intégration des forces sur un intervalle de temps.. Bref de la physique quoi..).

    Et voilà.

    PS: en vue FPS tu as aussi souvent du Strafe. Donc c'est la même chose mais selon le vecteur horizontal qui part vers ta gauche (ou ta droite selon la direction du strafe) là encore modifié par la première rotation (YAW). Si tu as déjà le vecteur horizontal front facing modifié tu peux faire une simple permutation des termes pour avoir le vecteur perpendiculaire. (ça correspond à un cross product selon le vecteur UP (0,0,1) ou (0,1,0) selon tes conventions..)

    Mon site web | Mon blog | Mes photos | Groupe USA
    > BONJOUR, JE SUIS NOUVEAU SUR CE FORUM
    > presse la touche caps lock, stp
    > OH.. MERCI C EST BEAUCOUP PLUS FACILE COMME CA

  7. #7
    Invité
    Invité(e)

    Par défaut

    Merci merci pour cette explication bien complète, peut être que je vais enfin finir cette caméra de malheur (3 ans de recherche ).

    Bon je teste, on verra bien si j'arrive, maintenant.

    Merci encore.


    (ah mince j'ai omnis un truc, c'est que si je passe l'addition de vecteur de cam_repere après la rotation de la cam, j'avance bien où je regarde sauf que le repère de la camera ne bouge pas, sa position seulement (comme un scope comme dans les fps (lunettes de visée)))
    Dernière modification par Invité ; 16/04/2015 à 17h55.

  8. #8
    Invité
    Invité(e)

    Par défaut Quelques corrections

    J'ai apporter quelques corrections à mon algo, enjoy:

    - Au départ, j'ai un vecteur point correspondant à un point de mon objet.

    - Object_Management:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    - J'additionne ce vecteur avec un autre vecteur appeler obj_position[4]
     
    - Puis, je passe ce vecteur à travers mes équations de rotations:
     
        // Rotate xyz order matrix
            End.x = x * ((cos(obj_rad_y) *                                                      cos(obj_rad_z))) - y * ((                 cos(obj_rad_y) *                                     sin(obj_rad_z))) - z * (                 sin(obj_rad_y));
            End.y = x * ((cos(obj_rad_x) * sin(obj_rad_z)) - (sin(obj_rad_x) * sin(obj_rad_y) * cos(obj_rad_z))) + y * ((sin(obj_rad_x) * sin(obj_rad_y) * sin(obj_rad_z)) + (cos(obj_rad_x) * cos(obj_rad_z))) - z * (sin(obj_rad_x) * cos(obj_rad_y));
            End.z = x * ((cos(obj_rad_x) * sin(obj_rad_y) * cos(obj_rad_z)) + (sin(obj_rad_x) * sin(obj_rad_z))) + y * ((sin(obj_rad_x) * cos(obj_rad_z)) - (cos(obj_rad_x) * sin(obj_rad_y) * sin(obj_rad_z))) + z * (cos(obj_rad_x) * cos(obj_rad_y));
     
        x = End.x
        y = End.y
        z = End.z
     
    - J'additionne le vecteur sortie avec un autre vecteur appeler obj_repere[4]
    - Camera_Management:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    - J'additionne le vecteur avec un vecteur appeler world_repere[4]
     
    - Je soustrais le vecteur avec un vecteur appeler cam_repere[4]
     
    - Je passe ce vecteur à travers mes equations de rotations une nouvelle fois:
     
        cam_rad_x = cam_rad_x * -1;
        cam_rad_y = cam_rad_y * -1;
        cam_rad_z = cam_rad_z * -1;
     
    	// Rotate xyz order matrix
            End.x = x * ((cos(cam_rad_y) *                                                      cos(cam_rad_z))) - y * ((                 cos(cam_rad_y) *                                     sin(cam_rad_z))) - z * (                 sin(cam_rad_y));
            End.y = x * ((cos(cam_rad_x) * sin(cam_rad_z)) - (sin(cam_rad_x) * sin(cam_rad_y) * cos(cam_rad_z))) + y * ((sin(cam_rad_x) * sin(cam_rad_y) * sin(cam_rad_z)) + (cos(cam_rad_x) * cos(cam_rad_z))) - z * (sin(cam_rad_x) * cos(cam_rad_y));
            End.z = x * ((cos(cam_rad_x) * sin(cam_rad_y) * cos(cam_rad_z)) + (sin(cam_rad_x) * sin(cam_rad_z))) + y * ((sin(cam_rad_x) * cos(cam_rad_z)) - (cos(cam_rad_x) * sin(cam_rad_y) * sin(cam_rad_z))) + z * (cos(cam_rad_x) * cos(cam_rad_y));
     
        x = End.x
        y = End.y
        z = End.z
     
    - Je soustrais le vecteur avec un vecteur appeler cam_position[4]
    - Screen_Management :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    - Je place ce vecteur dans un tableaux grâce à l'equation, puis je l'affiche, comme une image:
     
        z = z * -1;
        x = (x * distance) / z
        y = (y * distance) / z
     
        screen[repere - ((x * bpp) + (pitch * y))] = color      ; bpp = 4 (bytes_per_pixel), 32 (bits_per_pixel) . pitch = screen_y (y resolution of image) * bpp
                                                                ; repere = (screen_x * (screen_y - 1)) + ((screen_x / 2) - 1);
    Dernière modification par Invité ; 22/04/2015 à 14h05.

  9. #9
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    mai 2008
    Messages
    24 370
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : mai 2008
    Messages : 24 370
    Points : 178 871
    Points
    178 871
    Billets dans le blog
    49

    Par défaut

    Et ça marche ?
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  10. #10
    Invité
    Invité(e)

    Par défaut

    Non, par contre j'ai corrigé le fait qu'il fallait prendre l'équation XYZ du produit matriciel mat.X * mat.Y * mat.Z, car j'ai remarqué qu'en faisait une série de transformation 2D, ça ne prenait pas en compte toutes les rotations:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
     
        // Rotate order by XYZ for: X/Z rotate
        // XYZ:
            // X-axe
                obj[_y] = (obj[_y] * obj_cos.v[_x]) - (obj[_z] * obj_sin.v[_x]);
                obj[_z] = (obj[_z] * obj_cos.v[_x]) + (obj[_y] * obj_sin.v[_x]);
     
            // Y-axe
                obj[_x] = (obj[_x] * obj_cos.v[_y]) - (obj[_z] * obj_sin.v[_y]);
                obj_end[_z] = (obj[_z] * obj_cos.v[_y]) + (obj[_x] * obj_sin.v[_y]);
     
            // Z-axe
                obj_end[_x] = (obj[_x] * obj_cos.v[_z]) - (obj[_y] * obj_sin.v[_z]);
                obj_end[_y] = (obj[_y] * obj_cos.v[_z]) + (obj[_x] * obj_sin.v[_z]);
     
        // Rotate order by ZYX for: X/Y rotate
        // ZYX:
            // Z-axe
                obj[_x]     = (obj[_x] * obj_cos.v[_z]) - (obj[_y] * obj_sin.v[_z]);
                obj[_y]     = (obj[_y] * obj_cos.v[_z]) + (obj[_x] * obj_sin.v[_z]);
     
            // Y-axe
                obj_end[_x] = (obj[_x] * obj_cos.v[_y]) - (obj[_z] * obj_sin.v[_y]);
                obj[_z]     = (obj[_z] * obj_cos.v[_y]) + (obj[_x] * obj_sin.v[_y]);
     
            // X-axe
                obj_end[_y] = (obj[_y] * obj_cos.v[_x]) - (obj[_z] * obj_sin.v[_x]);
                obj_end[_z] = (obj[_z] * obj_cos.v[_x]) + (obj[_y] * obj_sin.v[_x]);
    Et même en les assemblant, ça ne marche pas
    Dernière modification par Invité ; 22/04/2015 à 14h19.

  11. #11
    Invité
    Invité(e)

    Par défaut Résolu mais bug restant

    - Bon j'ai enfin trouvé, il faut juste ajouter une nouvelle rotation XYZ et le multiplier par le vecteur repere_cam:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
     
        cam_rad[_x] *= -1;
        cam_rad[_y] *= -1;
        cam_rad[_z] *= -1;
     
        cos_x = cos(cam_rad[_x])
        cos_y = cos(cam_rad[_y])
        cos_z = cos(cam_rad[_z])
     
        sin_x = sin(cam_rad[_x])
        sin_y = sin(cam_rad[_y])
        sin_z = sin(cam_rad[_z])
     
        end[_x] = (repere_cam[_x] *   cos_y *                           cos_z  ) - (repere_cam[_y] *   cos_y *                           sin_z  ) - ((repere_cam[_z] *          sin_y )
        end[_y] = (repere_cam[_x] * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (repere_cam[_y] * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - ((repere_cam[_z] * (sin_x * cos_y))
        end[_z] = (repere_cam[_x] * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (repere_cam[_y] * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + ((repere_cam[_z] * (cos_x * cos_y))
    - Mais comme on as 3 types de déplacement unique (les mélanger ne marchent pas) sur chaque axes:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
        - right    -> repere_cam.add( 1,  0,  0)
        - left     -> repere_cam.add(-1,  0,  0)
     
        - up       -> repere_cam.add( 0,  1,  0)
        - down     -> repere_cam.add( 0, -1,  0)
     
        - forward  -> repere_cam.add( 0,  0,  1)
        - backward -> repere_cam.add( 0,  0, -1)
    - On décortique la fonction de rotation en 3 sous-fonctions:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
     
        // vector right/left
                                                                                                     0                                                                0
           .---< cam_y[_x] = (repere_cam[_x] *   cos_y *                           cos_z  ) - (repere_cam[_y] *   cos_y *                           sin_z  ) - (repere_cam[_z] *          sin_y )
           |.--< cam_y[_y] = (repere_cam[_x] * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (repere_cam[_y] * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (repere_cam[_z] * (sin_x * cos_y))
           ||.-< cam_y[_z] = (repere_cam[_x] * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (repere_cam[_y] * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (repere_cam[_z] * (cos_x * cos_y))
           |||
           |||
           ||.-> cam_y[_x] = (repere_cam[_x] *   cos_y *                           cos_z  )
           |.--> cam_y[_y] = (repere_cam[_x] * ((cos_x * sin_z) - (sin_x * sin_y * cos_z)))
           .---> cam_y[_z] = (repere_cam[_x] * ((cos_x * sin_y * cos_z) + (sin_x * sin_z)))
     
        // vector up/down
                                    0                                                                                                                                 0
           .---< cam_x[_x] = (repere_cam[_x] *   cos_y *                           cos_z  ) - (repere_cam[_y] *   cos_y *                           sin_z  ) - (repere_cam[_z] *          sin_y )
           |.--< cam_x[_y] = (repere_cam[_x] * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (repere_cam[_y] * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (repere_cam[_z] * (sin_x * cos_y))
           ||.-< cam_x[_z] = (repere_cam[_x] * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (repere_cam[_y] * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (repere_cam[_z] * (cos_x * cos_y))
           |||
           |||
           ||.-> cam_x[_x] = (repere_cam[_y] *   cos_y *                           sin_z  )
           |.--> cam_x[_y] = (repere_cam[_y] * ((sin_x * sin_y * sin_z) + (cos_x * cos_z)))
           .---> cam_x[_z] = (repere_cam[_y] * ((sin_x * cos_z) - (cos_x * sin_y * sin_z)))
     
        // vector forward/backward
                                    0                                                                0
           .---< cam_z[_x] = (repere_cam[_x] *   cos_y *                           cos_z  ) - (repere_cam[_y] *   cos_y *                           sin_z  ) - (repere_cam[_z] *          sin_y )
           |.--< cam_z[_y] = (repere_cam[_x] * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (repere_cam[_y] * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (repere_cam[_z] * (sin_x * cos_y))
           ||.-< cam_z[_z] = (repere_cam[_x] * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (repere_cam[_y] * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (repere_cam[_z] * (cos_x * cos_y))
           |||
           |||
           ||.-> cam_z[_x] = (repere_cam[_z] *          sin_y )
           |.--> cam_z[_y] = (repere_cam[_z] * (sin_x * cos_y))
           .---> cam_z[_z] = (repere_cam[_z] * (cos_x * cos_y))
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
     
        (On peut aussi y inclure la vitesse de déplacement de la caméra)
        // vector right/left
           cam_y[_x] = speed_cam * (repere_cam[_x] *   cos_y *                           cos_z  )
           cam_y[_y] = speed_cam * (repere_cam[_x] * ((cos_x * sin_z) - (sin_x * sin_y * cos_z)))
           cam_y[_z] = speed_cam * (repere_cam[_x] * ((cos_x * sin_y * cos_z) + (sin_x * sin_z)))
     
        // vector up/down
           cam_x[_x] = speed_cam * (repere_cam[_y] *   cos_y *                           sin_z  )
           cam_x[_y] = speed_cam * (repere_cam[_y] * ((sin_x * sin_y * sin_z) + (cos_x * cos_z)))
           cam_x[_z] = speed_cam * (repere_cam[_y] * ((sin_x * cos_z) - (cos_x * sin_y * sin_z)))
     
        // vector forward/backward
           cam_z[_x] = speed_cam * (repere_cam[_z] *          sin_y )
           cam_z[_y] = speed_cam * (repere_cam[_z] * (sin_x * cos_y))
           cam_z[_z] = speed_cam * (repere_cam[_z] * (cos_x * cos_y))
    - Puis, une fois qu'on a les 3 vecteurs caméra opérationnelles, on choisit lequel a additionner au vecteur repère.
    vu que si on veut pouvoir avancer sur l'axe z avec une rotation de caméra, on ne peut avancer que sur l'axe Z du monde.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
     
        Exemple:
            touche 'Z':		// Moving Forward
            {
                repere_cam[_x] += cam_z[_x]
                repere_cam[_y] += cam_z[_y]
                repere_cam[_z] += cam_z[_z]
            }
     
            touche 'S':		// Moving Backward
            {
                repere_cam[_x] -= cam_z[_x]
                repere_cam[_y] -= cam_z[_y]
                repere_cam[_z] -= cam_z[_z]
            }
     
            touche 'D':		// Moving Right
            {
                repere_cam[_x] += cam_x[_x]
                repere_cam[_y] += cam_x[_y]
                repere_cam[_z] += cam_x[_z]
            }
     
            touche 'Q':		// Moving Left
            {
                repere_cam[_x] -= cam_x[_x]
                repere_cam[_y] -= cam_x[_y]
                repere_cam[_z] -= cam_x[_z]
            }
     
            touche 'A':		// Moving Up
            {
                repere_cam[_x] += cam_y[_x]
                repere_cam[_y] += cam_y[_y]
                repere_cam[_z] += cam_y[_z]
            }
     
            touche 'E':		// Moving Down
            {
                repere_cam[_x] -= cam_y[_x]
                repere_cam[_y] -= cam_y[_y]
                repere_cam[_z] -= cam_y[_z]
            }
    - C'est tout, par contre ça ne marche pas correctement pour certaines configurations d'angle.

    Ansi, voilà tout l'algo final (buggé):

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    (les variables utilisés sont des vecteurs 3D float: point, new,
                                                        obj_position, obj_repere
                                                        obj_rad, cam_rad,
                                                        world_repere,
                                                        repere_cam, cam_position,
                                                        cam_x, cam_y, cam_z,
                                                        cos_x, cos_y, cos_z,
                                                        sin_x, sin_y, sin_z
     et un entier speed_cam)
    - Au départ, j'ai un vecteur point correspondant à un point de mon objet.

    - Object_Management:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
     
        - J'additionne ce vecteur avec obj_position[].
     
        - Puis, je le passe à travers mes équations de rotations:
     
            cos_x = cos(obj_rad[_x])
            cos_y = cos(obj_rad[_y])
            cos_z = cos(obj_rad[_z])
     
            sin_x = sin(obj_rad[_x])
            sin_y = sin(obj_rad[_y])
            sin_z = sin(obj_rad[_z])
     
            // Rotate xyz order matrix
                new[_x] = (point[_x] *   cos_y *                           cos_z  ) - (point[_y] *   cos_y *                           sin_z  ) - (point[_z] *          sin_y )
                new[_y] = (point[_x] * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (point[_y] * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (point[_z] * (sin_x * cos_y))
                new[_z] = (point[_x] * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (point[_y] * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (point[_z] * (cos_x * cos_y))
     
            point[_x] = new[_x]
            point[_y] = new[_y]
            point[_z] = new[_z]
     
        - J'additionne le vecteur sortie avec obj_repere[].
    - Je l'additionne avec world_repere[].

    - Camera_Management:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
     
     
        cos_x = cos(-cam_rad[_x])
        cos_y = cos(-cam_rad[_y])
        cos_z = cos(-cam_rad[_z])
     
        sin_x = sin(-cam_rad[_x])
        sin_y = sin(-cam_rad[_y])
        sin_z = sin(-cam_rad[_z])
     
        // vector right/left
           cam_y[_x] = speed_cam * (  cos_y *                           cos_z  )
           cam_y[_y] = speed_cam * (((cos_x * sin_z) - (sin_x * sin_y * cos_z)))
           cam_y[_z] = speed_cam * (((cos_x * sin_y * cos_z) + (sin_x * sin_z)))
     
        // vector up/down
           cam_x[_x] = speed_cam * (  cos_y *                           sin_z  )
           cam_x[_y] = speed_cam * (((sin_x * sin_y * sin_z) + (cos_x * cos_z)))
           cam_x[_z] = speed_cam * (((sin_x * cos_z) - (cos_x * sin_y * sin_z)))
     
        // vector forward/backward
           cam_z[_x] = speed_cam * (         sin_y )
           cam_z[_y] = speed_cam * ((sin_x * cos_y))
           cam_z[_z] = speed_cam * ((cos_x * cos_y))
     
        Exemple:
            touche 'Z':		// Moving Forward
            {
                repere_cam[_x] += cam_z[_x]
                repere_cam[_y] += cam_z[_y]
                repere_cam[_z] += cam_z[_z]
            }
     
            touche 'S':		// Moving Backward
            {
                repere_cam[_x] -= cam_z[_x]
                repere_cam[_y] -= cam_z[_y]
                repere_cam[_z] -= cam_z[_z]
            }
     
            touche 'D':		// Moving Right
            {
                repere_cam[_x] += cam_x[_x]
                repere_cam[_y] += cam_x[_y]
                repere_cam[_z] += cam_x[_z]
            }
     
            touche 'Q':		// Moving Left
            {
                repere_cam[_x] -= cam_x[_x]
                repere_cam[_y] -= cam_x[_y]
                repere_cam[_z] -= cam_x[_z]
            }
     
            touche 'A':		// Moving Up
            {
                repere_cam[_x] += cam_y[_x]
                repere_cam[_y] += cam_y[_y]
                repere_cam[_z] += cam_y[_z]
            }
     
            touche 'E':		// Moving Down
            {
                repere_cam[_x] -= cam_y[_x]
                repere_cam[_y] -= cam_y[_y]
                repere_cam[_z] -= cam_y[_z]
            }
     
        - Je le soustrais avec cam_repere[].
     
        - Je le passe une nouvelle fois à travers mes equations de rotations :
     
            // Rotate xyz order matrix
                new[_x] = (point[_x] *   cos_y *                           cos_z  ) - (point[_y] *   cos_y *                           sin_z  ) - (point[_z] *          sin_y )
                new[_y] = (point[_x] * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (point[_y] * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (point[_z] * (sin_x * cos_y))
                new[_z] = (point[_x] * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (point[_y] * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (point[_z] * (cos_x * cos_y))
     
            point[_x] = new[_x]
            point[_y] = new[_y]
            point[_z] = new[_z]
     
        - Je soustrais point[] avec cam_position[].
    - Screen_Management :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
     
        - Je place ce vecteur dans un tableaux grâce à l'equation, puis je l'affiche, comme une image:
     
            point[_x] = ((point[_x] * distance) / -point[_z])
            point[_y] = ((point[_y] * distance) / -point[_z])
     
        screen[repere - ((point[_x] * bpp) + (pitch * point[_y]))] = color(0xAARGB) ; bpp = 4 (bytes_per_pixel), 32 (bits_per_pixel) . pitch = screen_y (y resolution of image) * bpp
                                                                                    ; repere = (screen_x * (screen_y - 1)) + ((screen_x / 2) - 1)
    Dernière modification par Invité ; 30/04/2015 à 18h47.

  12. #12
    Invité
    Invité(e)

    Par défaut

    Mince j'ai oublié de dire le bug ...

    Bon alors le bug se trouve dans le déplacement des 3 axes (left/right - down/up - backward/forward) de déplacements de la caméra.

    Lors de l'initialisation de la scène, les déplacements fonctionnent, mais à un moment T (déplacement/rotation prolongé) la translation de la caméra est complètement faussée: inversion du bas/haut gauche/droite, mouvement bloquer, très problématique ^^
    Dernière modification par Invité ; 03/06/2015 à 14h13.

  13. #13
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    mai 2008
    Messages
    24 370
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : mai 2008
    Messages : 24 370
    Points : 178 871
    Points
    178 871
    Billets dans le blog
    49

    Par défaut

    N'est ce pas une fois que vous faites un 180 ° de rotation sur un des axes ?
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  14. #14
    Invité
    Invité(e)

    Par défaut

    Surement, si je fais de petites rotations de la caméra, le mouvement n'est pas bugé.

  15. #15
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2014
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 24
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2014
    Messages : 10
    Points : 21
    Points
    21

    Par défaut

    Blocage de Cardan?

  16. #16
    Invité
    Invité(e)

    Par défaut

    Pour le problème le blocage du mouvement de la caméra, peut-être, mais l'inversion des sens des vecteurs, je sais pas.
    Dernière modification par Invité ; 03/06/2015 à 14h53.

  17. #17
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    mai 2008
    Messages
    24 370
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : mai 2008
    Messages : 24 370
    Points : 178 871
    Points
    178 871
    Billets dans le blog
    49

    Par défaut

    Soit, la caméra à la tête vers le bas. Cela peux faire une première inversion. Sinon, surement que vous n'appliquez pas le vecteur "forward" ou qu'il n'est pas mis à jour.
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  18. #18
    Invité
    Invité(e)

    Par défaut

    J'ai déjà essayé de faire un looping sur l'axe Z avec ma caméra et le vecteur sur z est inversé et oui je le mets à jour comme le vecteur sur x et y, mais peut-être qu'il faudra que je complète les calculs pour gérer ces "exceptions".
    Dernière modification par Invité ; 04/06/2015 à 02h03.

Discussions similaires

  1. [Graphes] Algorithme pour transformer un graphe en graphe fortement connexe
    Par pikachu56 dans le forum Algorithmes et structures de données
    Réponses: 2
    Dernier message: 23/11/2011, 01h08
  2. Réponses: 7
    Dernier message: 19/02/2010, 09h42
  3. Réponses: 5
    Dernier message: 23/04/2009, 15h21
  4. Problème lors de la transformation de mon "algorithm&qu
    Par prunodagen dans le forum Langage SQL
    Réponses: 8
    Dernier message: 27/04/2005, 21h48

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo