[mOved] niouby qui veut apprendre à coder en asm pour gba... - Page 1

tout est dans le titre...
si vous avez de bons liens, des compilateurs, des tutos asm, etc, je suis très intéressé.
merci

je crois franchement k tout est touvable sur gbadev.org et devrs.com/gba/ !

Sinon ben tu as le site d'ARM (arm.com)

ok, ba je v voir ça... merci

un petit moteur 3D sur GBA, pk pas ???

bah, ça existe déjà

Il est sympathique, d'ailleurs...

ué
mais faudrait que le créateur en fasse une version interactive, où on peut se promener dedans...

Ce qui est dommage aussi, c'est que le codeur n'utilise pas de placage de textures pour ses murs...
Mais sinon, la "map" est très vaste.

ouais...
surtt qu'un placage de texture n'est pas bcp + lent qu'un flat filler comme celui qu'il utilise...

tu devrait faire du C je pense ...

aussi...

c kler que tu va te faire chier avec l'asm , alors que tout le monde code en C

non, coder un jeu en C, mais savoir prog en asm pour optimiser des routines critiques

arf les routines critiques dont tu parles sont faites en hard par le coprocesseur graphique

pas forcément
imagine par exemple une routine de polygon filling ou de texture mapping... la gba a un circuit 3D?

nan mais g vu les differents mode , et je comprend pkoi tu disais ca aghnar

euh oué c clair k si tu veux absolument faire de la 3D la GBA a pas encore de chipset 3D !

Donc ouais l'asm peut etre sympa pour faire un moteur en vrai 3D avec textures.

ché pas si c trop utilse ...

meuh oui... tiens, vala un bump mapper en asm
j'y comprends rien, mais ça a l'air cool

        AREA bumpmain, CODE, READONLY
        
        ENTRY
        b       start
        DCD 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        DCD 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        DCD 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
start
        ldr r8, =0x29345723
      ldr r9, =0x20349752
      ldr r0, =ramrun
      mov r1, #0x03000000
      add r1,r1,#0x40
      ldr r3, =endof+0x200
ho      cmp     r0, r3                  ; Copy init data
        ldrne   r2, [r0], #4
        strne   r2, [r1], #4
        bne     ho

        ldr r1,=0x03000040
     mov pc,r1    ;jump to code

ramrun
    mov r2,#0x04000000
    ldr r1,=0x00000404
    str r1,[r2]
    mov r0,#0
    mov r4,#0x05000000
palloop      
    mov r1,r0
    mov r1,r1,LSR #3    
    mov r3,r1,LSL #10
    mov r2,r1,LSL #5
    orr r3,r3,r2
    orr r3,r3,r1
    strh r3,[r4]
    add r4,r4,#2
    add r0,r0,#1
    cmp r0,#0x100
    bne palloop
    
    mov r2,#0x02000000      ;fill env w/ random #s
    ldr r1,=0x02009600
fl  bl  random

    strh r8,[r2]
    add r2,r2,#2
    cmp r1,r2
    bne fl

    
    mov r7,#4
smoothgen
    mov r4,#0x02000000
    sub r4,r4,#1
    sub r3,r4,#239
    add r5,r4,#241
    add r6,r4,#2

smoothloop              ;Smooth  (blur)
    ldrb r0,[r3],#1     ;X,Y-1
    ldrb r11,[r4],#1    ;X-1,Y
    ldrb r12,[r5],#1    ;X,Y+1
    ldrb r13,[r6],#1    ;X+1,Y
    
    add r0,r0,r11
    add r2,r12,r13
    add r0,r0,r2
    mov r0,r0,LSR #2
    strb r0,[r4]
    

    cmp r1,r4
    bne smoothloop
    sub r7,r7,#1
    cmp r7,#0
    bne smoothgen


    ldr r12,=32767
    ;r1 still equals 02009600
    
    mov r3,#0
lyloop
    mov r4,#0
lxloop
    sub r5,r3,#64
    sub r6,r4,#64
    cmp r5,#0
    rsblt r5,r5,#0
    cmp r6,#0
    rsblt r6,r6,#0
    mov r11,r5
    mul r5,r11,r11
    mla r7,r6,r6,r5
    mov r0,#0
