210

Et alors une beta? une release?? smilesmile

211

Desole sad et merci smile

212

[Petit up]

alors voilà j'ai refait la fonction de rendu de mode7 en asm (et en changeant l'algo un peu) et j'aimerais savoir si vous voyez des moyen de gagner des cycles la dedans :

#define IN_MAP_ASM(SHIFT) \
asm("move.l %d4,%d5"); \
asm("asr.l %0,%%d5"::"g"(RENDER_SHARPNESS)); \
asm("add.w %d1,%d5"); \
asm("move.l %d3,%d6"); \
asm("asr.l %0,%%d6"::"g"(RENDER_SHARPNESS)); \
asm("add.w %d2,%d6"); \
 \
asm("move.w %d5,%d7"); \
asm("swap %d7"); \
asm("move.w %d6,%d7"); \
asm("asr.w %0,%%d5"::"g"(TILES_SHIFT)); \
asm("asl.w %0,%%d5"::"g"(10-TILES_SHIFT)); \
asm("asr.w %0,%%d7"::"g"(TILES_SHIFT)); \
asm("add.w %d7,%d5"); \
asm("lsl.w #2,%d5"); \
asm("swap %d7"); \
asm("lea %a4@(%d5.w),%a5"); \
asm("and.w %0,%%d6"::"g"(TILES_SIZE - 1)); \
asm("and.w %0,%%d7"::"g"(TILES_SIZE - 1)); \
asm("asl.w %0,%%d7"::"g"(TILES_SHIFT)); \
asm("add.w %d6,%d7"); \
asm("movea.l %a5@,%a5"); \
asm("adda %d7,%a5"); \
asm("add.l %a3@,%d4"); \
asm("add.l %a3@(4),%d3"); \
 \
asm("tst.b %a5@"); \
asm(".word 0x6704 | beq +4"); \
asm("or.w %0,%%a0@"::"g"(PIX >> SHIFT)); \
asm("adda.w %a6,%a5"); \
asm("tst.b %a5@"); \
asm(".word 0x6704 | beq +4"); \
asm("or.w %0,%%a1@"::"g"(PIX >> SHIFT));


static inline void m7_DrawFrame(void) {
  asm("movem.l %d0-%d7/%a0-%a6,%a7@-"); // pushes all registers

  asm("move.w Dir,%d0");
  asm("lea SinTable,%a0");
  asm("lea CosTable,%a1");
  asm("moveq #0,%d3");
  asm("moveq #0,%d4");
  asm("move.b %a0@(%d0.w),%d3");
  asm("ext.w %d3");
  asm("move.b %a1@(%d0.w),%d4");
  asm("ext.w %d4");
// computing of m7startsL
  asm("lea m7starts,%a0");
  asm("lea m7startsL,%a1");
  asm("move.w Y,%a2");
  asm("move.w X,%a3");
  asm("moveq %0,%%d0"::"g"(SIZE_Y-1));
  asm("loopM7S:");
  asm("move.w %a0@+,%d1");
  asm("move.w %d1,%d2");
  asm("move.w %a0@+,%d5");
  asm("move.w %d5,%d6");
  asm("muls.w %d4,%d1");
  asm("muls.w %d3,%d2");
  asm("muls.w %d4,%d6");
  asm("muls.w %d3,%d5");
  asm("sub.l %d5,%d1");
  asm("add.l %d6,%d2");
  asm("add.l %a2,%d1");
  asm("add.l %a3,%d2");
  asm("asr.l %0,%%d1"::"g"(SINCOS + ZOOM));
  asm("asr.l %0,%%d2"::"g"(SINCOS + ZOOM));
  asm("move.w %d1,%a1@+");
  asm("move.w %d2,%a1@+");
  asm("dbra %d0,loopM7S");
// computing of m7vectorsL
  asm("neg.w %d3");
  asm("lea m7vectors,%a0");
  asm("lea m7vectorsL,%a1");
  asm("moveq %0,%%d0"::"g"(SIZE_Y-1));
  asm("loopM7V:");
  asm("move.w %a0@+,%d1");
  asm("move.w %d1,%d2");
  asm("muls.w %d3,%d1");
  asm("muls.w %d4,%d2");
  asm("asr.l %0,%%d1"::"g"(SINCOS + ZOOM));
  asm("asr.l %0,%%d2"::"g"(SINCOS + ZOOM));
  asm("move.l %d1,%a1@+");
  asm("move.l %d2,%a1@+");
  asm("dbra %d0,loopM7V");


  asm("movea.l MapTiles,%a4");
  asm("movea.w TilesOffset,%a6");
  asm("movea.l Plane0,%a0");
  asm("movea.l Plane1,%a1");
  asm("lea %%a0@(%c0),%%a0"::"g"(2*(OFFSET_SCR_HORZ+ 15*OFFSET_SCR_VERT)));
  asm("lea %%a1@(%c0),%%a1"::"g"(2*(OFFSET_SCR_HORZ+ 15*OFFSET_SCR_VERT)));
  asm("lea m7startsL,%a2");
  asm("lea m7vectorsL,%a3");
#if ENABLE_MULTI_RES == 1
  asm("move.w %0,%%d0"::"g"(MULTI_RES_CUT-1));
#else
  asm("move.w %0,%%d0"::"g"(SIZE_Y-1));
#endif
  asm("loopj:");
  asm("swap %d0");
  asm("move.w %a2@+,%d1");
  asm("move.w %a2@+,%d2");
  asm("moveq #0,%d3");
  asm("moveq #0,%d4");
  asm("move.w %0,%%d0"::"g"((SIZE_X*ZOOM_SCR_HORZ/16)-1));
  asm("loopi:");
  asm("clr.w %a0@");
  asm("clr.w %a1@");

#if ZOOM_SCR_HORZ <= 8
  IN_MAP_ASM(0)
  IN_MAP_ASM(ZOOM_SCR_HORZ)
#endif

#if ZOOM_SCR_HORZ <= 4
  IN_MAP_ASM(ZOOM_SCR_HORZ * 2)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 3)
