Discussion :

[noals]

salut,

j'essaye de faire de la génération procédurale de donjon en 3D mais j'ai un peu de mal à trouver le bon algorithme pour calculer les rotations.

en gros j'ai ça :

deux modules A et B qui comprennent chacun plusieurs sorties.
une sortie de A et une sortie de B sont sélectionnées aléatoirement et je cherche comment calculer la rotation que le module B devra effectuer pour que sa sortie sélectionnée corresponde avec la sortie sélectionnée du module B.
par exemple si la sortie de A est 90°, il faut que B tourne ou reste immobile pour que sa sortie devienne -90°

j'utilise des angles d'euler parce que je ne comprends pas bien comment utiliser les quaternions mais je ne suis pas contre des explications parce qu'il me semble que cela faciliterait mon problème, j'ai lu quelque part qu'il n'y avait pas de limitation à 180 ou un truc dans le genre avec les quaternion.
et pour ce qui est de la disposition des angles, ce sont les valeurs qui me sont retournés dans le moteur. j'utilise urho3d donc ça sera en c++.

j'ai essayé quelque truc avec mon programme mais comme ça fonctionnait bien une fois sur deux, je préfère ne pas mettre de code.
j'ai déjà écrit le code pour calculer ensuite la position mais si je n'ai pas la bonne rotation, mon calcul est faussé car la position des sorties changent avec la rotation.

je sais que ce n'est pas un calcul très complexe mais j'ai un peu de mal avec l'abstraction, quelqu'un peut-il m'expliquer comment faire ?

merci.

[Flodelarab]

Bonjour

Déjà, tu devrais supprimé les angles négatifs pour être entre 0° et 360°. Donc -90 devient 270.
Cela permet de faire un modulo si tu es au dessus de 360°.

Ensuite, c'est quoi le problème ?
Les sorties indiquées sont justement le nombre de degrés dont il faut tourner la pièce pour arriver à être en face.

[noals]

Déjà, tu devrais supprimé les angles négatifs pour être entre 0° et 360°. Donc -90 devient 270.
Cela permet de faire un modulo si tu es au dessus de 360°.

j'pensais utiliser les 360° au début mais c'est en convertissant les quaternion en angle euler et en regardant les valeurs du programme que j'me suis rendu compte qu'il les convertissait de cette façon avec 0, 90, -90, etc... et j'essaye de m'en sortir avec ça du coup.

Ensuite, c'est quoi le problème ?
Les sorties indiquées sont justement le nombre de degrés dont il faut tourner la pièce pour arriver à être en face.

il faut que je prenne en compte les deux angles des deux sorties sélectionnées pour calculer la rotation du module B pour que sa sortie corresponde avec la sortie du module A.

j'm'y perd un peu avec mes variables, les +, les -, j'vais faire d'autres tests avec mon programme.
ça devrait etre un truc dans le genre je crois :

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
if(sortie_B.rotation>=0)
{
    sortie_A.rotation.y_ - (180 - sortie_B.rotation.y_);
}
else
{
    sortie_A.rotation.y_ - (180 - sortie_B.rotation.y_ * (-1));
}

mais il me semble que j'oublie des cas particuliers là.

[noals]

non ben j'sais pas, je sais que c'est un problème tout con mais mon cerveau fait un blocage la dessus ><

j'me retrouve avec ce genre de résultat :

donc même mon placement n'est pas bon parce que si la rotation est bonne, la sortie se retrouve dans le vide.

Code c :

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
//calculate new rotation of module with e_connector and m_connector
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
 
        rotation.x_ = 0;
        rotation.z_ = 0;
 
        if(m_connector.rotation.y_ >= 0)
        {
            e_connector.rotation.y_ - (180 - m_connector.rotation.y_);
        }
        else
        {
            e_connector.rotation.y_ - (180 - m_connector.rotation.y_ * (-1));
        }
 
        temp_Qrot = Vec2Quat(rotation);
        moduleNode->SetWorldRotation(temp_Qrot);
 
 
//calculate new position of module with e_connector and m_connector
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
 