sqrt
    add r0,r0,#1
    mul r6,r0,r0
    cmp r6,r7
    blt sqrt
    sub r6,r0,#1
    mov r6,r6,LSL #2
    rsb r6,r6,#255
    cmp r6,#255
    movhi r6,#0
    strb r6,[r1],#1
    add r4,r4,#1
    cmp r4,#128
    bne lxloop
    add r3,r3,#1
    cmp r3,#128
    bne lyloop
        

    mov r1,#0x03000000
    mov r0,#0x02000000
    mov r2,#0x00000010
    mov r3,#0x00009600
    mov r4,#0x06000000
    mov r5,#2
    str r0,[r1],#4  ;0
    str r2,[r1],#4  ;4
    str r2,[r1],#4  ;8
    add r0,r0,r3
    str r0,[r1],#4  ;c
    str r4,[r1],#4  ;10
    str r5,[r1],#4  ;14
    str r5,[r1],#4  ;18
    
    


bump
    ;Use 11-curx, 12-cury,10-temporarybyte  other vars at 0x03000000 (0x40 bytes reserved)
    
    ;0x03000000: envmap
    ;0x03000004: lightx
    ;0x03000008: lighty
    ;0x0300000C: lightmap
    ;0x03000010: screenptr
    ;0x03000014: light x direction
    ;0x03000018: light y direction
    ;       0,1,2,3,4,5,6,7,8,9 working regs


    mov r1,#0x03000000
    mov r0,#0x02000000
    mov r2,#0x00000010
    mov r3,#0x00009600
    mov r4,#0x06000000
    mov r5,#1
    str r0,[r1],#4  ;0
    ldr r6,[r1],#4  ;4
    ldr r7,[r1],#4  ;8
    add r0,r0,r3
    str r0,[r1],#4  ;c
    str r4,[r1],#4  ;10
    ldr r8,[r1],#4  ;14
    ldr r9,[r1],#4  ;18

    add r6,r6,r8
    add r7,r7,r9
    mov r1,#0x03000000
    add r1,r1,#4
    str r6,[r1],#4
    str r7,[r1],#4

    cmp r6,#0
    movlt r8,#2
    cmp r6,#240
    movgt r8,#0
    subgt r8,r8,#2

    cmp r7,#0
    movlt r9,#2
    cmp r7,#160
    movgt r9,#0
    subgt r9,r9,#2

    add r1,r1,#8
    str r8,[r1],#4
    str r9,[r1],#4

    ;r0-r9 free to use
    ;0x03000000: envmap
    ;0x03000004: lightx
    ;0x03000008: lighty
    ;0x0300000C: lightmap
    ;0x03000010: screenptr
    ;0x03000014: light x direction
    ;0x03000018: light y direction
    ;'nx=((bumpmap(x+1,y)-bumpmap(x-1,y))-(x-lightx))+lightwidth/2

    mov r9,#0x03000000
    ldr r8,[r9],#4  ;envmap
    ldr r7,[r9],#4  ;lx
    ldr r6,[r9],#4  ;ly

    mov r13,#0  ;y
ybumploop
    mov r12,#0  ;x