#endif

#if ZOOM_SCR_HORZ <= 2
  IN_MAP_ASM(ZOOM_SCR_HORZ * 4)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 5)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 6)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 7)
#endif

#if ZOOM_SCR_HORZ == 1
  IN_MAP_ASM(ZOOM_SCR_HORZ * 8)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 9)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 10)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 11)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 12)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 13)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 14)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 15)
#endif

#if ZOOM_SCR_VERT == 2
  asm("move.w %a0@,%a0@(30)");
  asm("move.w %a1@,%a1@(30)");
#endif

  asm("addq.l #2,%a0");
  asm("addq.l #2,%a1");

  asm("dbra %d0,loopi");
  asm("addq.l #8,%a3");
  asm("swap	%d0");	
  asm("lea %%a0@(%c0),%%a0"::"g"(2*(15*ZOOM_SCR_VERT-((ZOOM_SCR_HORZ*SIZE_X)/16))));
  asm("lea %%a1@(%c0),%%a1"::"g"(2*(15*ZOOM_SCR_VERT-((ZOOM_SCR_HORZ*SIZE_X)/16))));
  asm("dbra %d0,loopj");


#if ENABLE_MULTI_RES == 1
  asm("move.w %0,%%d0"::"g"(((SIZE_Y-MULTI_RES_CUT)/2) - 1));
  asm("loopj2:");
  asm("swap %d0");
  asm("move.w %a2@+,%d1");
  asm("move.w %a2@,%d2");
  asm("addq.l #6,%a2");
  asm("moveq #0,%d3");
  asm("moveq #0,%d4");
  asm("move.w %0,%%d0"::"g"((SIZE_X*ZOOM_SCR_HORZ/16)-1));
  asm("loopi2:");
  asm("clr.w %a0@");
  asm("clr.w %a1@");

#if ZOOM_SCR_HORZ <= 8
  IN_MAP_ASM(0)
  IN_MAP_ASM(ZOOM_SCR_HORZ)
#endif

#if ZOOM_SCR_HORZ <= 4
  IN_MAP_ASM(ZOOM_SCR_HORZ * 2)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 3)
#endif