//get choosen module exit node to have the updated position !!
        exit_child_name = stringInt ("exit", randomConnectorNbr);                            
        exit_name_urho = string2urhoString(exit_child_name);
        exitNode = moduleNode->GetChild(exit_name_urho, true);
 
        m_connector.position=exitNode->GetWorldPosition();   // position !!
        //m_connector.relative_pos=exitNode->GetPosition();    // relative_pos   !!  
 
 
        if(e_connector.position.x_>=0)
        {
            if(m_connector.position.x_>=0)
            {
                position.x_ = m_connector.position.x_ + e_connector.position.x_;
            }
            else
            {
                position.x_ = (m_connector.position.x_ * (-1)) + e_connector.position.x_;
            }
        }
        else
        {
            if(m_connector.position.x_>=0)
            {
                position.x_ = (m_connector.position.x_ * (-1)) + e_connector.position.x_;
            }
            else
            {
                position.x_ = m_connector.position.x_ + e_connector.position.x_;
            }
        }
 
        if(e_connector.position.z_>=0)
        {
            if(m_connector.position.z_>=0)
            {
                position.z_ = m_connector.position.z_ + e_connector.position.z_;
            }
            else
            {
                position.z_ = (m_connector.position.z_ * (-1)) + e_connector.position.z_;
            }
        }
        else
        {
            if(m_connector.position.z_>=0)
            {
                position.z_ = (m_connector.position.z_ * (-1)) + e_connector.position.z_;
            }
            else
            {
                position.z_ = m_connector.position.z_ + e_connector.position.z_;
            }
        }
 
 
        if(e_connector.position.y_>=0)
        {
            if(m_connector.position.y_>=0)
            {
                position.y_ = e_connector.position.y_ + m_connector.position.y_;
            }
            else
            {
                position.y_ = e_connector.position.y_ + (m_connector.position.y_ * (-1));
            }
         }
         else
         {
            if(m_connector.position.y_>=0)
            {
                position.y_ = e_connector.position.y_ + (m_connector.position.y_ * (-1));
            }
            else
            {
                position.y_ = e_connector.position.y_ + m_connector.position.y_;
            }
         }
 
        moduleNode->SetWorldPosition(position);

je vais essayer de mieux poser le problème textuellement parce que j'ai vraiment du mal à imprimer là.


en fait j'ai une liste des exits, une exit est choisi au hazard, c'est mon e_connector.
ensuite je charge un nouveau module en position ZERO qui comprend x exits.
je stocke les exits (type, pos, rot, etc..) dans une liste d'exits qui fait partie de ma classe module et j'en choisi une au hazard, m_connector.
mon but est donc de faire correspondre l'exit du module à l'exit de la liste.
pour se faire, je dois d’abord faire tourner mon module pour que la rotation de son exit soit l'inverse de la rotation de l'exit de la liste.

ha, ben ça vient de me donner une idée. avec urho3D, j'ai une fonction :

RotateAround (const Vector3 &point, const Quaternion &delta, TransformSpace space=TS_LOCAL)
Rotate around a point in the chosen transform space.

avec ça, je devrait pouvoir faire du m_connector le centre de rotation de mon module pour que m_connector.rotation.y_ == e_connector.rotation.y_ * (-1) avec comme cas particuliers si 0° ou 180°

euh.. non en fait.
j'm'embrouille avec les rotation des exits relative au module et les "world" rotation des exits et des modules.

je vais refaire d'autre test avec mon programme pour bien voir les valeurs qui me sont retourné, j'fais vraiment un blocage avec cette connerie, c'est frustrant.

[noals]

je crois que même mon calcul des position n'est pas bon, j'ai beau essayer de différentes manière, j'arrive toujours à peu prêt au même résultat.
y'aurait pas une meilleur méthode pour faire ça ? j'm'y perd vraiment avec les positions et rotations relatives et globales.

il me semble que juste ça, c'est bon pour les rotation :

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

rotation.y_ = e_connector.rotation.y_ - (180 - m_connector.rotation.y_);

