petite question - Page 1

Salut,
je cherche à savoir comment faire : je doit faire pivoter un rectangle.
Comment faire, et comment faire pour connaitre les nouvelles coordonées des nouveaux points???
En fait comment faire pour le transformer. Faut le faire avant de le mettre, mais comment??? par un écran tampon???
merci de vos (futurs) conseils

C'est de la trigo de base.
Si tu veux faire tourner un point (x,y) autour de l'origine du repère d'un angle theta, les nouvelles coordonnées (xn,yn) seront:
xn=x*cos(theta)-y*sin(theta)
yn=x*sin(theta)+y*cos(theta)
Vérifie en basic je suis pas sûr des signes.

Si tu veux faire tourner mais pas autour de l'origine, faut d'abord faire une translation, faire ta rotation puis refaire la même translation dans l'autre sens.

Donc, c une methode (ci dessus)

je te conseille de faire une table de sin pour accélérer car sinon, c over lent

Je te conseille la méthode qu'il t'ont dicté, tout en sachant qu'il faut garder tes coordonnées d'origines parce qu'à chaque fois que tu modifies ton rectangle, tu as une perte de précision, et après t'obtient un truc vraiment pas beau

tiens, en parlant de ca, vous utilisez koi vous pour faire des rotation ??
(a par les matrices de rotation, sin & cos)

bah rien d'autre... tu veux utiliser koi en plus de ca, ou à la place?

ben les matrices de transformation, c ca qui est utiliser dans tous les jeux 3D sur PC, c le plus rapide de loin
y a des mthodes pas a pas, mais l'avantage des matrices, c'st ke tu fais tout en une seul fois.

OKi ... mais, je pensais pour les rotation continues a des methodes peu etre plus optimisées ...

ouais chui là
euh moi j'avais besoin d'appliquer une rotation à un carré (un rectangle particulier, on est tous d'accord), et ce que j'ai fait, c'est une table de cosinus en fpm, avec les valeurs de cos(0..90), ça suffit largement, tu trouves tous les cos et sin entre 0 et 360° avec ça.
Je fais tourner mon carré autour d'un centre de rotation, mais je m'occupe de ça seulement à la fin, je considère que mon premier point appartient au cercle de centre mon centre de rotation et de rayon r :

x=r*cos(angle) et y=r*sin(angle)

et je déduis les coordonées des trois autres points (-y,x), (-x,-y) et (y,-x). tu peux faire pareil pour ton rectangle, ça fait du calcul en moins... et à la fin je fais mon "changement de repère".
C'est à toi de voir si veux avoir en priorité vitesse ou précision (meme si ce que j'utilise est assez précis).

nEUrOne : le truc des DL ne marche que pour des angles tres petits, donc on oublie vite fait pour la 3D Plutot que d'utiliser les expressions barbares de la matrice finale, y'a des formules plus simples:
rotation autour de l'axe X
x' = x
y' = y*cos(a) - z*sin(a)
z' = y*sin(a) + z*cos(a)
tu fais ça pour chaque axe et apres tu projète
X' = Xo + Zo * (X-Xo) / (Zo-Z)
Y' = Yo + Zo * (Y-Yo) / (Zo-Z)
où O(Xo,Yo,Zo) est la position de l'observateur.

Bon j'ai un peu dévié de sujet, mais en gros, la méthode que j'utilise est simple, petite et rapide!

Euh en fait tu ne pourra pas faire appliquer de rotations à ton rectangle avec ce que je t'ai dit... je mé trompé :P va falloir calculer pour chaque points.

/*
Pour le rectangle, tu aura besoin de faire le calcul avec 2 points...
Imagine toi le point supérieur droit du rectangle, il appartient au cercle de centre O et de rayon r. Tu as toujours les trucs:
x=r*cos(angle)
y=r*sin(angle)
Ensuite tu as les coordonées du points symétrique par rapport à O, c'est (-x,-y).
Il te faut le point supérieur gauche, qui est aussi sur le cercle de centre O, de rayon r, et lui par contre, tu dois utiliser un nouvel angle de (180-angle)... tu trouve son x et son y et tu déduis son symétrique par rapport à O, c'est (-x,-y).

Remarques:
-si angle=0, t'as une ligne horizontale
-si angle=90, t'as une ligne verticale
-si angle=45, t'as un carré

Voilà
*/
[edit]Edité par yhean le 24-10-2001 à 23:33:09[/edit]