#if ZOOM_SCR_HORZ <= 2
  IN_MAP_ASM(ZOOM_SCR_HORZ * 4)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 5)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 6)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 7)
#endif

#if ZOOM_SCR_HORZ == 1
  IN_MAP_ASM(ZOOM_SCR_HORZ * 8)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 9)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 10)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 11)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 12)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 13)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 14)
  IN_MAP_ASM(ZOOM_SCR_HORZ * 15)
#endif

  asm("move.w %a0@,%a0@(30)");
  asm("move.w %a1@,%a1@(30)");

  asm("addq.l #2,%a0");
  asm("addq.l #2,%a1");

  asm("dbra %d0,loopi2");
  asm("add.l #16,%a3");
  asm("swap	%d0");	
  asm("lea %%a0@(%c0),%%a0"::"g"(2*(15*2-((ZOOM_SCR_HORZ*SIZE_X)/16))));
  asm("lea %%a1@(%c0),%%a1"::"g"(2*(15*2-((ZOOM_SCR_HORZ*SIZE_X)/16))));
  asm("dbra %d0,loopj2");
#endif

  asm("movem.l %a7@+,%d0-%d7/%a0-%a6"); // pops all registers
}


bon je sais que c'est de l'asm inline invalide (car je dit pas a gcc que je detruit les registres etc... Kevin m'a déjà expliqué pourquoi) mais bon en attendant que je modifie ca ca marche très bien tongue

C'est surtout dans la macro que je dois optimiser au max.
Si vous avez le temps de regarder smile
Merci beaucoup
Auteur de Mode7 Engine pour ti68k
Auteur de F-ZERO for TI68k
Membre de Orage Studio
Mon site perso : http://www.tigen.org/lionela/
Le gite de mes parents à coté de Narbonne :
http://chaletdenis.free.fr/

213

Pourquoi tu ne mets pas ta routine dans un fichier .s à part ?
ça éviterait de faire l'inline sick
avatar
« Quand le dernier arbre sera abattu, la dernière rivière empoisonnée, le dernier poisson capturé, alors vous découvrirez que l'argent ne se mange pas. »

214

Oui, c'est plus lisible. Mais peut-être que ça empêche l'inline. Ca fait trop longtemps que je programme plus, un pro te diras.
avatar
Un site complet sur lequel vous trouverez des programmes et des jeux pour votre calculatrice TI 89 / Titanium / 92+ / Voyage 200 : www.ti-fr.com.
Quelques idées personnelles ici.

215

il faudrait en effet mais plusieurs raisons :

1) je ne sais pas comment faire (mais ca doit etre facile a résoudre)
2) je dois utiliser des constantes du preprocesseur C et c'est ca qui coince.
je pourrais eventuellement les redefinir avec des .equ mais ca obligerait a refaire 2 fois tous les settings du moteur -> source d'erreur et d'emmerdements
Auteur de Mode7 Engine pour ti68k
Auteur de F-ZERO for TI68k
Membre de Orage Studio
Mon site perso : http://www.tigen.org/lionela/
Le gite de mes parents à coté de Narbonne :
http://chaletdenis.free.fr/

216

- tu peux utiliser le préprocesseur sans asm inline :
#define tostring_noexpand(x) #x
#define tostring(x) tostring_noexpand(x)

Ca te permet d'écrire asm("move.w #" tostring(123) ",d0"), et ça te permet de déplacer ton code dans un bloc en dehors de toute fonction C smile (et accessoirement ça te protège de bugs si par hasard tu veux changer un #define constant en un paramètre variable : avec le code que tu as posté, ça cassera sans te prévenir en détruisant un registre au hasard sick alors qu'avec cette solution, tu as une erreur claire)

- sinon, tu peux utiliser un compilateur qui supporterait l'utilisation de constantes du préprocesseur C directement dans du code ASM #tridiscret#

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

217

as supporte pourtant
#define
non ?

218

Il me semble aussi que oui, vu qu'il utilise cpp
avatar
Proud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

219

Alors quand est ce qu'on en verra la couleur??

220

