Algorithme de transformation 3D

Version imprimable

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 :aie:.

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:

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:

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:

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.

13/04/2015, 10h45
LittleWhite

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.
13/04/2015, 12h35
Invité

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 :aie:

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

- 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 (:aie:), 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.
13/04/2015, 13h44
LittleWhite

Dommage, j'ai Linux :D
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.
13/04/2015, 14h56
Invité

Pas de problème, merci quant même ^^
13/04/2015, 19h21
LeGreg

Citation:

Envoyé par glojii

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 :aie:.

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..)
13/04/2015, 19h58
Invité

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

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 :aie: (comme un scope comme dans les fps (lunettes de visée)))

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:

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:

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:

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);

20/04/2015, 09h58
LittleWhite

Et ça marche ?

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:

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 :aie:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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)

03/06/2015, 10h04
Invité

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 ^^
03/06/2015, 13h36
LittleWhite

N'est ce pas une fois que vous faites un 180 ° de rotation sur un des axes ?
03/06/2015, 14h11
Invité

Surement, si je fais de petites rotations de la caméra, le mouvement n'est pas bugé.
03/06/2015, 14h18
qnope

Blocage de Cardan?
03/06/2015, 14h41
Invité

Pour le problème le blocage du mouvement de la caméra, peut-être, mais l'inversion des sens des vecteurs, je sais pas.
03/06/2015, 20h25
LittleWhite

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.
04/06/2015, 00h35
Invité

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".