Voila je voudrai savoir comment je pourai faire avancer un node selon sa rotation sur l'axe Y

Tu veux dire sachant que ton node a pivoté d'un angla alpha tu voudrait qu'il avance de x dans cette direction?

Si oui tu peut faire un vecteur (x,0,0) et le faire pivote de alpha sur l'axe y. J'ai supposé que ton node était orienté, selon l'axe x(il regarde dans cette direction).
Bon ce n'est qu'une supposition et il y a peut être mieux.(voir les déplacement relatif).

Tu trouvera facilement dans vector3df les fonctions qu'il te faut pour faire pivoter le vecteur.

En espérant avoir compris la question.

dark calculator

ben ex : si le node regarde en nord - est  je veut quil avance vers le nord - est

help

Pour une camera on peut faire :

vector3df direction = node_camera->getTarget() - node_camera->getPosition();
// direction.Y = 0; // si l'on veut un déplacement horizontal
direction.normalize(); // pour récpérer le vecteur unitaire
node_camera->setPosition(node_camera->getPosition() + direction * facteur); // avec facteur étant le nombre d'unités pour avancer

Maintenant, pour un node quelquonque il faudrait trouver un équivalent à node_camera->getTarget().

Bien, sinon on peut faire comme ça aussi :
Le vecteur direction dépend seulement de Y donc on peut utiliser la trigonométrie, seulement il y a un problème. Il faut envisager 8 cas car cos et sin sont impaire et paire respectivement. Donc on se retrouve avec cos(x) = cos(-x) et sin(x) = -sin(-x).
Donc les 8 cas sont : (en degree)
Y=0
0>Y>90
Y=90
90>Y>180
Y=180
180>Y>270
Y=-270
270>Y>360
Cela nécessitera de "normaliser" les angles car l'angle de rotation peut etre egal à (n*360 + teta) avec n appartenant à l'ensemble N (entier naturel).
Donc ensuite suffit de coder mais si quelqu'un a une méthode moins "barbare" qu'il fasse part de son idée.

En fait, je viens de voir dans la doc qu'il y a :
     vector3d< T >  rotationToDirection (const vector3d< T > &forwards=vector3d< T >(0, 0, 1)) const 
     Builds a direction vector from (this) rotation vector.
Donc faut voir.

Dernière modification par johnplayer (19-01-2009 11:52:21)

tu peut me faire un example stp

Je ne suis pas expert en programmation (autodidacte) donc je te donne ce bout de code sans etre sur qu'il sera correct.

// avec node, le noeud à avancer
vector3df direction = node->getRotation()->rotationToDirection(vector3df(X,Y,Z));
/** XYZ à l'air de représenter la direction que l'on veut :
vector3df (0,0,1) montre l'avant du node (avancer)
vector3df (0,0,-1) montre l'arriere du node (reculer)
vector3df (1,0,0) montre la droite du node (marcher en crabe vers la droite)
vector3df (-1,0,0) montre la gauche du node (marcher en crabe vers la gauche)
vector3df (0,1,0) montre le dessus du node
vector3df (0,-1,0) montre le dessous du node
les 4 premiers vecteurs permettent de gérer une camera de type FPS
**/
// maintenant, direction ne prends pas encore en compte la position du node dans le monde. On poursuit donc :
/** si on fait :
direction += node->getPosition();
direction est alors egal au getTarget() d'une camera si vector3df(X,Y,Z) = vector3df(0,0,1) qui montre l'avant
**/
// si l'on veut avancer de plusieurs unités on fait :
node->setPosition(node->getPosition() + n*direction); // avec n le nombre d'unités dont on veut avancer

J'espère que le code est bon et que ça résoudra ton problème. Si jamais ça marche ou s'il y a quelques moifs à faire fais en part car j'en aurais aussi besoin par la suite et certainement d'autres personnes seront intéressées.

sa marche pas

Une erreur mais sinon ca marche. C'est un point et non une fleche pour utiliser rotationToDirection().

vector3df direction = node->getRotation().rotationToDirection(vector3df(X,Y,Z));
node->setPosition(node->getPosition() + n*direction); // avec n le nombre d'unités dont on veut avancer

avais deja vus sa lol
je parlai du calcule qui étai faut

C'est bizarre car ca fonctionne tres bien chez moi.

Salut,

Pour un node, moi je verrais bien ça :

ISceneNode node;//node que tu veux déplacer
int x;//distance de déplacement
vector3df trans(x,0,0);//On suppose que ton node regarde par défault dans la direction x
trans.rotateXZBy (node->getRotation().Y, vector3df(x,0,0));
node->setPosition(node->getPosition() + trans);