cerede2000> prevu avant la fin de l'année (novembre)
Sinon Kevin me dit que c'est obligé de redefinir les constantes avec .equ
Auteur de Mode7 Engine pour ti68k
Auteur de F-ZERO for TI68k
Membre de Orage Studio
Mon site perso : http://www.tigen.org/lionela/
Le gite de mes parents à coté de Narbonne :
http://chaletdenis.free.fr/

221

Tu peux toujours preprocesser ton .s par cpp.

222

Pas bête ça smile

223

En novembre oua!!!! Avec le temps que tu ora passer dessus et au vu des premieres beta qui date ce jeu va etre plus que du tonnerre j'en ai deja l'eau a la bouche!!!!!!! smilesmilesmilesmile

224

Quand on dit novembre ça signifie décembre au plus tôt

225

#pollux#
avatar
Proud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

226

jfg :
Quand on dit novembre ça signifie décembre au plus tôt


decembre 2042 grin
Site personnel
Site professionnel

msn / mail : racine.f(at)free.fr

227

trioui
avatar
Proud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

228

Merci smile j'ai utilisé l'astuce de Pollux et ca donne ca :

#define ts_nx(x) #x 
#define ts(x) ts_nx(x)

#define IN_MAP_ASM(SHIFT) "
move.l %d4,%d5
asr.l #(" ts(RENDER_SHARPNESS) "),%d5
add.w %d1,%d5
move.l %d3,%d6
asr.l #(" ts(RENDER_SHARPNESS) "),%d6
add.w %d2,%d6

move.w %d5,%d7
swap %d7
move.w %d6,%d7
asr.w #(" ts(TILES_SHIFT) "),%d5
asl.w #(" ts(10-TILES_SHIFT) "),%d5
asr.w #(" ts(TILES_SHIFT) "),%d7
add.w %d7,%d5
lsl.w #2,%d5
swap %d7
lea %a4@(%d5.w),%a5
and.w #(" ts(TILES_SIZE - 1) "),%d6
and.w #(" ts(TILES_SIZE - 1) "),%d7
asl.w #(" ts(TILES_SHIFT) "),%d7
add.w %d6,%d7
movea.l %a5@,%a5
adda %d7,%a5
add.l %a3@,%d4
add.l %a3@(4),%d3

tst.b %a5@
.word 0x6704 | beq +4
or.w #(" ts(PIX >> (SHIFT)) "),%a0@
adda.w %a6,%a5
tst.b %a5@
.word 0x6704 | beq +4
or.w #(" ts(PIX >> (SHIFT)) "),%a1@
"

