affichage d'un sprite pour un nioob - Page 1

bon je pige pas pourquoi la fonction ci dessous ne fonctionne pas, j'ai une adresse erreur ,
je sais que ca fait genre, "voila mon code corrigez le" mais c'est mon premier progr asm que j'ai fait tout seul et je ne sais pas mais vraiment pas d'où peut venir l'erreur surtout que je ne sais pas comment verifier mes resultats, c une fonction inline
on a d1=x,y=d2,void *sprite=a0,void* buffer =a1

move.w  %d1,%d0  ;
lsr.w   #3,%d0   ;a priori d0=(short)x/8 
adda.w  %d0,%a1  ;on ajoute x/8 a l'adresse du buffer
sub.w   %d1,%d0  ;a priori d0=x%8
sub.w   #32,%d0   ; d0=32-x%8
move.w  %d2,%d1  ;
lsl.w   #5,%d2   ;on multiplie par 32
lsl.w   #1,%d1   ;on multiplie par 2
sub.w   %d2,%d1  ;a priori d1=y*30
adda.w  %d1,%a1  ;on ajoute y*30 a l'adresse du buffer

move.b  (%a0)+,%d1 ; le premier byte du srpite ds %d1
move.l  %d1,%d1    ; est ce que c'est comme ca pour convertir en long ??????
lsl.l   %d0,%d1    ; on decale de 32-x%8 donc normalement c'est comme si on le mettait a l'adresse buffer +y*30+ x/8 +x%8, cad la ou on veut
move.l  %d1,(%a1)  ; on l'affiche
move.b  (%a0)+,%d1 ; on continue encore 7 fois
move.l  %d1,%d1
lsl.l   %d0,%d1
move.l  %d1,30*1(%a1)
move.b  (%a0)+,%d1
move.l  %d1,%d1
lsl.l   %d0,%d1
move.l  %d1,30*2(%a1)
move.b  (%a0)+,%d1
move.l  %d1,%d1
lsl.l   %d0,%d1
move.l  %d1,30*3(%a1)
move.b  (%a0)+,%d1
move.l  %d1,%d1
lsl.l   %d0,%d1
move.l  %d1,30*4(%a1)
move.b  (%a0)+,%d1
move.l  %d1,%d1
lsl.l   %d0,%d1
move.l  %d1,30*5(%a1)
move.b  (%a0)+,%d1
move.l  %d1,%d1
lsl.l   %d0,%d1
move.l  %d1,30*6(%a1)
move.b  (%a0)+,%d1
move.l  %d1,%d1
lsl.l   %d0,%d1
move.l  %d1,30*7(%a1)