Y'a pas plus simple que ces méthodes???
parce que si je fait pivoter tous les points de mon rectangle, ca va etre long et compliqué

si c tt le rectangle que tu veux faire pivoter, y compris une quelconque image dedans, fais du texture mapping, sinon, si c juste un rectangle vide ac les bords, je vois pas où est le pbl

ben justement, c plutot un sprite entier que je veux faire pivoter, et je regarde si le faire pivoter ou si prendre qqs images du pivotement effectué n'est pas plus simple

Bah fallait le dire avant!
En effet, si tu veux faire pivoter un sprite, ça serait peut etre mieux d'avoir quelques sprites montrant des étapes intermédiaires de la rotation... enfin ça dépend de ce que tu veux faire. Sinon tu peux toujours demander à RV comment faire tourner une image sur elle même...

v demander à rv alors
merci

l'es jamais sur le forum hervé???

Si si, mais le mieux c'est de lui envoyer un mail... HerveRV@aol.com

si, je passe tous les jours, sauf quand je pars de chez moi durant 5 jours !
mais je suis revenu !

bon, je crois que je vais pas en dire plus sur la méthode décrite un peu plus haut, qui est aussi celle que j'ai utilisée, donc voila le code source du prog "rotation" qui est sur mon site:
(ça devrait tout de suite t'éclairer sur la manip)

; ******************** DEPART DU PROGRAMME SOURCE ******************** 

	include "tios.h"
	include "flib.h"
	include "util.h"
	include "graphlib.h"
	include "exec.inc"
	include "userlib.h"
	include "macrolib_rv.h"
	include "rv_lib.h"

; bibliothèque(s) utilisée(s) ici, si besoins 

	xdef _main
	xdef _comment 
	xdef _ti89


; *********************** RAPPEL DES MACROS ************************* ;
;											    ;
;	AddressLine	 <x1>,<y1>,<x2>,<y2>,<Addresse du coin haut gauche> ;
;	Beep2		 <fréquence>,<longueur>					    ;
;	BOX		 x,y,larg,haut,str					    ;
;	BOX_Tios	 titre,text,bouton1,bouton2				    ;
;	Ecrit 	 x,y,mode,chaîne						    ;
;	EcritAdr	 x,y,mode,adresse						    ;
;	EcritAdrF	 x,y,adresse						    ;
;	EcritChar	 x,y,mode,caractère					    ;
;	Ecrit_nbr 	 x,y,mode,nbr_digits,nbr				    ;
;	EcritFnbr    x,y,nbr_digits,nbr					    ;
;	EcritFUTUR	 <x>,<y>,<str>						    ;
;	Efface4	 -> efface les buffer 1&2 en gray4			    ;
;	EffaceListe	 <liste a effacer>,<nombre d'elements>		    ;
;	Envoyer	 <registre.b ou dc.b>					    ;
;	Exec		 <RomFunc ou Code provenant de	exec.inc>	    ;
;	Fill		 <x>,<y>,<largeur>,<hauteur>,<couleur>		    ;
;	Font		 #<1;2;3>							    ;
;	Getkey	 -> d0							    ;
;	GetKeyRAM	 <y>,<x> de la matrice clavier 89			    ;
;	GetKeyRAM_2	 <y>,<x>,<label> de la matrice clavier 89		    ;
;	InputSTR	 <x>,<y>,<dim str max> -> {d0,d1,a0}		    ;
;	Line		 <x1>,<y1>,<x2>,<y2>					    ;
;	PetiteBoite	 <string>							    ;
;	PopUp		 <x>,<y>,<nbr lignes>,<txt (dc.b "1",0,"2",0,"3",0)>;
;	PxlOff	 x,y 								    ;
;	PxlOff_a0	 x,y,addresse						    ;
;	PxlOn		 x,y								    ;
;	PxlOn_a0	 x,y,addresse						    ;
;	PxlTest	 x,y -> d0=<0;1>						    ;
;	PxlTest_a0	 x,y,addresse -> d0=<0;1>				    ;
;	Random_d0	 val -> d0=rand(val)					    ;
;	Rand_Var	 nbr,variable						    ;
;	Rcl4Pic	 #<x>,#<y>,<pict1>,<pict2>				    ;
;	RclPic 	 x,y,var							    ;
;	ReadList	 var,position,sto var					    ;
;	ReadMat	 var,x,y,largeur,sto var				    ;
;	Rectangle    <x>,<y>,<largeur>,<hauteur>				    ;
;	Recevoir	 <resultat.b>						    ;
;	RemplitListe <liste a remplir>,<valeur.w>,<nombre d'elements>   ;
;	Rotation	 x,y,centre_x,centre_y,angle,scr_adr,pic		    ;
;	Rplc4Pic	 #<x>,#<y>,<pict1>,<pict2>				    ;
;	Rplc4Pic	 #<x>,#<y>,<pict1>,<pict2>,<mask>			    ;
;	RplcPic	 x,y,var,mask						    ;
;	StoList	 var,valeur,position					    ;
;	StoMat	 var,valeur,x,y,largeur					    ;
;	StoPic	 <x(byte_pair)>,<y>,<longueur_x(word)>,<hauteur_y>, ;
;	-suite-	 <addresse_du_coin_haut_gauche>,<variable>	    ;
;   TransfertListe <liste a copier>,<sto liste>,<nombre d'elements>   ;
;	Trans_scr	 <écran_a_copier>,<écran_a_transformer>		    ;
;	XorPic	 <x>,<y>,<sprite>						    ;
;											    ;
; ******************** DEPART DES SOUS-PROGRAMMES ******************* ;

droite		EQU	344
gauche		EQU	338
haut			EQU	337
bas			EQU	340
esc			EQU	264
apps			EQU	265
F1			EQU	268
F2			EQU	269
F3			EQU	270
F4			EQU	271
F5			EQU	272
F6			EQU	273
F7			EQU	274
F8			EQU	275
; pause_20000 	  pause_40000	  pause_60000	  pause_2sec
; Interruptions_ON/OFF
; ******************************************************************* ;
; ******************************************************************* ;
; ******************** DEPART DU CODE PRINCIPAL ********************* ;
; ******************************************************************* ;
; ******************************************************************* ;
;	jsr 		graphlib::gray4					; active le mode dégradé
;	jsr 		graphlib::gray2   				; Remet le mode noir et blanc
;	jsr   	flib::idle_loop					; attend une touche et stocke dans d0
;	jsr 		graphlib::clr_scr					; efface l'écran dans sa totalité
;	jsr 		flib::clr_scr					; efface l'écran sauf la ligne ST et le 18/30
;	jsr 		flib::zap_screen					; efface l'écran dans sa totalité
; le code commence ici 

;	Rotation	 x,y,centre_x,centre_y,angle,scr_adr,pic

										;Départ
	_main:								;Lbl _main
	clr.l		angle ; + pas
	lea		buffer,a6
   loop:
	cmp.w		#360,pas
	bne		pas_ok
	clr.w		pas
	pas_ok:
	cmp.w		#360,angle
	bls		angle_ok
	sub.w		#360,angle
	angle_ok:


	move.l	#$4C00,a0
	move.l	a6,a1
	move.w	#99,d0
    loop_:
	move.l	(a1),(a0)+
	clr.l		(a1)+
	move.l	(a1),(a0)+
	clr.l		(a1)+
	move.l	(a1),(a0)+
	clr.l		(a1)+
	move.l	(a1),(a0)+
	clr.l		(a1)+
	move.l	(a1),(a0)
	clr.l		(a1)
	add.w		#14,a0
	add.w		#14,a1
	dbra		d0,loop_

	Rotation	#80,#50,#2,#2,angle,a6,a
	move.l	a6,a5
	Trans_scr	a5,#$4C00

	addq.w	#1,pas
	move.w	pas,d0
	add.w		d0,angle
	Getkey
	cmp.w		#0,d0
	beq		loop
	rts


; cette instruction signifie la fin du programme
; le code fini ici 
; ******************************************************************* ;
; ******************************************************************* ;
; ******************** DEPART DES LABELS **************************** ;
; ******************************************************************* ;
; ******************************************************************* ;

a:
 dc.w 24 ;Vertical size
 dc.w 3 ;Horizontal size
 dc.b %01110000,%00000000,%00000000
 dc.b %11111000,%00000000,%00000000
 dc.b %11011000,%00000000,%00000000
 dc.b %11111100,%00000000,%00000000
 dc.b %01111111,%00000000,%00000000
 dc.b %00011111,%10000000,%00000000
 dc.b %00001011,%11100000,%00000000
 dc.b %00001101,%11110000,%00000000
 dc.b %00000101,%11111000,%00000000
 dc.b %00000010,%11111100,%00000000
 dc.b %00000011,%01111110,%00000000
 dc.b %00000001,%10111111,%00000000
 dc.b %00000000,%11011111,%10000000
 dc.b %00000000,%01101111,%11000000
 dc.b %00000000,%00110111,%11100000
 dc.b %00000000,%00011011,%11110000
 dc.b %00000000,%00001101,%11111000
 dc.b %00000000,%00000110,%11111100
 dc.b %00000000,%00000011,%01111100
 dc.b %00000000,%00000001,%10111110
 dc.b %00000000,%00000000,%11011110
 dc.b %00000000,%00000000,%01100111
 dc.b %00000000,%00000000,%00011011
 dc.b %00000000,%00000000,%00000110


; ******************************************************************* ;
; ******************************************************************* ;
; ******************** DEPART DES DONNEES *************************** ;
; ******************************************************************* ;
; ******************************************************************* ;
; les données commencent ici 

_comment 	dc.b	"Rotations par Hervé Bonafos",0

angle		dc.w	0
pas		dc.w	0
 BSS

buffer ds.b	3000

 end 

euh, bien sur il faut avoir des fichiers que vous avez pas et que vous aurez pas, rv_lib est disponible sur mon site, et il y a une doc pour chacune des fonctions.
bon, je pense que ça suffit pas pour répondre à la question, alors j'attend les zones d'ombres restantes

heu pour la rotation.. on peut utiliser bresenham... ca peut faire l'affaire.. et il n'y a pas besoin de cos ou sin..

ben oui, cela j'avais compris
ce que je voulais, c'est une explication de ta routine "rotation"
c'est cela que je veux
le reste, c'était une bete utilisation de ce truc

c très simple :
je fais un test de bit sur l'image source, si y a un bit à 1, je calcule sa destination, avec du cos et du sin (expliquées dans le post n°2), puis je termine par un pxlOn a la coordonnée finale sur un autre plan

Ce n'est pas une très bonne technique. Il vaut mieux utiliser la rotation inverse r^-1 de r et calculer r^-1(P) pour chaque pixel P de la destination, arrondir ses coordonnées aux entiers correspondants pour obtenir les coordonnées du pixel P0 correspondant (= "arrondir r^-1(P) au pixel P0 correspondant"), vérifier si P0 est à l'intérieur de la source et si c'est le cas, si P0 est allumé dans la source. Si les 2 sont le cas, on allume P, sinon on l'éteint. Comme ça, on est sûr de ne pas oublier des pixels de la destination, et de ne pas perdre du temps à allumer le même pixel plusieurs fois.

Et tout ceci n'est utile que si le rectangle est rempli. Si c'est juste les bords du rectangle (ou en général de n'importe quel polygone), il suffit de calculer l'image des coins par r.
[edit]Edité par Kevin Kofler le 02-11-2001 à 22:57:43[/edit]

et pour les valeurs des sinus et cosinus, vous faites comment???
j'avais pensé à un tablea avec 2 lignes:
ex: si un cos fait 0.5 environ, on met 1 dans la première ligne et 2 dans la seconde
ou si une valeur faut 0.738, on met 738 dans une ligne et 100 dans la seconde. après on prend la valeur à calculer, on la multiplie par la première et on divise par le seconde. Vous en pensez quoi???

Et si on veut, par exemple, faire pivoter tout cela dans l'espace?
Donner dans la perspective quoi...

beuuurk! les divisions (((
comment ralentir un prog?
faites des divisions

enfin, c ptet une bonne idée, bien que je ne pense pas, mais le plus simple (à mon avis) est d'utiliser pour ta table précalculée, les valeurs du cosinus de 0 à 512 (correspondant de 0 à 1) puis de faire tes calculs avec, et de faire un lsr.w #9,dx, ac ton résultat ds dx. comme ça tu conserves une relativement bonne précision, pour n'arrondir qu'à la fin.
dc pour chaque valeur de l'angle (de 0 à 90 pour un pas de 1°), tu auras cos(angle)*512.

Les fractions ne seront pas beaucoup plus précises que la virgule fixe (que propose sBibi) parce que les valeur du sinus et du cosinus sont en général irrationnelles.
[edit]Edité par Kevin Kofler le 06-11-2001 à 23:22:51[/edit]

je ne dis pas ça pour la précision, mais pour la vitesse

sinon, pour la perspective, c une application toute bête du théorème de thalès

y a une autre méthode utilisant les produits scalaires, mais je te laisse chercher tt seul, c pas bien compliqué, il faut juste se mettre devant une feuille, faire 2-3 schémas, et c bon

c pas que thalès ?
la percepective n'est pas quelque chose de proportionnel !
si tu fais thalès tu peux avoir un rendu sympa je pense, mais pas réaliste à mon avis.
en fait j'en sait rien, mais je me suis déjà penché sur la question, sbibi (tu sais pourquoi !)

moi je peux te dire que non, rv
moi aussi je me suis longuement penché sur le problème...
j'avais des équations de fou, et finalement, je me suis apperçu que tout se simplifiait et qu'on rtobait sur un simple thalès.
tu t'es penché sur la question, mais toi, ça marche pas alors que moi ça marche impeccable

toute la perspective de mon moteur, qui est il me semble assez réaliste est basée sur ce principe
tu connais les coordonnées x,y,z de ton point, eh bien les coordonnées projetées sont:

x'=focal*x/z
y'=focal*y/z

j'ai essayé par tous les moyens de virer le 1/z, mais c pas possible, et ça peut facilement se comprendre.
par contre, on peut très facilement simplifier les formules au dessus, paske moi, les divisions, j'aime pas
don tu fé:
temp=focal/z
x'=temp*x
y'=temp*y

et tu peux aussi virer la constante focal, qui est la distance de l'oeil à l'écran. (en fait, c une variable, paske c mieux de pouvoir la changer, paske quand focal augment, ça revient à faire un zoom )

tt simplement, l'angle de vision d'un être humain est de 90°
or l'écran de la 92 fait 240 de large, don pour avoir les 90°, il faudraitavoir:

focal=120
valeur qui se rapproche nettement de 128

tu insère un petit lsl #7,dx et c bon...

si tu as déjà joué à max payne, quand il est dans sonrève, et que tu dois le guider dans le labyrinthe de couloirs, pour avoir cet effet de tiraillement du décor, le moteur diminue simplement la valeur de focal (enfin, ça c ma notation...)
de même que dans quake ou wolfenshtein (le nouvo), qd tu fé un zoom, c focal qui augmente.

maintenant, va voir les shots de mon moteur, et dis moi si la perspective est pas réaliste
c simple, c EXACTEMENT la même technique pour tous les moteurs 3d, sauf que certains utilisent les produits scalaires, mais ça revient EXACTEMENT au même

je viens de faire un dessin, c bcp mieux:

1: projection sans perspective
2: fausse perspective
3: vraie perspective obtenue avec thalès


[edit]Edité par sBibi le 07-11-2001 à 19:46:30[/edit]