mais comme ça remarche encore une fois sur deux et que ça peut être à cause de la rotation ou de la position, j'arrive pas à bien cibler le problème.
franchement, si quelqu'un pouvait m'éclaircir ou proposer une autre méthode ça serait sympa.

[noals]

bon, j'ai vérifié mes valeurs.
entre blender et urho3D, j'm'étais un peu perdu dans les axes je crois.


je dois donc utiliser le z de la rotation local de mes exits pour l'angle, x et z de la position global pour les coordonnés et y de la position global pour la hauteur.
(en sachant que je dois appliquer la rotation sur l'axe des Y pour ce qui est du module si je ne m'abuse)

ça devrait peut-être fonctionner un peu mieux comme ça... ><

[noals]

je vais essayer de loader des points de repère dans mon programme pour avoir un visuel des exits choisies parce que j'ai beau essayer dans pas mal de sens différents calculs, y'a pas l'air d'en avoir un qui convient.
j'ai besoin d'un visuel pour comprendre ce qui se passe avec mes calculs.

[noals]

c'est jolie à l'écran mais pour l'instant, je comprends surtout que tous mes calculs sont mauvais lol.

[noals]

je ne sais pas pourquoi le sujet avait le statut "résolu" mais non, mon problème n'est pas résolu (j'ai p-e appuyé dessus par mégarde, je ne sais pas) et je commence à être à cour d'idée.

pour me simplifier la tache, j'ai eu l'idée de faire ma rotation en deux fois.


1/ faire tourner le module pour que sont exit soit toujours avec une rotation de 0°
donc ça apparement, ça marche bien, mon point rouge pointe toujours vers le "nord"

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
 
 
        if(m_connector.rotation.z_==0||m_connector.rotation.z_==(-0))
        {
            moduleNode->Yaw(0);
        }
        else
        {
            moduleNode->Yaw(-m_connector.rotation.z_);
        }

2/ et donc ensuite simplement, faire tourner le module de la rotation inverse de l'autre exit selectionnée
mais encore une fois, ça marche une fois sur deux

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
        if(e_connector.rotation.z_==0||m_connector.rotation.z_==(-0))
        {
            moduleNode->Yaw(180);
        }
        else
        {
            moduleNode->Yaw(-e_connector.rotation.z_);
        }

donc peut-être que la fonction Yaw ne gère pas les rotation de la même manière que mes valeurs retournées par la conversion des quaternions.
donc peut-être que c'est là que j'devrais convertir mes valeurs négative de manière à ce qu'elle soient entre 0 et 360 mais ça me parait bizarre; je vais essayé la prochaine fois, je verrai bien.

[noals]

bon ben j'ai compris mon problème, ça n'a rien à voir avec mes calculs en fait.

il se trouve que quand les bones de l'armature de mes models ne sont pas droit ou un truc dans le genre, ça ne me donne pas les bon angles dans mon programme.


j'ai testé avec un angle de 45° qui est volontaire, ça me renvoie un autre angle et donc ça fausse mes calculs.



'fin bon, ça me rassure, y'a pas que du brun dans mes calculs parce que je commencais à avoir des doute sur les capacités de mon cerveau à résonner de manière logique lol.
il faut que je trouve une manière plus fiable d'avoir l'angle de mes sorties, j'vais essayer de voir ça sur le forum de urho3D.


sujet résolu en quelque sorte.. ><




edit: je devrais p-e pouvoir calculer l'angle en fonction des positions remarque, aahhh les maths.... ^^;

[Flodelarab]

Es-tu sûr que les angles sont en degrés et pas en radians (ou autres) ?

C'est tout de même bizarre que le logiciel change tes angles. Tu devrais trouver la source.

[noals]

mes rotations sont des quaternions à la base et ils sont convertis en degree avec EulerAngles()

Vector3 EulerAngles () const
Return Euler angles in degrees.