Sans regarder vraiment ton code en détails, l'adress error vient du fait que tu écrives un word ou un longword à une adresse impaire.
Il faut que tu modifies ton code pour n'afficher qu'à des adresses paires (c'est au début que ça pose problème : quand tu convertis x en octets).

comment ca ?, lsr.w #3,%d0 fournit forcement un chiffre pair non?

move.w  %d1,%d0  ;
lsr.w   #3,%d0   ;a priori d0=(short)x/8 
adda.w  %d0,%a1  ;on ajoute x/8 a l'adresse du buffer
sub.w   %d1,%d0  ;a priori d0=x%8
sub.w   #32,%d0   ; d0=32-x%8
move.w  %d2,%d1  ;
lsl.w   #5,%d2   ;on multiplie par 32
lsl.w   #1,%d1   ;on multiplie par 2
sub.w   %d2,%d1  ;a priori d1=y*30
adda.w  %d1,%a1  ;on ajoute y*30 a l'adresse du buffer

move.b  (%a0)+,%d1; le premier byte du srpite ds %d1
ext %d1  ; on convertit un byte en long
ext %d1
lsl.l   %d0,%d1; on decale de 32-x%8 donc normalement c'est comme si on le mettait a l'adresse buffer +y*30+ x/8 +x%8, cad la ou on veut
move.l  %d1,(%a1); on l'affiche
move.b  (%a0)+,%d1; on continue encore 7 fois
ext %d1 
ext %d1
lsl.l   %d0,%d1
move.l  %d1,30*1(%a1)
move.b  (%a0)+,%d1
ext %d1 
ext %d1
lsl.l   %d0,%d1
move.l  %d1,30*2(%a1)
move.b  (%a0)+,%d1
ext %d1 
ext %d1
lsl.l   %d0,%d1
move.l  %d1,30*3(%a1)
move.b  (%a0)+,%d1
ext %d1 
ext %d1
lsl.l   %d0,%d1
move.l  %d1,30*4(%a1)
move.b  (%a0)+,%d1
ext %d1 
ext %d1
lsl.l   %d0,%d1
move.l  %d1,30*5(%a1)
move.b  (%a0)+,%d1
ext %d1 
ext %d1
lsl.l   %d0,%d1
move.l  %d1,30*6(%a1)
move.b  (%a0)+,%d1
ext %d1 
ext %d1
lsl.l   %d0,%d1
move.l  %d1,30*7(%a1)

j'ai juste corrigé la conversion en long mais ca marche tjours pas

Non, ça dépend du 4^ème bit de ton opérande.

Deux ext sur d1 à la suite ne servent à rien.
Comment veux-tu que l'assembleur (ou le processeur) devine que le premier est un ext.w et le deuxième un ext.l ?

De toute façon, ce n'est pas correct dans ton cas : l'instruction ext étend le signe d'une opérande, donc si le MSB de ton sprite est armé, on aura des 1 dans toute la partie haute du registre.

En fait, il ne faut pas vraiment convertir ta valeur sur 32 bits de cette façon. Il faut utiliser le registre sur 32 bits directement.
Puisque ça n'a pas de sens de convertir ta valeur sur 32 bits puisqu d0 ne contient pas un nombre, mais un motif, donc une extension du signe devient gênante.

Pour pouvoir utiliser les 32 bits de ton registre, tu dois au préalable le rendre utilisable, en effaçant sa partie haute, de façon à ce qu'elle ne parasite pas le motif du sprite.

euh....... si je fais un clr.l %d1 avant de faire move.b (%a0)+,%d1 ca le fait ??

Oui.

Tu peux également utiliser un moveq.l #0,d1 ça sera plus rapide

Notre version de GNU as change ça automatiquement (petit hack parce que GCC sort parfois des clr.l %dn).

C'est dangereux je trouve, ce genre de trucs.
Par exemple si qq1 veut faire du smc pour modifier le clr.l en clr.w, il écrira l'instruction moveq.l #64,dn

encore une question : est ce qu'il ya une difference de vitesse entre move.b, move.w et move.l ? et pour lsl.b, lsl.w lsl.l ?

ca y'est j'ai reussi, pour tout les newbies en asm comme moi (doit pas y'en avoir bcoup) , voila mon code : void sprite8_w(short decalage asm("%d0"),void *sprite asm("a0"),void *buffer asm("a1")) { asm(" clr.w %d1 move.b  (%a0)+,%d1 lsl.w   %d0,%d1 move.w  %d1,(%a1) clr.w %d1 move.b  (%a0)+,%d1 lsl.w   %d0,%d1 move.w  %d1,30*1(%a1) clr.w %d1 move.b  (%a0)+,%d1 lsl.w   %d0,%d1 move.w  %d1,30*2(%a1) clr.w %d1 move.b  (%a0)+,%d1 lsl.w   %d0,%d1 move.w  %d1,30*3(%a1) clr.w %d1 move.b  (%a0)+,%d1 lsl.w   %d0,%d1 move.w  %d1,30*4(%a1) clr.w %d1 move.b  (%a0)+,%d1 lsl.w   %d0,%d1 move.w  %d1,30*5(%a1) clr.w %d1 move.b  (%a0)+,%d1 lsl.w   %d0,%d1 move.w  %d1,30*6(%a1) clr.w %d1 move.b  (%a0)+,%d1 lsl.w   %d0,%d1 move.w  %d1,30*7(%a1)"); } void sprite8_l(short decalage asm("%d0"),void *sprite asm("a0"),void *buffer asm("a1")) { asm("     clr.l %d1 move.b  (%a0)+,%d1 lsl.l   %d0,%d1 move.l  %d1,(%a1) clr.l %d1 move.b  (%a0)+,%d1 lsl.l   %d0,%d1 move.l  %d1,30*1(%a1) clr.l %d1 move.b  (%a0)+,%d1 lsl.l   %d0,%d1 move.l  %d1,30*2(%a1) clr.l %d1 move.b  (%a0)+,%d1 lsl.l   %d0,%d1 move.l  %d1,30*3(%a1) clr.l %d1 move.b  (%a0)+,%d1 lsl.l   %d0,%d1 move.l  %d1,30*4(%a1) clr.l %d1 move.b  (%a0)+,%d1 lsl.l   %d0,%d1 move.l  %d1,30*5(%a1) clr.l %d1 move.b  (%a0)+,%d1 lsl.l   %d0,%d1 move.l  %d1,30*6(%a1) clr.l %d1 move.b  (%a0)+,%d1 lsl.l   %d0,%d1 move.l  %d1,30*7(%a1)"); } void sprite8_b(void *sprite asm("a0"),void *buffer asm("a1")) {       asm("move.b   (%a0)+,(%a1)     move.b   (%a0)+,30*1(%a1)     move.b   (%a0)+,30*2(%a1)     move.b   (%a0)+,30*3(%a1)     move.b   (%a0)+,30*4(%a1)     move.b   (%a0)+,30*5(%a1)     move.b   (%a0)+,30*6(%a1)     move.b   (%a0)+,30*7(%a1)"); } void sprite8(short x, short y,void *sprite, void * buffer) {      short xo=(x>>3),xb=x%8;   if(xo%2!=0 && xb!=0)xo--,xb+=8;   void *offset = buffer+(y<<5)-(y<<1)+xo;   if(xb>0 && xb<8)   {      sprite8_w(8-xb,sprite,offset);      return;   }   if(xb>8)   {    sprite8_l(24-xb,sprite,offset);return;   }        sprite8_b(sprite,offset);    }
mais maintenant faut que je la fasse en or parce que sa remplace tout zone de l'ecran si on utilise sprite8_w ou l

en tout cas merci infiniment sasume et kevin

et puis dsl sasume mais moveq.w #0,%d1 genere une erreur dans tigcc, c'est pourqoui je n'ai utilisé que des clr

et encore un truc, comment on fait pour enlever les pseudo-warnings de tigcc comme quoi on a defini une variable ou mis en argument un truc mais qu'on l'utilise pas ?

./12 Oui (enfin, ça dépend de tes opérandes), pour plus d'infos [google]68000UM.pdf[/google]
./14 C'est parce que l'instruction moveq porte obligatoirement sur un longword, pour plus d'infos [google]68KPM.pdf[/google]

ah merci !!!!!!
et euh... dans ds l'asm inline, pour faire une subroutine, on utilise xdef nom_fonction et rts a la fin ?
et pour faire un bsr apres un comp, on fait un bne normal ?

bidoo
: et euh... dans ds l'asm inline, pour faire une subroutine, on utilise xdef nom_fonction et rts a la fin ?

On utilise nom_fonction: surtout. Et effectivement rts à la fin.

et pour faire un bsr apres un comp, on fait un bne normal ?

Non, on fait beq.s 0f;jbsr foo;0:.

a ouéééé , c hyper astucieux merci kevin
mais j'ai un doute tout d'un coup, est ce que la fonction Sprite8 de tigcclib fait la meme chose ? est elle plus rapide ?

<troll>
au fait c vraiment illisible ton code bourré de %
</troll>

./19> La fonction Sprite8 fait en gros la même chose, mais elle gère plusieurs modes d'affichage, mais sa boucle n'est pas du tout déroulée donc elle prend beaucoup moins de place que la tienne.

ouf ... j'avais peur de faire tous ca pour rien
sprite8 est donc un un peu plus lente

de toute facon je vais optimiser tous ca pour avoir un minimum de cycle processeur

j'ai encore une petite question , j'arrive pas a comprendre comment on gere les float en memoire j'ai cru comprendre qu'il fallait un word pour la partie non-entiere et 2 longs pour la partie entiere mais pourquoi lorsque je met float a=0, tigcc met 16384 dans le word et si je met 1 dans 'a' y met 268435456 dans le premier long et pour 2 il met 536870912 dans le meme long.
... la j'y comprend rien ....

qqun peut il m'expliquer le fonctionnement des float ?

oué je l'ai lu et relu et rerelu, ca m'aide toujours pas a comprendre,
je pige pas si on a a=1, normalement, e=1 et mantissa = 0 , ce n'est pas le cas : tigcc met 16384 dans e et 268435456 dans mantissa !

pourquoi ?

ah non j'ai dis une betise : e=0 et mantissa = 1 pour un bcd=1
et puis 268435456 est codé sur 29 bits ....

comprend plus rien la ...

ok j'ai compriiiis c simple si j'ai un chiffre comme 456.21 je le transforme en $45621000 qui correspond a la mantissa et je met $4002 dans e non?

pour la mantissa, c'est ça, par contre pour l'exposant je sais plus

le mieux, c tjs d'essayer...