xbumploop

    
    mov r5,#240
    sub r4,r8,r5
    ldrb r0,[r4],#480     ;bumpmap(x,y-1)
    ldrb r1,[r4]         ;bumpmap(x,y+1)
    sub r3,r1,r0        ;r1-r0
    sub r4,r13,r6       ;y-lighty
    sub r5,r3,r4        ;r3-r4                          r5 is dy
    sub r8,r8,#1        ;envmap-1
    ldrb r0,[r8],#2      ;envmap-1   > +2 (bumpmap(x-1,y)
    ldrb r1,[r8]         ;bumpmap(x+1,y)
    sub r3,r1,r0
    sub r4,r12,r7       ;x-lx
    sub r3,r3,r4        ;                                r3 is dx
    add r3,r3,#64
    add r5,r5,#64
    cmp r3,#128
    movhs r3,#0
    cmp r5,#128
    movhs r5,#0
    mov r5,r5,LSL #7
    add r5,r5,r3
    ldr r4,[r9]
    add r4,r4,r5
    ldrb r10,[r4]

    add r12,r12,#1

    
    mov r5,#240
    sub r4,r8,r5
    ldrb r0,[r4],#480     ;bumpmap(x,y-1)
    ldrb r1,[r4]         ;bumpmap(x,y+1)
    sub r3,r1,r0        ;r1-r0
    sub r4,r13,r6       ;y-lighty
    sub r5,r3,r4        ;r3-r4                          r5 is dy
    sub r8,r8,#1        ;envmap-1
    ldrb r0,[r8],#2      ;envmap-1   > +2 (bumpmap(x-1,y)
    ldrb r1,[r8]         ;bumpmap(x+1,y)
    sub r3,r1,r0
    sub r4,r12,r7       ;x-lx
    sub r3,r3,r4        ;                                r3 is dx
    add r3,r3,#64
    add r5,r5,#64
    cmp r3,#128
    movhs r3,#0
    cmp r5,#128
    movhs r5,#0
    mov r5,r5,LSL #7
    add r5,r5,r3
    ldr r4,[r9]
    add r4,r4,r5
    ldrb r1,[r4]
    add r10,r10,r1,LSL #8

    add r12,r12,#1

    
    mov r5,#240
    sub r4,r8,r5
    ldrb r0,[r4],#480     ;bumpmap(x,y-1)
    ldrb r1,[r4]         ;bumpmap(x,y+1)
    sub r3,r1,r0        ;r1-r0
    sub r4,r13,r6       ;y-lighty
    sub r5,r3,r4        ;r3-r4                          r5 is dy
    sub r8,r8,#1        ;envmap-1
    ldrb r0,[r8],#2      ;envmap-1   > +2 (bumpmap(x-1,y)
    ldrb r1,[r8]         ;bumpmap(x+1,y)
    sub r3,r1,r0
    sub r4,r12,r7       ;x-lx
    sub r3,r3,r4        ;                                r3 is dx
    add r3,r3,#64
    add r5,r5,#64
    cmp r3,#128
    movhs r3,#0
    cmp r5,#128
    movhs r5,#0
    mov r5,r5,LSL #7
    add r5,r5,r3
    ldr r4,[r9]
    add r4,r4,r5
    ldrb r1,[r4]
    add r10,r10,r1,LSL #16

    add r12,r12,#1

  
    mov r5,#240
    sub r4,r8,r5
    ldrb r0,[r4],#480     ;bumpmap(x,y-1)
    ldrb r1,[r4]         ;bumpmap(x,y+1)
    sub r3,r1,r0        ;r1-r0
    sub r4,r13,r6       ;y-lighty
    sub r5,r3,r4        ;r3-r4                          r5 is dy
    sub r8,r8,#1        ;envmap-1
    ldrb r0,[r8],#2      ;envmap-1   > +2 (bumpmap(x-1,y)
    ldrb r1,[r8]         ;bumpmap(x+1,y)
    sub r3,r1,r0
    sub r4,r12,r7       ;x-lx
    sub r3,r3,r4        ;                                r3 is dx
    add r3,r3,#64
    add r5,r5,#64
    cmp r3,#128
    movhs r3,#0
    cmp r5,#128
    movhs r5,#0
    mov r5,r5,LSL #7
    add r5,r5,r3
    ldr r4,[r9]
    add r2,r9,#4
    add r4,r4,r5
    ldrb r0,[r4]
    mov r0,r0,LSL #24
    add r0,r0,r10
    ldr r1,[r2]
    str r0,[r1],#4
    str r1,[r2]

    add r12,r12,#1
    cmp r12,#240
    bne xbumploop

    add r13,r13,#1
    cmp r13,#160
    bne ybumploop  

    



    b bump






random      ;uses r8,r9 and r7,r6,r5  use seed in r8,r9  63bit shift register technique
    mov r7,r8,ROR #30
    mov r8,r8,ROR #1
    mov r9,r9,ROR #31
    mov r5,r9
    add r7,r7,r8
    and r5,r5,#1
    mvn r6,#1
    and r8,r8,r6
    and r9,r9,r6
    orr r8,r8,r5
    and r7,r7,#1
    add r9,r7,r9
    
    mov pc,r14 ;return
endof

    END

bon, je crois que commencer par le c c une bonne idée, et eprès apprendre l'asm, paske là, c cho

A vu d'oeil ca m'a pas l'air si chaud que ca...
j'explique, quand j'ai vu une premiere source de asm 68k je me suis dit pt1 ca va etre tres tres dure de comprendre tout ca...
Maintenant, je trouve l'asm 68k super simple...

