Arkanoid - Page 2

OK, je vais voir ce que ça donne.

Ca ne serait pas plutôt remplacer 48 par 4?

Oui.
D'ailleurs ça me fait penser que c'est sûrement optimisable alors.
Déjà, commence par remplacer le lea par un addq.
[edit] Ben non, je ne vois pas en fait.

J'ai modifié la routine pour pouvoir passer en argument 2 destinations, elle semble presque fonctionner.
Je te l'envoye pas mail ou je l'affiche ici?

En tout cas j'ai tout compris, mais reste juste un petit problème à corriger.

Si tu la mets ici, utilise la fonction source, parce que comme la boucle est déroulée, elle prend pas mal de place (surtout la version pour nvg).

;C prototype: void DrawGrayBuffer2 (short x, short y, void *src, void *dest1, void *dest2); ; ;void DrawGrayBuffer2(register short x asm("%d0"), ;                register short y asm("%d1"), ;                register void *src asm("%a0"), ;                register void *dest1 asm("%a2"), ;                register void *dest2 asm("%a3"));      section ".data"      xdef DrawGrayBuffer2 DrawGrayBuffer2:      movem.l     d2-d7/a1,-(a7)      add.w     d1,d1               ;d1=y*2      move.w     d1,d2               ;d2=d1=y*2      lsl.w     #4,d1               ;d1=32*y      add.w     d2,d2               ;d2=4*y      add.w     d2,d1               ;d1=y soit y*36            moveq.l     #15,d3               ;15=0b1111=décalage sur 32 bits      move.w     d0,d2               ;d2=x      and.w     d3,d0               ;d0=Bit à décaler      not.w     d3      and.w     d3,d2                ;d2=octet      add.w     d2,d1               ;Octet ou ce commence la copie            adda.w     d1,a0               ;Ce place dans la source            lea.l     8568(a0),a1          ;Prépare plan1            moveq.l     #127,d7               ;Prépare la boucle de 128 pixels            moveq.l     #$FFFFFFFF,d1          ;Tout les bits de 2^32 activé.      lsl.w     d0,d1               ; d1 = mask1      move.w     d1,d2      not.w     d2               ; d2 = mask2            ;d0=Bit à décaler      ;d1=mask1      ;d2=mask2      ;d7=boucle \LineStart:      move.l     (a0)+,d3      lsl.l     d0,d3      move.l     (a0)+,d4      rol.l     d0,d4      move.w     d4,d5      and.w     d2,d5      or.w     d5,d3      move.l     d3,(a2)+     ; 1      move.l     (a1)+,d5      lsl.l     d0,d5      move.l     (a1)+,d6      rol.l     d0,d6      move.w     d6,d3      and.w     d2,d3      or.w     d3,d5      move.l     d5,(a3)+      and.w     d1,d4      move.l     (a0)+,d3      rol.l     d0,d3      move.w     d3,d5      and.w     d2,d5      or.w     d5,d4      move.l     d4,(a2)+     ; 2      and.w     d1,d6      move.l     (a1)+,d5      rol.l     d0,d5      move.w     d5,d4      and.w     d2,d4      or.w     d4,d6      move.l     d6,(a3)+      and.w     d1,d3      move.l     (a0)+,d4      rol.l     d0,d4      move.w     d4,d6      and.w     d2,d6      or.w     d6,d3      move.l     d3,(a2)+     ; 3      and.w     d1,d5      move.l     (a1)+,d6      rol.l     d0,d6      move.w     d6,d3      and.w     d2,d3      or.w     d3,d5      move.l     d5,(a3)+      and.w     d1,d4      move.l     (a0)+,d3      rol.l     d0,d3      move.w     d3,d5      and.w     d2,d5      or.w     d5,d4      move.l     d4,(a2)+     ; 4      and.w     d1,d6      move.l     (a1)+,d5      rol.l     d0,d5      move.w     d5,d4      and.w     d2,d4      or.w     d4,d6      move.l     d6,(a3)+      and.w     d1,d3      move.l     (a0)+,d4      rol.l     d0,d4      move.w     d4,d6      and.w     d2,d6      or.w     d6,d3      move.l     d3,(a2)+     ; 5      and.w     d1,d5      move.l     (a1)+,d6      rol.l     d0,d6      move.w     d6,d3      and.w     d2,d3      or.w     d3,d5      move.l     d5,(a3)+      and.w     d1,d4      move.l     (a0)+,d3      rol.l     d0,d3      move.w     d3,d5      and.w     d2,d5      or.w     d5,d4      move.l     d4,(a2)+     ; 6      and.w     d1,d6      move.l     (a1)+,d5      rol.l     d0,d5      move.w     d5,d4      and.w     d2,d4      or.w     d4,d6      move.l     d6,(a3)+      and.w     d1,d3      move.l     (a0)+,d4      rol.l     d0,d4      and.w     d2,d4      or.w     d4,d3      move.l     d3,(a2)+     ; 7      and.w     d1,d5      move.l     (a1)+,d6      rol.l     d0,d6      and.w     d2,d6      or.w     d6,d5      move.l     d5,(a3)+      swap.w     d4      swap.w     d6      move.w     d4,(a2)+      move.w     d6,(a3)+      lea.l     6(a0),a0      lea.l     6(a1),a1      dbf     d7,\LineStart            movem.l     (a7)+,d2-d7/a1      rts