asm("
.text
m7_DrawFrame:
movem.l %d0-%d7/%a0-%a6,%a7@- | pushes all registers
move.w Dir,%d0
lea SinTable,%a0
lea CosTable,%a1
moveq #0,%d3
moveq #0,%d4
move.b %a0@(%d0.w),%d3
ext.w %d3
move.b %a1@(%d0.w),%d4
ext.w %d4
| computing of m7startsL
lea m7starts,%a0
lea m7startsL,%a1
move.w Y,%a2
move.w X,%a3
moveq #(" ts(SIZE_Y-1) "),%d0
loopM7S:
move.w %a0@+,%d1
move.w %d1,%d2
move.w %a0@+,%d5
move.w %d5,%d6
muls.w %d4,%d1
muls.w %d3,%d2
muls.w %d4,%d6
muls.w %d3,%d5
sub.l %d5,%d1
add.l %d6,%d2
add.l %a2,%d1
add.l %a3,%d2
asr.l #(" ts(SINCOS + ZOOM) "),%d1
asr.l #(" ts(SINCOS + ZOOM) "),%d2
move.w %d1,%a1@+
move.w %d2,%a1@+
dbra %d0,loopM7S
| computing of m7vectorsL
neg.w %d3
lea m7vectors,%a0
lea m7vectorsL,%a1
moveq #(" ts(SIZE_Y-1) "),%d0
loopM7V:
move.w %a0@+,%d1
move.w %d1,%d2
muls.w %d3,%d1
muls.w %d4,%d2
asr.l #(" ts(SINCOS + ZOOM) "),%d1
asr.l #(" ts(SINCOS + ZOOM) "),%d2
move.l %d1,%a1@+
move.l %d2,%a1@+
dbra %d0,loopM7V

movea.l MapTiles,%a4
movea.w TilesOffset,%a6
movea.l Plane0,%a0
movea.l Plane1,%a1
lea %a0@(" ts(2*(OFFSET_SCR_HORZ+ 15*OFFSET_SCR_VERT)) "),%a0
lea %a1@(" ts(2*(OFFSET_SCR_HORZ+ 15*OFFSET_SCR_VERT)) "),%a1
lea m7startsL,%a2
lea m7vectorsL,%a3
"
#if ENABLE_MULTI_RES == 1
"
move.w #(" ts(MULTI_RES_CUT-1) "),%d0
"
#else
"
move.w #(" ts(SIZE_Y-1) "),%d0
"
#endif
"
loopj:
swap %d0
move.w %a2@+,%d1
move.w %a2@+,%d2
moveq #0,%d3
moveq #0,%d4
move.w #(" ts((SIZE_X*ZOOM_SCR_HORZ/16)-1) "),%d0
loopi:
clr.w %a0@
clr.w %a1@
"
#if ZOOM_SCR_HORZ <= 8
IN_MAP_ASM(0)
IN_MAP_ASM(ZOOM_SCR_HORZ)
#endif

#if ZOOM_SCR_HORZ <= 4
IN_MAP_ASM(ZOOM_SCR_HORZ * 2)
IN_MAP_ASM(ZOOM_SCR_HORZ * 3)
#endif

#if ZOOM_SCR_HORZ <= 2
IN_MAP_ASM(ZOOM_SCR_HORZ * 4)
IN_MAP_ASM(ZOOM_SCR_HORZ * 5)
IN_MAP_ASM(ZOOM_SCR_HORZ * 6)
IN_MAP_ASM(ZOOM_SCR_HORZ * 7)
#endif

#if ZOOM_SCR_HORZ == 1
IN_MAP_ASM(ZOOM_SCR_HORZ * 8)
IN_MAP_ASM(ZOOM_SCR_HORZ * 9)
IN_MAP_ASM(ZOOM_SCR_HORZ * 10)
IN_MAP_ASM(ZOOM_SCR_HORZ * 11)
IN_MAP_ASM(ZOOM_SCR_HORZ * 12)
IN_MAP_ASM(ZOOM_SCR_HORZ * 13)
IN_MAP_ASM(ZOOM_SCR_HORZ * 14)
IN_MAP_ASM(ZOOM_SCR_HORZ * 15)
#endif

#if ZOOM_SCR_VERT == 2
"
move.w %a0@,%a0@(30)
move.w %a1@,%a1@(30)
"
#endif
"
addq.l #2,%a0
addq.l #2,%a1

dbra %d0,loopi
addq.l #8,%a3
swap	%d0	
lea %a0@(" ts(2*(15*ZOOM_SCR_VERT-((ZOOM_SCR_HORZ*SIZE_X)/16))) "),%a0
lea %a1@(" ts(2*(15*ZOOM_SCR_VERT-((ZOOM_SCR_HORZ*SIZE_X)/16))) "),%a1
dbra %d0,loopj
"
#if ENABLE_MULTI_RES == 1
"
move.w #(" ts(((SIZE_Y-MULTI_RES_CUT)/2) - 1) "),%d0
loopj2:
swap %d0
move.w %a2@+,%d1
move.w %a2@,%d2
addq.l #6,%a2
moveq #0,%d3
moveq #0,%d4
move.w #(" ts((SIZE_X*ZOOM_SCR_HORZ/16)-1) "),%d0
loopi2:
clr.w %a0@
clr.w %a1@
"

#if ZOOM_SCR_HORZ <= 8
IN_MAP_ASM(0)
IN_MAP_ASM(ZOOM_SCR_HORZ)
#endif

#if ZOOM_SCR_HORZ <= 4
IN_MAP_ASM(ZOOM_SCR_HORZ * 2)
IN_MAP_ASM(ZOOM_SCR_HORZ * 3)
#endif

#if ZOOM_SCR_HORZ <= 2
IN_MAP_ASM(ZOOM_SCR_HORZ * 4)
IN_MAP_ASM(ZOOM_SCR_HORZ * 5)
IN_MAP_ASM(ZOOM_SCR_HORZ * 6)
IN_MAP_ASM(ZOOM_SCR_HORZ * 7)
#endif

#if ZOOM_SCR_HORZ == 1
IN_MAP_ASM(ZOOM_SCR_HORZ * 8)
IN_MAP_ASM(ZOOM_SCR_HORZ * 9)
IN_MAP_ASM(ZOOM_SCR_HORZ * 10)
IN_MAP_ASM(ZOOM_SCR_HORZ * 11)
IN_MAP_ASM(ZOOM_SCR_HORZ * 12)
IN_MAP_ASM(ZOOM_SCR_HORZ * 13)
IN_MAP_ASM(ZOOM_SCR_HORZ * 14)
IN_MAP_ASM(ZOOM_SCR_HORZ * 15)
#endif

"
move.w %a0@,%a0@(30)
move.w %a1@,%a1@(30)

addq.l #2,%a0
addq.l #2,%a1

dbra %d0,loopi2
add.l #16,%a3
swap	%d0	
lea %a0@(" ts(2*(15*2-((ZOOM_SCR_HORZ*SIZE_X)/16))) "),%a0
lea %a1@(" ts(2*(15*2-((ZOOM_SCR_HORZ*SIZE_X)/16))) "),%a1
dbra %d0,loopj2
"
#endif
"
movem.l %a7@+,%d0-%d7/%a0-%a6 | pops all registers
rts
");


comme ca j'ai qu'un seul asm(""); et c'est valide smile
Sinon personne ne detecte une petite optimisation ? ca serait vraiment cool

PS: je parle de novembre 2005 wink
Auteur de Mode7 Engine pour ti68k
Auteur de F-ZERO for TI68k
Membre de Orage Studio
Mon site perso : http://www.tigen.org/lionela/
Le gite de mes parents à coté de Narbonne :
http://chaletdenis.free.fr/

229

trop long, flemme de lire hehe

(HS : argl, je savais pas que ça marchait avec GCC, de faire #define machin "ligne1
ligne2" sans mettre d'antislash après ligne1... enfin maintenant c'est "deprecated" dans la version officielle, mais pas dans TIGCC)

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

230

En effet, GCC officiel != TIGCC, mais tant que c'est pour le bien des utilisateurs (garder compatibilité antérieure)...
avatar
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
Co-admin de TI-Planet.

231

Ba (non merci de ne pas troller..)

C'est aussi une mauvaise idée :/ mettre un warning "déprecated" serait une bonne idée, sinon certain risquerais de prendre de mauvaise habitudes sorry

et la compatibilité c'est bien, jusqu'a un certain point. Ce genre de fonctionalitée est loin d'etre indispensable, et demande peu de remaniement sur le code donc bon, l'enlever ne ferrais pas tant de mal que ça
avatar
Proud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

232

up

petite question, je dois calculer la direction et le sens d'un vecteur que j'obtiens a partir de 2 points (x1,y1) et (x2,y2).
la direction est dans [0,NBDIR[
comment je fais ?
j'ai pensé a faire des tables de cos et sin inversées et a chercher la direction correspondant aux deux valeurs x et y du vecteur après l'avoir normalisé mais je sais pas s'il y a pas mieux question rapidité smile
Auteur de Mode7 Engine pour ti68k
Auteur de F-ZERO for TI68k
Membre de Orage Studio
Mon site perso : http://www.tigen.org/lionela/
Le gite de mes parents à coté de Narbonne :
http://chaletdenis.free.fr/

233

Mmm, ça dépend de NBDIR.
S'il est assez petit, genre < 32, tu peux t'en sortir avec une table de sin et cos et des multiplications ( ~ NBDIR/4 multiplications )
Sinon tu peux utiliser une table d'arctan et du coup faire une division, comme dans la routine ci dessus, qui retourne un angle entre 0 et 255 :

char arctan255[33]={0,1,3,4,5,6 ,8,9,10,11,12, 13,15,16,18,19, 20,21,22,23,24, 25,25,26,27,28, 29,29,30,30,31 ,32,32};

unsigned char arctan(int start_x,int start_y,int goal_x,int goal_y)
{
int dx = (goal_x-start_x);
int dy = (goal_y-start_y);
unsigned char angle;
int shift=0;
int ratio;

if (dx==0&&dy==0)
return 0;

if (ABS(dy)>ABS(dx))
{
ratio = ABS((dx*32)/dy);
shift = 1;
}
else
ratio = ABS((dy*32)/dx);

angle = arctan255[ratio];
if (shift)
angle=64-angle;

if (dx<0)
angle=128-angle;

if (dy>0)
angle=256-angle;

return angle;
}

La précision peut être facilement améliorée, suffit d'avoir une table d'arctan de 128, 256... valeurs et de changer le ratio = ABS((dx*32)/dy) en conséquence.
En tout cas, pas besoin de normaliser wink

234

En fait, on y réflèchissant bien, ya moyen d'utiliser un nombre restreint de multiplications ( ~ ln NBDIR ) en utilisant un algo de recherche dichotomique. Mais bon, la routine précédente peut convenir, ça dépend combien de fois tu l'utilises par frame !

235

ah ouais merci smile

entre temps j'avais fait ça :
signed short Py;
signed short proj = 0;
unsigned short z;
		
for (z = NBDIR; z--; ) {
	Py = (dy * CosTable[z] + dx * SinTable[z]);
	if (proj < Py) {
		proj = Py;
		angle = z;
	}
}


est ce que c'est plus rapide ?
Auteur de Mode7 Engine pour ti68k
Auteur de F-ZERO for TI68k
Membre de Orage Studio
Mon site perso : http://www.tigen.org/lionela/
Le gite de mes parents à coté de Narbonne :
http://chaletdenis.free.fr/

236

lol
en fait c'est la méthode à laquelle je faisais allusion au tout début ( le truc avec ~ NBDIR/4 multiplications )
Si NBDIR est grand, cette routine peut générer bcp de multiplications, et alors une division peut être plus rapide ( je sais pas exactement après cbien de multiplications smile )

Tu peux faire plus rapide avec une recherche dichotomique. Pour cela, tu te limites au premier quadrant ( ie dx > 0 et dy > 0 ), et tu utilises le fait que la fonction arctan est croissante sur [ 0, pi/2 ] = [ 0, nbdir/ 4 ].
Concrètement, tu coupes l'intervalle en deux à chaque fois.
Le premier c'est [0,nbdir/ 4], si dy * Cos( nbdir/ 8 ) >=dx * Sin( nbdir/ 8 ), alors tu continues dans l'intervalle [ nbdir/ 8,nbdir/ 4], sinon tu vas dans [0,nbdir/8]. Et tu recommences la même opération jusqu'à ce que t'arrives à un intervalle avec une seule valeur...

J'ai pas testé la méthode, donc dsl si ça marche pas. Mais si ça marche smile, tu t'en sors avec 2 * log2( NBDIR) multiplications, ce qui peut être pas mal utile quand NBDIR est grand... D'ailleurs tu veux pas dire combien il vaut ton NBDIR ? tongue

237

ok je vais essayer de faire le parcours dichotomique merci bien smile
excuse moi j'ai oublié de préciser pour NBDIR, il vaut 256 smile
Auteur de Mode7 Engine pour ti68k
Auteur de F-ZERO for TI68k
Membre de Orage Studio
Mon site perso : http://www.tigen.org/lionela/
Le gite de mes parents à coté de Narbonne :
http://chaletdenis.free.fr/

238

Ok, avec 256 le parcours dichotomique ça devient intéressant,..... tout comme la routine avec la division d'ailleurs wink
A toi de bencher !

239

Enfin la méthode la plus simple si tu as besoin d'un truc pas trop lent c'est qd même de se ramener à l'intervalle [0,Pi/4] par symétrie, puis faire un lookup dans une table en fonction du quotient y*K/x ^^ (avec K de l'ordre de NBDIR)

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

240

Ouais, c'est la routine postée en >232 wink
256 angles, avec la dichotomie ça fait genre 12 multiplications, est-ce plus rapide qu'une division ? ( à mon avis non ...)