Pour une caméra, c'est plus compliqué à cause des targets, sa dépend comment tu la gère à la base.
Sinon il y aussi cette fonction : http://irrlicht.sourceforge.net/docu/cl … a19278474d qui pourrait correspondre.
Mais je sais pas trop se qu'elle fait.

Voilà je n'ai pas pu tester mon code, je vais aller le faire, mais je ne sais toujours pas si c'est réelement se que tu veux.

dark calculator

Pour ce qui de la fonction que tu as repérée j'ai donné un exemple juste au dessus. par contre, j'aimerais bien avoir une explication pour ce qui de l'erreur de calcul car je n'ai pas l'impression de l'avoir dans mes essais. alors si hardcpp pouvait expliquer l'erreur qu'il voit, je pourrais certainement l'aider.

Désolé j'avais lu en diagonale ton code, et comme tu parlais des camera avant j'ai pensé qu'il concernait les camera, ayant apercu du getTarget et tout. Et puis je te voyais faire des cas particulier mais en faits tout cela était en commentaire et un seul intéresse l'ami hardcpp.
Ton code est donc un peu mieux que le mien, je m'excuse d'avoir rajouté ce post un peu inutile, sa m'apprendera a pas tout lire.

dark calculator

ben le node partai a des distance faramineuse

C'est normal! Si n = 1 (voir le code) et que tu deplaces ton node à chaque frame tu obtiens n*framerate deplacement par seconde.
Si ton rendu est en vsync tu as 60 déplacement par seconde donc ton objet part très vite et si tu n'as pas de vsync je ne t'en parle meme pas. Il faut utiliser device->getTimer()->getTime() pour deplacer ton objet toutes les x millisecondes. Si tu force la vsync à la limite tu peux mettre n = deplacement_par_seconde / 60 mais je t'avoue que ce n'est pas très propre.

meme sa marche pas dsl

Et si tu fais direction.normalize() est-ce que ça ne résoud pas ton problème? Et à la limite si tu peux m'envoyer ton essai par mail je pourrais mieux voir... enfin s'il n'y a rien que tu veuilles garder "confidentiel" .

/** XYZ à l'air de représenter la direction que l'on veut :
vector3df (0,0,1) montre l'avant du node (avancer)
vector3df (0,0,-1) montre l'arriere du node (reculer)
vector3df (1,0,0) montre la droite du node (marcher en crabe vers la droite)
vector3df (-1,0,0) montre la gauche du node (marcher en crabe vers la gauche)
vector3df (0,1,0) montre le dessus du node
vector3df (0,-1,0) montre le dessous du node
les 4 premiers vecteurs permettent de gérer une camera de type FPS
**/

Faudrai trouver un calcule pour obtenir sa (au dessu) selon l'axe Y mais je n'est pas idée du calcule

Je pense que je ne plus t'aider à ce niveau là, de plus, pourquoi réinventer la poudre? La solution que je t'es donné est, sans prétention aucune, la plus simple et certainement moins gourmande en temps de calculs.

Je ne vois pas pourquoi elle ne marche pas chez toi, parce que il me semble que tu as tout comme moi Irrlicht 1.5. Si je peux me permettre un conseil, créé une scene avec un plan (avec un UVW Mapping) sur lequel tu mets une texture avec différentes droites passant par le centre de ton plan pour avoir des directions correspondant à chaques angles(0°,30°,60°,etc.).Ensuite tu fais des tests.

Après, comme je te l'ai dis au-dessus, seul les sources d'un de tes essais pourraient me permettre de t'aider. Je pourrais te mettre des explications et voir ce qui ne va pas.

ben je bosse sur un mmorpg (voire partie recrutement) j'utilise une camera style world of warcraft sauf que nl'on se deplace a la souris quand je clisue sur la map le perso se tourne vaire ce point il faut j'uste le faire avance

Dans ce cas, à partir du moment où il n'y a pas d'obstacle entre le perso et le point d'arrivée, tu peux faire :
vector3df arrivee; // point 3d récupérer au clic de la souris
vector3df direction = vector3df arrivee - node->getPosition()
direction.normalize(); // vecteur unitaire de direction

Pour tourner ton personnage dans la bonne direction, tu fais :
node->setRotation(direction->getHorizontalAngle()); // obtient la rotationnécessaire au node sur Y

Ensuite, pour avancer, tu fais :
node->setPosition(node->getPosition() + n*direction); // avec n = distance à parcourir toutes les x millisecondes.

merci sa marche

De rien, ça fais toujours plaisir d'aider quand on peut.

Dernière modification par johnplayer (20-01-2009 19:42:56)