http://urho3d.github.io/documentatio...uaternion.html
j'ai aussi un problème un peu dans le même genre avec mes positions en fait, je ne sais pas trop d'où ça vient, j'ai souvent des Xe-26 ou dans le genre alors que ma valeur doit être 0 par exemple mais concrètement ça n'a pas l'air de changer grand chose.
c'est peut-être une erreur dans le moteur, de gestion des .mdl ou un problème avec l'exporter blender, j'sais pas trop. je le signalerai par la suite sur le forum de urho3D plus tard, j'préfère me concentrer sur ce qui m'a l'air de fonctionner pour l'instant. urho3D est open source.


je suis en train d'essayer une autre méthode avec atan2 en espérant que de cette manière, je n'aurai pas de problème gênant de précision.

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
float getAngle(float x_, float z_)
{
    const double PI = atan(1.0)*4;
    float angleRadian = atan2(0,1)-atan2(x_,z_);
    float angleDegree = angleRadian*180 /PI;
    return angleDegree;
}

[noals]

bon ben mon calcul avec atan n'est pas bon non plus apparement.



quelqu'un pourrait corriger ma fonction vite fait ? j'aimerai bien pouvoir avancer un jour... ça fait plus d'une semaine que j'me prend la tête avec ces P... d'angles.

[bertry]

Salut,
Il me semble qu'il y a une erreur de signe dans ta fonction. Il faut permuter les deux termes lors du calcul de angleRadian pour aller de PI/2 vers atan2(x_,z_) dans le sens trigo:

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
float getAngle(float x_, float z_)
{
    const double PI = atan(1.0)*4;
    float angleRadian = atan2(x_,z_)-atan2(0,1); // permutation de deux termes pour avoir le bon signe
    float angleDegree = angleRadian*180 /PI;
    return angleDegree;
}

Il faudrait aussi limiter les valeurs de retour à [-180°, 180°] ou à [0°, 360°]

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
const double MINI = -180;
const double MAXI = 180;
if( angleDegree < MINI ) return angleDegree+360;
else if( angleDegree > MAXI ) return angleDegree-360;
return angleDegree;

[noals]

merci d'avoir répondu mais non, même pas.
ça donne le même résultat en gros.

Code c++ :

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
 
        Node* moduleNode;
        moduleNode=my_scene->CreateChild("test");
        moduleNode->SetWorldPosition(Vector3::ZERO);             
        moduleNode->SetWorldRotation(Quaternion::IDENTITY);   //(1,0,0,0) 
 
        AnimatedModel* m_Object=moduleNode->CreateComponent<AnimatedModel>();
        m_Object->SetModel(cache->GetResource<Model>("Models/cor2.mdl"));
        m_Object->SetMaterial(cache->GetResource<Material>("Materials/blank.xml"));
 
        Node* e0 = moduleNode->GetChild("exit0", true);
        Node* e1 = moduleNode->GetChild("exit1", true);
 
        Vector3 p0 = e0->GetWorldPosition();   // position !! 
        float a0 = getAngle(p0.x_, p0.z_);   //angle !!
 
        Vector3 p1 = e1->GetWorldPosition();   // position !! 
        float a1 = getAngle(p1.x_, p1.z_);   //angle !!

Code c++ :

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
 
float getAngle(float x_, float z_)
{
 
    const double MINI = -180;
    const double MAXI = 180;
 
    const double PI = atan(1.0)*4;
    float angleRadian = atan2(x_,z_)-atan2(0,1);
    float angleDegree = angleRadian*180 /PI;
 
 
    if( angleDegree < MINI )
    {
        return angleDegree+360;
    }
    else if( angleDegree > MAXI ) 
    {
        return angleDegree-360;
    }
    else
    {
        return angleDegree;
    }
}

c'est peut-être un autre problème avec le .mdl, j'sais pas du tout, pour moi ça n'a aucun sens. je vais demander sur le forum urho3D, peut-être qu'ils arriveront à cibler le problème parce que c'est la troisième méthodes que j'essaye et j'en suis toujours au même point.

[anapurna]

salut


pour connaitre l'angle entre deux point la formule est

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
 
degrees(aval)
debut
  return aval * (180 / PI)
