FONCTIONS DE ROTATION DANS L'ESPACE
Funto66
Messages postés
1267
Date d'inscription
mercredi 1 janvier 2003
Statut
Membre
Dernière intervention
28 février 2007
-
30 oct. 2004 à 20:05
Arnaud16022 Messages postés 1329 Date d'inscription vendredi 15 août 2003 Statut Membre Dernière intervention 16 juin 2010 - 15 avril 2005 à 18:39
Arnaud16022 Messages postés 1329 Date d'inscription vendredi 15 août 2003 Statut Membre Dernière intervention 16 juin 2010 - 15 avril 2005 à 18:39
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/27185-fonctions-de-rotation-dans-l-espace
https://codes-sources.commentcamarche.net/source/27185-fonctions-de-rotation-dans-l-espace
15 avril 2005 à 18:39
15 avril 2005 à 00:13
mais j'aimerai consulter la doc sur gamecreator "http://prografix.games-creators.org/document/70" et il n'y a pas d'image
13 nov. 2004 à 22:18
et pour la précision des valeurs?
12 nov. 2004 à 23:54
tout sur un amd 2100+ 1.7 GHz
6 nov. 2004 à 11:49
extern __inline__ unsigned long long int rdtsc()
{
unsigned long long int x;
__asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
return x;
}
Pour une approximation du cosinus, j'utiliserais plutot un tableau de float, et une interpolation linéaire entre chaque valeur. Ca retourne quelque chose de très correct.
L'approximation position += accélération * (delta_t)^2 est tres correct, mais faut rester au dessus de 50fps, en dessous faut faire de calcul de position par frame pour garder une certaine précision. Et puis, qui a besoin d'une telle précision ?
Le truc le plus banal comme la chute libre (dans un jeu par exemple), n'aurait besoin que de 10 rafraichissement par seconde.
5 nov. 2004 à 21:32
1.666666664, c'est la valeur approchée de 5/3? si ouica serait pas plus précis encore de tout mettre en double ou long et dee mettre la fraction a la place?
5 nov. 2004 à 20:54
où est-ce qu'ils ont pu trouver ça? En tous cas si ça marche bien ben ça doit être super rapide :)
Je prends note :) Tu pourrais pas nous filer un lien direct vers les autres fonctions trigo tant qu'à faire ? ;)
5 nov. 2004 à 08:27
http://www.simgear.org/ dans le projet il y a un truc appelet "fastmath.h/.cpp", pour example voici une fonc qui definis les sinus:
// valable de [0;PI/2]
float fast_sin(const float val)
{
float fASqr = val*val;
float fResult = -2.39e-08f;
fResult *= fASqr;
fResult += 2.7526e-06f;
fResult *= fASqr;
fResult -= 1.98409e-04f;
fResult *= fASqr;
fResult += 8.3333315e-03f;
fResult *= fASqr;
fResult -= 1.666666664e-01f;
fResult *= fASqr;
fResult += 1.0f;
fResult *= val;
return fResult;
}
etonant non ?!
J'ai tester avec Excel pour savoir si les valeurs etait correct; et la, surprise toute les valeurs sont correct.
4 nov. 2004 à 18:34
typedef __int64 LONGLONG
donc ... il faut que chaque implementation sache geré un type equivalent"
-> si vous travaillez sous Windows il y a ULARGE_INTEGER et LARGE_INTEGER qui sont des structures 64-bit (en fait c'est un union) etq ui marche très bien sur tous les compilo .
4 nov. 2004 à 07:52
non, mon exemple est correct. la position est bien majorée d'une fraction du vecteur vitesse "à ce moment-là". (même si en effet pr un mouvement circulaire par exemple, ou tt autre mouvement pr lequel une force est appliquée ponctuellement, évidemment la précision dépend du nb de FPS, mais ici je n'ai pas prétendu faire intervenir des forces (ds l'exemple quoi)).
4 nov. 2004 à 00:14
_int64 times[1000];
for (long i=0;i<1000;i++)
{
QueryPerformanceCounter((LARGE_INTEGER *)&time[i]);
}
si on regard le tableau: suprise ne chiffre ne sont pas exactement constant, (en moyenne=5 cycle) ce pourais ne pas etre grave si ce que l'on mesure est grand face l'impressision. Pense que le tick est de 270ns donc si il y a un cycle de trop ca peut faire une enorme difference meme avec une boucle enorme. En fait c'est un probleme quentique (qui l'aurai cru)
En ce qui concerne le __int64, ca n'est pas reservée au machine 64bit bien sur, c'est un mots clef specifique windows et donc effectivement ce n'est pas portable. La definition d'un LONGLONG est:
typedef __int64 LONGLONG
donc ... il faut que chaque implementation sache geré un type equivalent
3 nov. 2004 à 23:10
D'ailleurs ce que tu dis est faux.
Bille.Position += Bille.Vitesse * delta_temps;
Vitesse est calculée a partir de l'accélération, qui ellemme est calculée a partir dee la vitesse.
Ca fait une equation différentielle, et sur un ordi pour résoudre ca on peut pas le faire analytiquement, du coup ya plus 36 solution, il faut le faire numériquement.
Pour ca il faut prendre le plus petit intervalle de temps possible, et à 1FPS c'est pas top. ducoup la solution n'est pas (exactement) la meme à 1 et a 100000 de fps.
mais, oui, je sais, je pinaille.
Pamaury: pour GetTickCount, je trouve ca normal qu'il soit a la ms pres, puisque c'est la définition du tick (nbre de millisecondes deepuis le boot, non?)
Basted: pourquoi ne pas mesurer le temps d'execution de
for (int a=0;a!=1000000;a++){}
puis ded
for (int a=0;a!=1000000;a++){b*10;}
et faire la différence des deux, et diviser par 1000000? ca sreait juste comme calcul? A priori oui, mais bon o sait jamais...
Bon, il est 11 heures.. plus que 8 heures de vacances...BOUH!
++
3 nov. 2004 à 22:32
ton code est VC only, à cause des __int64. est-e qu'un long long int n'est pas ok? sur une machine 32 bits, ça vaudra aussi un 64 bits, et sur les machines ultérieures, ça vaudra probablement plus, mais tt de même assez. non ?
3 nov. 2004 à 22:18
class Timer
{
public:
__int64 beginTime;
double tick;
public:
Timer()
{
__int64 frecTimer;
QueryPerformanceFrequency((LARGE_INTEGER *)&frecTimer);
tick = 1.0/frecTimer;
}
void Start()
{
QueryPerformanceCounter((LARGE_INTEGER *)&beginTime);
}
double Stop()
{
__int64 currentTime;
QueryPerformanceCounter((LARGE_INTEGER *)¤tTime);
return (currentTime - beginTime)*tick;
}
};
Chez moi la presision est 270ns c'est donc loin de la frequence de mon proceseur, et trop lent aussi pour messurer les operation assembleur de base (ajout, multiplication etc ...)
3 nov. 2004 à 22:07
Il y a aussi ftime et GetSystemTime qui sont assez précis(à la ms environ) . Et avec la SDL il y a SDL_GetElapsedTime je crois .
3 nov. 2004 à 21:45
Bille.Position += Bille.Vitesse * delta_temps;
avec delta_temps un flottant en secondes, et Vitesse et Position des grandeures vectorielles. de cette manière, à 1 ou à 1 000 000 de FPS, tu avances pareil sur les deux ordis... mais l'image sera pas forcément fluide :)
3 nov. 2004 à 21:41
3 nov. 2004 à 21:21
3 nov. 2004 à 20:59
Donc sur certain processeur çà peut être les cycles d'horloges mais c'est pas obligatoire .
3 nov. 2004 à 19:50
par contre, vu le niveau global du site, je ne pense pas qu'il y ait vraiment besoin d'une telle précision...dans hoverbike j'avais clock et ca marchait bien...
en ce moment c'et plutot sdl_getticks
3 nov. 2004 à 18:31
3 nov. 2004 à 17:49
3 nov. 2004 à 07:58
QueryPerformanceCounter n'est qu'une intreface pour utiliser un compteur HARDWARE dispo sur tout les PC assez recent . Ce compteur est extremmement précis, il attend la nano seconde en précision sur mon ordi .
3 nov. 2004 à 00:28
2 nov. 2004 à 22:47
2 nov. 2004 à 19:57
2 nov. 2004 à 17:39
Et pour tester les perfs, faudrait que tu mesures les FPS; avec l'API Win32 t'as les fonctions QueryPerformanceCounter(), GetTicks(), avec SDL t'as SDL_GetTicks(), avec GLUT à la limite glutTimerFunc() et avec la lib standard t'as clock().
2 nov. 2004 à 15:31
Une question : glRotated() utilise le GPU ?
2 nov. 2004 à 13:12
2 nov. 2004 à 10:04
Je vous fournirais l'URL de mon testGLperf quand je l'aurais totalement finis. Mais de toute facon le pre-calcul de vertex est plus que courrent, ne reste qu'a savoir dans quel cas c'est interessent.
2 nov. 2004 à 01:46
Mais si jamais c'est le cas, on pourrait en tirer un super avantage : qd on fait tourner un objet, on pourrait le faire tourner en "software" (sur la CPU et non le GPU) et fournir les données transformées au GPU; on aurait ainsi aussi les coordonnées transformées directement accessibles dans notre prog, ce qui pourrait être intéressant pr les collisions :) (bien qu'un système par bounding boxes doit être bien plus optimisé quand même ^^).
1 nov. 2004 à 22:28
Par le angle d'euler, on fait calsiquement une rotation sur l'axe des x puis y , puis z, mais cela pose un pb appele de perte de degre de liberté appelé: "Gimbal Lock"
cf.: http://membres.lycos.fr/javamus/articles/mqfaq.html question q34
pour palié a ce probleme: les quaternions
Mais sinon je trouve ta demarche interessente, il faut savoir que les calcul des coordonnée de points peuvent etre plus rapide a effectuer en CPU qu'en GPU, par exemple en OpenGL, glRotated s'execute chez moi en 775 ns alors que le meme calcul fait avec une class de matrise se fait en 635 ns (et je n'est pas optimisé la class: en claire sin et cos)
Du coup j'imagine qu'en fait cela n'est pas materiel, ou si c'est la cas ce n'est pas "rentable". Sauf effectivement dans le cas ou la transformation s'applique a beaucoup de vertex, et encors c'est largement a discuter car bon nombre d'objet sont static par rapport a une matrise donnée (a mediter)
Pour l'histoire des option de sin et cos (en fait la seul chose a vraiment optimiser), j'ai crus comprendre que cela etait pris en compt par des instruction ASM special apparu avec SSL, SSL2, SSL3, 3DNow!, MMX une petit class qui gerais ca serai le bien venu
cf.: http://lfmat.sourceforge.net/
l'onglet benchmarq ecris en claire "ca dechire grave ++"
1 nov. 2004 à 22:03
1 nov. 2004 à 21:28
je sé pas comment te l'expliquer, dsl.
je vais chercher un lien qui expliquera ca mieux que moi.
mais tes fonctions sont utiles.
Je te cite juste une page ou c'est dit et pas explique (c'est pas spécifiquement le but de cette page):
"Des transformations correctes ne peuvent pas être obtenue en cumulant des angles de rotations. Pour ce faire, il faudrait user de quaternions, mais là n'est pas le propos de notre sujet :) "
source :http://membres.lycos.fr/javamus/articles/trfmat.html
c'est sur les matrices et les transfos, ca peut t'intéresser
1 nov. 2004 à 20:05
En fait j'ai tester ces fonctions dans mon debut de moteur 3D ou je fais tourner un cube dans tous les sens que je veux grace a ces fonctions...et ca fonctionne tres bien pour ce que je veux faire.
Ce point ne sera pas a la place escompté parce que les fonctions sin et cos n'ont pas une precision infinie ...c'est ca que tu veux dire?
le but de ces fonctions est faire tourner un point a l'ecran...pas besoin d'une precision enorme C'est pas un logiciel de calcul que je veux faire!
Sinon j'ai mis a jour mon code en y ajoutant des tableaux contenant les valeurs de sin et cos au 10eme de de gré pres... enfin vous pouvez facilement modifier cette valeur avec le : #define precision
1 nov. 2004 à 19:46
en fait tes fonctions peuvent trres bien servir pour créer un effet JOLI dans un programme qui aura le mérite (oh oui! c'est pas si courant) d'etre personnel.
"Pour quoi il ne serait pas possible de faire tourner mon point autour d'un axe quelquonque (X par exple) puis autour d'un axe perpendiculaire (Y par exemple)"
essaye et tu verras que ca marche pas (le plus souvent du moins). je veux dire par la que le point va tourner correctement autour des 2 axes, comme tu le lui a demandé, mais a la fini sera pas tout a fait a la place escomptée; Ca marche si tu trouve le moyen de calculer les angles de rotations voulus mais pour ca bon courage.
1 nov. 2004 à 18:55
Pour quoi il ne serait pas possible de faire tourner mon point autour d'un axe quelquonque (X par exple) puis autour d'un axe perpendiculaire (Y par exemple)
Et puis je ne vois l'inutilité de ces fonctions !? Ca ne sert pas pour toi la rotation pour animer un objet en 3D?
Et je n'ai pas dit que mes fonctions etaient rapides...d'ailleurs si t'as lu les autres commentaires je suis en train de les optimiser un peu
31 oct. 2004 à 22:31
pour faire tourner un point autour d'une droite (pour commencer on va dire qu'elle passe par l'origine) autre qu'un axe, tu peux pas faire d'abord une rotation autour d'un axe puis une autrre rotation autour d'un axe perpendiculaire. Le point serait déplacé, certes, mais il ne serait pas du tout a la position voulue.
Les matrices c'est tout con, en gros t'as qu'à savoir les multiplier, mais la encore ce n'est QUE autour des axes.
La meilleure solution, universelle, pratique, RAPIDE et tout et tout, c'est effectivement les quaternions.
Maisc'est pas la peine d'essayer de reprogrammer ca toi meme, pasque toute la doc ou presque est en anglais, et que c'set qd meme assez dur (ne serait-ce que le concept: un quaternions, en fait, ca s'appelle aussi un hyperscalaire a 4 dimensions, qui sert entre autres a des rotations spheriques 4D ... voila qui laisse songeur.)
Bref...t'es pas sorti de l'auberge... et tes fonctions sont lentes (dsl...) et inutiles (re-dsl...) sauf cas précis
oh encore untruc: tout au début tu fais
#ifndef Rotate
sans rien derriere... je vois pas comment ca peut marcher. ce qu'il faut c'est :
#ifndef Rotate_h
#define Rotate_h
... ton code ...
#endif
31 oct. 2004 à 20:44
31 oct. 2004 à 15:29
http://www.cppfrance.com/code.aspx?ID=24821
mais je sais pas si ca marche bien
31 oct. 2004 à 13:06
cos(x) = sin(90-x)
tan(x) = sin(x) / cos(x)
euh, bien entendu tu dois tjs t'arranger pr convertir l'indice d'accès au tableau afin de rester ds l'intervalle [0, 360] (càd 0, 3600 en fait).
je te conseille de faire une classe "wrapper", que tu nommerais CTrigo, et qui au démarrage crée un tableau statique (tu pourrais vouloir plusieurs occurrences de la classe, mais c'est pas vrmnt la peine de se tapper un singleton) avec les valeurs sinusoïdes, selon la précision voulue (à préciser en statique aussi). ensuite tu crées des fonctions Sin(), Cos(), Tan(), Cotan() qui convertiront elles-mêmes les angles histoire de pas se casser la tête.
exemple:
l'angle 54,8 sera à l'infice int(54.8 * 10) = 548 (pr précision 10)
l'angle -37 sera à l'indice (360 + (-37))*10 = 3230
et l'angle 589 sera à l'indice (589%360)*10
enfin, ça doit pas être trop dur ni lourd pt de vue machine de faire ces calculs. oublie pas que si tu veux calculer Tan à partir de cos et de sin, tu peux parfaitement calculer l'angle exacte une seule fois dans la fonction Tan, puis ne pas appeler les fonctions Cos et Sin qui referaient l'adaptation de l'angle, mais directemet depuis Tan renvoyer la valeur tableau.
tu peux aussi imaginer une méthode de conversion de l'angle, tout simplement ^^
vala
31 oct. 2004 à 10:51
31 oct. 2004 à 01:37
Enfin, tout dépend de ce que tu veux faire tourner aussi, et surtout de ce que tu veux en faire ;)
30 oct. 2004 à 23:18
30 oct. 2004 à 21:53
Voila ;)
++
30 oct. 2004 à 21:47
-> tu fais tes transformation sur la matrice et tu applique ensuite cette matrices à tous les point qui subissent la transformation ainsi, pas besoin d'appeler 50 fois la fonction cos si t'as 50 points . Un bon site qui introduit ce sujet:
http://prografix.games-creators.org/document/70
Sinon regarde sur le net il doit y avoir plein de trucs .
Sinon pour les quaternions je m'en suis jamais servit masi il me semble que c'est pour gérer le déplacement d'un objet par rapport à un autre lui-même en mouvement de façon assez facilement ^^
30 oct. 2004 à 20:15
En tout cas merci, je retiens cette remarque.
ET les matrices et quaternions , ce n'est pas encore de mon niveau mais je vais me renseigner la dessus...
30 oct. 2004 à 20:05
En général pour ça on crée des gros tableaux qui contiennent des valeurs pour les fonctions trigo. Genre tab_sin[28] renverrait la valeur de sin(28), mais t'es pas obligé de rester en degrés ou en radians, tu peux prendre une unité plus petite pour une meilleure précision ;)
Sinon pour faire tourner des points en général on utilise des matrices ou des quaternions (m'en demande pas plus sur ce sujet par contre lol) ^^