De plus on connais deja l'asm 68k, et on peut deja observer qqs similitudes.. je pense donc que ce sera surment moins chaud que lorsque j'ai apris l'asm la premiere fois

Mais oui ca doit valoir le coup je pense.. enfin surment puis que c'est un petit pros il me semble non?

A vue de nez :
instruction destination source1 source2

and r7,r7,#1 => r7 = r7 & 1
add r9,r7,r4 => r9 = r7 + r4
mov r1,#0x03000000 => r1 = 0x3000000

Certaines ont des suffixes pour dire qu'elles ne s'executes que si le flag est fixe :
ex:
movgt r8,#0
subgt r8,r8,#2
Identique aux precedantes mais seulements si le resultat de la comparaison est gt (bgt)

str / ldr : store / save data
ldr r6,[r1],#4 ;4
str r6,[r1],#4 ;4
Je sais pas trop dans quels sens ca marche.
r6 = *(4+r1)
*(4+r1= r6

>add r10,r9,r1,LSL #8
Hum.... Je sais pas trop...
Sans doute un decalage lsl qui s'effectue apres:
r10 = (r9 + r1 ) << 8

>mvn r6,#1
Je ne sais pas.

>ldr r1,=0x03000040
>mov pc,r1 ;jump to code
Hum... J'ai comme l'impression qu'il n'y pas de pile

>fl bl random
Sais pas... Appel de routine.

Finalement, tu vois Sbibi, c'est pas si complique a comprendre

je t jamais dit le contraire
j'en ai compris une bonne partie, mais certaines instructions restent obscures...

d'ailleurs, ce matin le tp d'info s'appelait: "introduction à l'assembleur"
ben, il se trouvait que ça ressemblait vachement à ça

même vachement vachement
c pour les processeurs à architecture risc apparemment

mais on a eu que quelques instructions à la con, genre add, addi, lsr, lsl et 2-3 autres trucs, pas de mov, rien
enfin bon, c pas grave mais c vrai ke ça a pas l'air si cho que ça...
le plus chiant, c'est pas trop la syntaxe, c'est qu'il faut réapprendre à connaitre la machine... la place de ts les trucs utiles dans la mem, etc etc...

au fait, y a un z80 ossi dans la gba

Je ne connais pas le z80

par contre, apparemment, on peut mettre soit trois arguments, soit deux...

mov r1,r0
mov r1,r1,LSR #3

par exemple

orr ça peu vouloir dire koi?
un or logik? pourquoi y a un autre r alors...

en fait, pour l'ordre, c'et l'inverse du 68000...

Oui ben c'est ce que j'ai dit plus haut :
mov r1,r1,LSR #3
==
r1 = r1 >> 3

>Je ne connais pas le z80
moi non plus, mais bon...

je me demandais si y avait pas un truc pour se servir des deux... ça me parait difficile mais bon...
surtt je voi pas l'intérêt, à part si le z80 est plus rapide que l'arm @ 16mhz sur certains trucs, mais bon, ça m'étonnerai

je crois qu'ils l'on mis pour garder la compatibilité ac les anciennes gameboy...
donc ça doi switcher d'un proc à l'autre en fonction de la cartouche qui est mise.
et le type de cartouche est stocké dans la mem à une addresse que je n'ai pas sous la main, dans un bit dont je me souviens plus lequel non plus...
ptet qu'en changeant dynamiquement ce bit au cours d'un programme, ça permettrait de passer d'un proc à l'autre...

bah, ça sert à rien...

Si ca sert. Mais je ne sais pas si tu peux t'en servir en paralle que du arm...
Il est probablement desactive pour economiser de la memoire.

mov r1,r1,LSR #3
==
r1 = r1 >> 3

euh, t sur de ça??
ça me paraît un peu bizzarre qu'il y aie une instruction insérée au milieu d'une autre...

à mon avis, LSR c'est plutôt une addresse quelconque...
paske l'ensemble de l'opcode+params doit faire 16 bits, dc c bizarre d'insérer une autre instruction, ça ferait plus 16 bits et le proc attends des params, pas des instruction...
non?

Oui, oui. C'est ofrt probable que ca soit ca.
T'es sur que c'est code sur 16 bits ? C'est pas plutot sur 32 bits ?