Fin 
 
GetAngleBetweenTwoPoints(p1, p2): 
debut
  xDiff = p2.x - p1.x 
  yDiff = p2.y - p1.y 
  deg = degrees(atan2(yDiff, xDiff)) 
  SI (deg < 0) 
    deg = deg+ 360; 
  return deg
fin

dans ton cas si j'ai bien compris tu a un point fixe en 0,0
ce qui devrais te donner

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
  P1.x = 0   et p1.y = 0
  P2.x = _x et p1.y = _z
  deg = GetAngleBetweenTwoPoints(p1, p2)

[noals]

merci de ta réponse mais ça ne change rien.
j'essaye de comprendre un peu mieux atan2 avec wiki https://fr.wikipedia.org/wiki/Atan2 mais avec les essaie que je fais, il me donne la même valeur et le même signe pour les deux angles et c'est pas normal de mon point de vue mais ça vient peut-être du fait que je ne prends pas en compte les cadrans dans lequel mon angle se situe.

Notez que l'ordre des arguments est inversé; la fonction atan2(y,x) donne l'angle correspondant au point (x,y).

si j'en crois le shéma (et si mes arguments sont dans le bon ordre)
mon atan2(z=1,x=0) correspond au (1,0) de la fonction
mon atan2(z=0,x=-10) correspond au (0,1) ou (0,-1)
mon atan2(z=-10,x=0) correspond au (-1,0)

et donc j'obtient ls bon angles avec

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
        float test1 = atan2(0,-10)*180/( atan(1.0)*4 );
        float test2 = atan2(-10, 0)*180/( atan(1.0)*4 );

et je viens de tester, ça à l'air de marcher aussi avec les points qui n'ont pas de valeurs égal à 0.

et donc pour tester :

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
float getAngle(float x_, float z_)
{
 
    float angle = atan2(z_, x_)* 180/( atan(1.0)*4 );
    return angle;
 
}

mais c'est là où je comprend plus parce que ça fonctionne bien dans mon main.cpp mais ça ne fonctionne plus avec ma fonction pourtant ma fonction est assez simple.

j'aime bien programmer mais si les résultats ne sont même plus logique, c'est assez difficile d'avancer et frustrant dans l'ensemble. ><

Code c++ :

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
 
        Node* moduleNode;
        moduleNode=my_scene->CreateChild("test");
        moduleNode->SetWorldPosition(Vector3::ZERO);             
        moduleNode->SetWorldRotation(Quaternion::IDENTITY);   //(1,0,0,0) 
 
        AnimatedModel* m_Object=moduleNode->CreateComponent<AnimatedModel>();
        m_Object->SetModel(cache->GetResource<Model>("Models/cor2.mdl"));
        m_Object->SetMaterial(cache->GetResource<Material>("Materials/blank.xml"));
 
        Node* e0 = moduleNode->GetChild("exit0", true);
        Node* e1 = moduleNode->GetChild("exit1", true);
 
        Vector3 p0 = e0->GetWorldPosition();   // position !! 
        float a0 = getAngle(p0.x_, p0.z_);   //angle !!
 
        Vector3 p1 = e1->GetWorldPosition();   // position !! 
        float a1 = getAngle(p1.x_, p1.z_);   //angle !!
 
        float test1 = atan2(0, -10)*180/( atan(1.0)*4 );
        float test2 = atan2(-10, 0)*180/( atan(1.0)*4 );
 
/*  EDIT
 
et ça marche aussi avec 
        float test1 = atan2(p0.x_, p0.z_)*180/( atan(1.0)*4 );
        float test2 = atan2(p1.x_, p1.z_)*180/( atan(1.0)*4 );
mais dans le main....
 
*/

Code c++ :

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
 
float getAngle(float x_, float z_)
{
 
    //const double MINI = -180;
    //const double MAXI = 180;
 
    //const double PI = atan(1.0)*4;
 
    float angle = atan2(z_, x_)* 180/( atan(1.0)*4 );
    //float angleDegree = angleRadian*180 /PI;
/*
    if( angleDegree < MINI )
    {
        return angleDegree+360;
    }
    else if( angleDegree > MAXI ) 
    {
        return angleDegree-360;
    }
    else
    {
        return angleDegree;
    }
*/
return angle;
}