[EDIT] C'est lea 4 à la fin.

Non c'est bon elle fonctionne très bien, il suffit juste que je la 'clippe'.

Que tu la clippes ?
Au fait, relis le post ./33

w #3,d1 add.w d2,d1

Euh, j'ai une optimisation :    add.w   d1,d1
    add.w   d1,d1
    move.w  d1,d2
    lsl.

Ça prendra 2 cycles en moins !

Au fait, ce n'est pas la peine de sauver a1, tigcc le fait automatiquement. Par contre, il faut que tu sauves a2 et a3.

Moi j'en ai une autre:
mulu #36,d1
Ça prendra 6 octets en moins!
Avec certains ici, on se demande pourquoi Motorola a mis des instructions de multiplication dans leurs processeurs...

Sasume
: Au fait, ce n'est pas la peine de sauver a1, tigcc le fait automatiquement.

Même chose pour d2, d'ailleurs.

Oui, mais beaucoup de cycles en plus
geogeo recherche de la vitesse, sinon il n'aurait pas laissée la boucle déroulée.
Éventuellement, il peut remplacer les deux add par un lsl #2, et il gagnera 2 octet contre une perte de seulement 2 cycles.

Sasume
: geogeo recherche de la vitesse, sinon il n'aurait pas laissée la boucle déroulée.

Argh, en effet, en plus, il a fait du copier-coller du même code 7 fois... Les boucles, c'est pour les chiens???
C'est fou ce que certains gaspillent comme place! Le déroulement de la boucle gaspille une centaine d'octets!