ça n'a même plus de rapport avec urho3D là (bien que ça vient p-e d'un bug causé par le moteur), c'est vraiment mon programme qui ne veut pas me donner le bon résultat là où j'en ai besoin pour une raison qui m'échappe.

si quelqu'un à une idée....

merci de votre soutient.

[anapurna]

salut

il y a un truc qui m’échappe aussi

atan(1.0) * 4 = 3.14159265 donc PI

ta formule

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 atan2(-10, 0)*180/( atan(1.0)*4 );

mes formule

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
degrees(aval)
debut
  return aval * (180 / PI)
Fin

pour transformer le radian en degréé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
GetAngleBetweenTwoPoints(p1, p2): 
debut
  xDiff = p2.x - p1.x 
  yDiff = p2.y - p1.y 
  deg = degrees(atan2(yDiff, xDiff)) 
  // tu applique les meme regles tu devrais avoir le même résultat 
  // ou alors tu as modifié la valeur de PI dans une variable globale
  SI (deg < 0) 
    deg = deg+ 360; 
  return deg
fin

pour ton probleme tu inverse deux fois les variable pour getangle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
float getAngle(float x_, float z_)
{
 
    float angle = atan2(z_, x_)* 180/( atan(1.0)*4 );
    return angle;
 }
 
  float test1 = atan2(0,-10)*180/( atan(1.0)*4 );
  float test2 = atan2(-10, 0)*180/( atan(1.0)*4 );

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
P0.x = 0
 P0.z = -10
 float a0 = getAngle(p0.x_, p0.z_);   //angle !!

ce qui revient a faire dans ta fonction
float a0 = atan2(P0.z,P0.x)*180/( atan(1.0)*4 );
=> a0 = atan2(-10,0)*180/( atan(1.0)*4 );
=> a0 = Test2

donc a priori c'est lui qui délire mais j'arrive pas a voir ou effectivement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
P1.x = -10
 P1.z =  0
 float a1 = getAngle(p1.x_, p1.z_);   //angle !!

ce qui revient a faire dans ta fonction

float a1 = atan2(P1.z,P1.x)*180/( atan(1.0)*4 );
=> a1 = atan2(0,-10)*180/( atan(1.0)*4 );
=> a1 = Test1

[noals]

si je fais le calcul directement dans ma fonction principale, ça à l'air de fonctionner correctement avec cette formule :

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
        temp_rot_1 = atan2(m_connector.position.z_,m_connector.position.x_)* 180/( atan(1.0)*4 );
        temp_rot_2 = atan2(e_connector.position.z_,e_connector.position.x_)* 180/( atan(1.0)*4 );
        moduleNode->Yaw(temp_rot_1 - temp_rot_2-180);

ce qui positionne bien mon module pour que sa sortie soit à l'opposé de l'autre sortie mais il faut que mon armature soit bien centré en zero sinon mes angles sont faussé.
d'ailleurs, j'dois déjà modifier ma formule et y inclure les positions du module de l'exit choisie parce que le premier module est en position (0,0,0) donc ça pose pas de problème mais pour les prochain ça ne sera plus le cas. (ça devrait pas me poser de problème normalement)


pour mon module en ד , l'armature est bien centré donc j'vois pas trop d'où ça peut venir mais bon, j'ai une solution qui à l'air de fonctionné pour l'instant, je vais modifier les modules qui posaient problème précédemment, ma classe exit, refaire mon calcul des positions et je verrai bien.

après j'dois encore m'attaquer à des tests de collisions pour que les modules ne se chevauchent pas... ><;
là, c'est du grand n'importe quoi lol

[noals]

bon, y'a encore quelques bug à droite à gauche, faut que je vérifie un peu tous ça mais ça commence enfin à ressembler à quelque chose.

avec de la chance


et sans chance


merci encore.