Mais en même temps, enrouler la boucle la rendrait plus lente (hormis le fait qu'elle serait enroulée), parce qu'on n'aurait pas assez de registre pour que ça fonctionne comme ça le fait lorsque la boucle est déroulée, et en plus il faudrait changer quelques instructions ici et là pour que le code fonctionne.

Il y a a4-a6 qui sont libres. Donc on peut enrouler avec:

 lea (7).w,a4
loop:
 ...
 subq.w #1,a4
 cmpa.w #0,a4
 bne.s loop

Qu a dit qu'on ne peut mettre que des adresses dans les registres d'adresses?

Bof, je pense que ce sera plus court et surtout plus rapide d'utiliser par exemple la partie haute de d2 pour contenir le compteur de boucle et la partie basse pour contenir ce qu'il contient déjà actuellement (on utilise swap pour passer de l'un à l'autre).

Plus court, non. On gagne 4 octets en utilisant un registre de données (2 pour lea -> moveq, 2 pour cmpa #0 -> tst ou cmpa #0 et bne.s -> dbra.w), mais on en perd 4 pour les swap.

Que tu la clippes ?
Au fait, relis le post ./33

Ah je croyais que addq.l n'optimisé pas. C'est bon j'ai modifié.Idem pour y=y*36

Moi j'en ai une autre:

mulu #36,d1

Ça prendra 6 octets en moins! Avec certains ici, on se demande pourquoi Motorola a mis des instructions de multiplication dans leurs processeurs...

Euh, je recherche de la vitesse, je veux pas un scrolling de 1 fps.


J'ai réalisé une autre fonction simple qui efface le buffer de 17136 octets:

;C prototype: void ClearScreenBuffer (void *buffer);
;
;void ClearScreenBuffer (register void *buffer asm("%a0"));
	section ".data"
	xdef ClearScreenBuffer

ClearScreenBuffer:
	move.l	d1,-(a7)
	move.l	#237,d1
\clear_bcl:
	clr.l	(a0)
	clr.l	4(a0)
	clr.l	8(a0)
	clr.l	12(a0)
	clr.l	16(a0)
	clr.l	20(a0)
	clr.l	24(a0)
	clr.l	28(a0)
	clr.l	32(a0)
	clr.l	36(a0)
	clr.l	40(a0)
	clr.l	44(a0)
	clr.l	48(a0)
	clr.l	52(a0)
	clr.l	56(a0)
	clr.l	60(a0)
	clr.l	64(a0)
	clr.l	68(a0)
	lea	72(a0),a0
	dbf	d1,\clear_bcl
	move.l	(a7)+,d1
	rts

clr.l est horriblement lent? Ou je dois plutôt effacer un registre et le mettre ça valeur dans le buffer?

Il y a des manières nettement plus rapides d'effacer un buffer. Regarde du côté de movem...
Là, ton code est gros et lent.

Oui, ou bien utilie des movem, ça te permettra de moins dérouler, mais d'avoir quand même une très bonne vitesse.
Enfin, tu veux un jeu rapide, ok, mais à mon avis, il ne demandera pas non plus énormément de ressources donc ce n'est peut-être pa la peine de perdre trop de place avec que des fonctions déroulées.
Et pour ta fonction, rien que d'utiliser des clr.l (a0)+ te ferait gagner beaucoup de temps.

Bon je viens de faire ça:

ClearScreenBuffer:
	movem.l  d2-d7/a2,-(a7)
    	moveq    #0,d0
    	moveq    #0,d1
    	moveq    #0,d2
    	moveq    #0,d3
    	moveq    #0,d4
    	moveq    #0,d5
    	moveq    #0,d6
    	movea.l  d0,a1
    	movea.l  d0,a2
    	move.l    #476,d7
    	
clear_bcl:
	movem.l  d0-d6/a1-a2,-(a0)
    	movem.l  d0-d6/a1-a2,-(a0)
    	movem.l  d0-d6/a1-a2,-(a0)
    	movem.l  d0-d6/a1-a2,-(a0)
	dbf      d7,clear_bcl
	movem.l  (a7)+,d2-d7/a2
	rts

Or je comprend pas la calculatrice gêle.

Tu débordes probablement. Vérifie tes comptes.

Bah en retirant tout et en laissant juste moveq #0,d0 et movem.l d0,-(a0) ça freeze.
Le compilo aime pas que je passe un argument directement dans a0??

ça ne viendrait pas du -(a0) par hasard ?

ClearScreenBuffer:
	movem.l  d2-d7/a2,-(a7)
    	moveq    #0,d0
    	moveq    #0,d1
    	moveq    #0,d2
    	moveq    #0,d3
    	moveq    #0,d4
    	moveq    #0,d5
    	moveq    #0,d6
    	movea.l  d0,a1
    	movea.l  d0,a2
    	move.l    #476,d7
    	
clear_bcl:
	movem.l  d0-d6/a1-a2,[12](a0)[/12]
    	movem.l  d0-d6/a1-a2,[12]36(a0)[/12]
    	movem.l  d0-d6/a1-a2,[12]72(a0)[/12]
    	movem.l  d0-d6/a1-a2,[12]108(a0)[/12]
    	[12]adda.w #144,a0[/12]
	dbf      d7,clear_bcl
	movem.l  (a7)+,d2-d7/a2
	rts

ça devrait fonctionner comme ça (le postincrement n'est pas possible pour le 2^e argument de movem)

J'ai trouvé le problème, j'avais oublié une ligne.

|C prototype: void ClearScreenBuffer (void *buffer);
|
|void ClearScreenBuffer (register void *buffer asm("%a0"));
.data
.globl ClearScreenBuffer
.even
ClearScreenBuffer:
	movem.l  %d0-%d7/%a1-%a6,-(%a7)
	[u]lea      (0x42F0,%a0),%a0[/u]			|8568*2
    	moveq    #0,%d0
    	moveq    #0,%d1
    	moveq    #0,%d2
    	moveq    #0,%d3
    	moveq    #0,%d4
    	moveq    #0,%d5
    	moveq    #0,%d6
    	movea.l  %d0,%a1
    	movea.l  %d0,%a2
    	movea.l  %d0,%a3
    	movea.l  %d0,%a4
    	movea.l  %d0,%a5
    	movea.l  %d0,%a6
    	move.l	 #50,%d7
    	
clear_bcl:
	|336 octets=84 long
	movem.l  %d0-%d6/%a1-%a6,-(%a0)			|52 octets=13 long
    	movem.l  %d0-%d6/%a1-%a6,-(%a0)
    	movem.l  %d0-%d6/%a1-%a6,-(%a0)
    	movem.l  %d0-%d6/%a1-%a6,-(%a0)
    	movem.l  %d0-%d6/%a1-%a6,-(%a0)
    	movem.l  %d0-%d6/%a1-%a6,-(%a0)
    	movem.l  %d0-%d5,-(%a0)
	dbf      %d7,clear_bcl
	movem.l  (%a7)+,%d0-%d7/%a1-%a6
	rts

Voilà ce que j'ai trouvé de plus petit et de plus rapide.
Enfin de compte c'est pas si compliqué que ça.

J'ai un petit problème avec le scrolling, il semble y avoir un bug assez bizarre:


Il y a 4 balles situé au coordonnées 0,0 ; 0,221 ; 271,0 ; 271,221 donc dans chaque coin de l'écran virtuel.

Je pense que tu scrolle un peu trop loin vers la droite

Je t'assure que non, je scrolle à x=48 maximum. 288-240.

grrr ça me saoûle si ça vient de ma fonction