home *** CD-ROM | disk | FTP | other *** search
/ Fujiology Archive / fujiology_archive_v1_0.iso / !FALCON / LINEOUT / OUT.ZIP / SOURCE.ZIP / BILERP.ASM < prev    next >
Assembly Source File  |  2003-02-24  |  9KB  |  303 lines
  1. ; bilinear rotozoom (palette based)
  2. ;
  3. ; we have to keep the texture in dsp ram for speed
  4. ; this causes a problem, namely saving ram (for soundmixer)
  5. ; we can choose:
  6. ;
  7. ; a) 64*64 texture
  8. ; b) 128*128 texture, banked x:even,y:odd
  9. ; c) 128*128 texture, interleaved (2 texels in 1 word)
  10. ;
  11. ; a) might look crappy, but is simple and fast
  12. ; b) looks good, but is somewhat slower <-
  13. ; c) looks good (as b), but is slowest
  14. ;
  15. ; i chose to dump the concept of wrapping.. tough luck, but faster.
  16. ; seems to work now.. reasonable speed.
  17. ; one problem: you need to pack the pixels into words to kill as much
  18. ; cpu handshakes as possible.. this might require some minor unrolling..
  19. ;
  20. ; update: fixed all the shit.. i think it's still slow due to banking..
  21. ;
  22. ; update: sending two pixels in one transfers speeds it up.
  23. ;
  24. ; update: speeded up lots, cos we keep vars in internal x/y mem.
  25.  
  26. DOUBLE:    =    1                        ; send two pixels per transfer?
  27.  
  28. get:    MACRO
  29.     jclr    #0,X:<<$FFE9,*
  30.     movep    X:<<$FFEB,\1
  31.     ENDM
  32.  
  33. send:    MACRO
  34.     jclr    #1,X:<<$FFE9,*
  35.     movep    \1,X:<<$FFEB
  36.     ENDM
  37.  
  38.     org    p:0
  39.     jmp    <start
  40.  
  41.     org    p:$40
  42.  
  43. start:    jsr    <init
  44.  
  45. _loop:    jsr    <getVectors
  46.     jsr    <paint
  47.     jmp    <_loop
  48.  
  49. getVectors:
  50.     move    #uv_table,r0
  51.     do    #3,_loop
  52.     get    x:(r0)
  53.     get    y:(r0)+
  54. _loop:
  55.     IFNE    0
  56.     move    #$000100,x0
  57.     move    #$3FFF00,x1
  58.     move    x1,x:<uv_start
  59.     move    x1,y:<uv_start
  60.     clr    a
  61.     move    x0,x:<uv_xstep
  62.     move    a,y:<uv_xstep
  63.     move    a,x:<uv_ystep
  64.     move    x0,y:<uv_ystep
  65.     ENDC
  66.  
  67.     rts
  68.  
  69. paint:
  70.     IFNE    DOUBLE
  71.  
  72.     move            #$FFEB,r1
  73.     move            #<texturesize,r2
  74.     move            #<texturemask,r3
  75.     move            #<uv_xstep,r4
  76.     move            #<1,n4
  77.     move            #<uv_x,r5
  78.     move            #<1,n5
  79.     move            #<scalar,r6
  80.     move            #<128/2,n0
  81.     move            l:<uv_start,a
  82.     move            a,l:(r5+n5)
  83.     movec    #128*128/2-1,m0
  84.     move                    y:(r2),y1    ; y1=texturesize
  85.  
  86.     do    #100,_yloop
  87. ; calc start (u,v)
  88. ; a1=u, a0=v
  89.     move            a,l:(r5)
  90.     move                    y:(r5),y0    ; y0=v
  91.  
  92.     do    #80,_xloop
  93. ; 1: calc texture coordinates (u,v) 30 cycles..
  94. ; a1=u, a0=v, y0=texturesize, y1=v
  95.     mpy    y0,y1,b        l:(r3),x            ; b=offset=u*texturesize, x1=width, x0=mask
  96.     move            #<0,b0
  97.     and    x0,b        l:(r5),y            ; kill frag_u, y1=u, y0=v
  98.     mac    y1,x1,b        l:(r4),x            ; b=offset, x1=u_step, x0=v_step
  99.     add    x,a        x:(r6),x0            ; a1=u[n+1], a0=v[n+1], x0=scalar
  100.     mpy    x0,y0,a        a,l:(r5)
  101.     bclr    #23,a0
  102.     mpy    x0,y1,a        a0,y1                ; y1=v_frac
  103.     bclr    #23,a0
  104.     lsr    b        a0,y0                ; y0=u_frac
  105.     move            b1,r0                ; r0=textureoffset (assuming texturestart=0!)
  106.  
  107. ; 2: bilinear interpolation..
  108. ; two bank version..
  109. ; y0=u_frac, y1=v_frac
  110. ; r0:texture, n0=texturewidth
  111.     jcs    <_odd                        ; Was it even?
  112.  
  113. ; nice.. this one cannot wrap in u-dir ;) v-dir can be done with m0.. 20 cycles
  114. _even:    move            x:(r0+n0),x0            ; x0=hlb
  115.     move            x:(r0),b            ; b=hlt
  116.     mac    +y1,x0,b    b,x0        y:(r0),a    ; b=v_frac*hlb+hlt, x0=hlt, a=hrt
  117.     macr    -y1,x0,b            y:(r0+n0),x0    ; b=hl=v_frac*(hlb-hlt)+hlt, x0=hrb
  118.     mac    +y1,x0,a    a,x0                ; a=v_frac*hrb+hrt, x0=hrt
  119.     macr    -y1,x0,a    b,x0                ; a=hr=v_frac*(hrb-hrt)+hrt, x0=hl
  120.     mac    -y0,x0,b    a,x0        y:(r2),y1    ; b=u_frac*hr+hl, x0=hl, y1=texturesize
  121.     macr    +y0,x0,b    l:(r5),a            ; b=h=u_frac*(hr-hl)+hl, a=uv_x
  122.     jmp    <_next    
  123.  
  124. ; beware.. this one has no wrapping in u-direction.. 18 cycles
  125. _odd:    move                    y:(r0+n0),x0    ; x0=hlb
  126.     move                    y:(r0)+,b    ; b=hlt
  127.     move            b,x1
  128.     mac    +y1,x0,b    x:(r0),a            ; b=v_frac*hlb+hlt, x0=hlt, a=hrt
  129.     macr    -y1,x1,b    x:(r0+n0),x0            ; b=hl=v_frac*(hlb-hlt)+hlt, x0=hrb
  130.     mac    +y1,x0,a    a,x0                ; a=v_frac*hrb+hrt, x0=hrt
  131.     macr    -y1,x0,a    b,x0                ; a=hr=v_frac*(hrb-hrt)+hrt, x0=hl
  132.     mac    -y0,x0,b    a,x0        y:(r2),y1    ; b=u_frac*hr+hl, x0=hl, y1=texturesize
  133.     macr    +y0,x0,b    l:(r5),a            ; b=h=u_frac*(hr-hl)+hl, a=uv_x
  134.  
  135. _next:    move            b,x:(r2)    y:(r5),y0    ; Store texturepixel, y0=v
  136.  
  137. ; 1: calc texture coordinates (u,v) 30 cycles..
  138. ; a1=u, a0=v, y0=texturesize, y1=v
  139.     mpy    y0,y1,b        l:(r3),x            ; b=offset=u*texturesize, x1=width, x0=mask
  140.     move            #<0,b0
  141.     and    x0,b        l:(r5),y            ; kill frag_u, y1=u, y0=v
  142.     mac    y1,x1,b        l:(r4),x            ; b=offset, x1=u_step, x0=v_step
  143.     add    x,a        x:(r6),x0            ; a1=u[n+1], a0=v[n+1], x0=scalar
  144.     mpy    x0,y0,a        a,l:(r5)
  145.     bclr    #23,a0
  146.     mpy    x0,y1,a        a0,y1                ; y1=v_frac
  147.     bclr    #23,a0
  148.     lsr    b        a0,y0                ; y0=u_frac
  149.     move            b1,r0                ; r0=textureoffset (assuming texturestart=0!)
  150.  
  151. ; 2: bilinear interpolation..
  152. ; two bank version..
  153. ; y0=u_frac, y1=v_frac
  154. ; r0:texture, n0=texturewidth
  155.     jcs    <_odd2                        ; Was it even?
  156.  
  157. ; nice.. this one cannot wrap in u-dir ;) v-dir can be done with m0.. 20 cycles
  158. _even2:    move            x:(r0+n0),x0            ; x0=hlb
  159.     move            x:(r0),b            ; b=hlt
  160.     mac    +y1,x0,b    b,x0        y:(r0),a    ; b=v_frac*hlb+hlt, x0=hlt, a=hrt
  161.     macr    -y1,x0,b            y:(r0+n0),x0    ; b=hl=v_frac*(hlb-hlt)+hlt, x0=hrb
  162.     mac    +y1,x0,a    a,x0                ; a=v_frac*hrb+hrt, x0=hrt
  163.     macr    -y1,x0,a    b,x0                ; a=hr=v_frac*(hrb-hrt)+hrt, x0=hl
  164.     mac    -y0,x0,b    a,x0        y:(r2),y1    ; b=u_frac*hr+hl, x0=hl, y1=texturesize
  165.     macr    +y0,x0,b    x:(r2),x0    y:(r6),y0    ; b=h=u_frac*(hr-hl)+hl, x0=prv. pix, y0=scalar
  166.     jmp    <_next2
  167.  
  168. ; beware.. this one has no wrapping in u-direction.. 18 cycles
  169. _odd2:    move                    y:(r0+n0),x0    ; x0=hlb
  170.     move                    y:(r0)+,b    ; b=hlt
  171.     move            b,x1
  172.     mac    +y1,x0,b    x:(r0),a            ; b=v_frac*hlb+hlt, x0=hlt, a=hrt
  173.     macr    -y1,x1,b    x:(r0+n0),x0            ; b=hl=v_frac*(hlb-hlt)+hlt, x0=hrb
  174.     mac    +y1,x0,a    a,x0                ; a=v_frac*hrb+hrt, x0=hrt
  175.     macr    -y1,x0,a    b,x0                ; a=hr=v_frac*(hrb-hrt)+hrt, x0=hl
  176.     mac    -y0,x0,b    a,x0        y:(r2),y1    ; b=u_frac*hr+hl, x0=hl, y1=texturesize
  177.     macr    +y0,x0,b    x:(r2),x0    y:(r6),y0    ; b=h=u_frac*(hr-hl)+hl, x0=prv. pix, y0=scalar
  178.  
  179. _next2:    mpy    x0,y0,a                        ; a0=c1<<8
  180.     move            a0,y0                ; y0=c1<<8
  181.     add    y0,b        l:(r5),a            ; b=c1<<8+c2, a=uv_x
  182.     jclr    #1,x:<<$FFE9,*
  183.     move            b,x:(r1)    y:(r5),y0    ; Send two pixels to host, y0=v
  184. _xloop:    
  185.  
  186.     ELSE
  187. ; old version.. one at at time.....
  188.     move            #$FFEB,r1
  189.     move            #<texturesize,r2
  190.     move            #<texturemask,r3
  191.     move            #<uv_xstep,r4
  192.     move            #<1,n4
  193.     move            #<uv_x,r5
  194.     move            #<1,n5
  195.     move            #<scalar,r6
  196.     move            #<128/2,n0
  197.     move            l:<uv_start,a
  198.     move            a,l:(r5+n5)
  199.     movec    #128*128/2-1,m0
  200.     move                    y:(r2),y0    ; y0=texturesize
  201.     move                    y:(r5),y1    ; y1=v
  202.  
  203.     do    #100,_yloop
  204. ; calc start (u,v)
  205. ; a1=u, a0=v
  206.     move            a,l:(r5)
  207.  
  208.  
  209.     do    #160,_xloop
  210. ; 1: calc texture coordinates (u,v) 30 cycles..
  211. ; a1=u, a0=v, y0=texturesize, y1=v
  212.     mpy    y0,y1,b        l:(r3),x            ; b=offset=u*texturesize, x1=width, x0=mask
  213.     move            #<0,b0
  214.     and    x0,b        l:(r5),y            ; kill frag_u, y1=u, y0=v
  215.     mac    y1,x1,b        l:(r4),x            ; b=offset, x1=u_step, x0=v_step
  216.     add    x,a                y:(r6),x0    ; a1=u[n+1], a0=v[n+1], x0=scalar
  217.     mpy    x0,y0,a        a,l:(r5)
  218.     bclr    #23,a0
  219.     mpy    x0,y1,a        a0,y1                ; y1=v_frac
  220.     bclr    #23,a0
  221.     lsr    b        a0,y0                ; y0=u_frac
  222.     move            b1,r0                ; r0=textureoffset (assuming texturestart=0!)
  223.  
  224. ; 2: bilinear interpolation..
  225. ; two bank version..
  226. ; y0=u_frac, y1=v_frac
  227. ; r0:texture, n0=texturewidth
  228.     jcs    <_odd                        ; Was it even?
  229.  
  230. ; nice.. this one cannot wrap in u-dir ;) v-dir can be done with m0.. 20 cycles
  231. _even:    move            x:(r0+n0),x0            ; x0=hlb
  232.     move            x:(r0),b            ; b=hlt
  233.     mac    +y1,x0,b    b,x0        y:(r0),a    ; b=v_frac*hlb+hlt, x0=hlt, a=hrt
  234.     macr    -y1,x0,b            y:(r0+n0),x0    ; b=hl=v_frac*(hlb-hlt)+hlt, x0=hrb
  235.     mac    +y1,x0,a    a,x0                ; a=v_frac*hrb+hrt, x0=hrt
  236.     macr    -y1,x0,a    b,x0                ; a=hr=v_frac*(hrb-hrt)+hrt, x0=hl
  237.     mac    -y0,x0,b    a,x0        y:(r2),y1    ; b=u_frac*hr+hl, x0=hl
  238.     macr    +y0,x0,b    l:(r5),a            ; b=h=u_frac*(hr-hl)+hl, a=uv_x
  239.     jmp    <_next    
  240.  
  241. ; beware.. this one has no wrapping in u-direction.. 18 cycles
  242. _odd:    move                    y:(r0+n0),x0    ; x0=hlb
  243.     move                    y:(r0)+,b    ; b=hlt
  244.     move            b,x1
  245.     mac    +y1,x0,b    x:(r0),a            ; b=v_frac*hlb+hlt, x0=hlt, a=hrt
  246.     macr    -y1,x1,b    x:(r0+n0),x0            ; b=hl=v_frac*(hlb-hlt)+hlt, x0=hrb
  247.     mac    +y1,x0,a    a,x0                ; a=v_frac*hrb+hrt, x0=hrt
  248.     macr    -y1,x0,a    b,x0                ; a=hr=v_frac*(hrb-hrt)+hrt, x0=hl
  249.     mac    -y0,x0,b    a,x0        y:(r2),y1    ; b=u_frac*hr+hl, x0=hl
  250.     macr    +y0,x0,b    l:(r5),a            ; b=h=u_frac*(hr-hl)+hl, a=uv_x
  251.  
  252. _next:    jclr    #1,x:<<$FFE9,*
  253.     move            b,x:(r1)    y:(r5),y0
  254. _xloop:    
  255.  
  256.     ENDC
  257.  
  258. ; increment start (u,v)
  259.     move            l:(r5+n5),a
  260.     move            l:(r4+n4),x
  261.     add    x,a
  262.     move            a,l:(r5+n5)
  263. _yloop:    rts
  264.  
  265.  
  266. ; Store texture.
  267. init:    move            #128*128/2,x0
  268.     move            #>texture,r0
  269.     do    x0,_loop
  270.     get    x:(r0)
  271.     get    y:(r0)+
  272. _loop:    rts
  273.  
  274.         org    x:0
  275. texturemask:    dc    128                        ; texturewidth
  276. uv_table:
  277. uv_xstep:    ds    1                        ; u_xstep
  278. uv_ystep:    ds    1                        ; u_ystep
  279. uv_start:    ds    1                        ; u_start
  280. uv_x:        ds    1                        ; u_x
  281. uv_y:        ds    1                        ; u_y
  282.  
  283. prv_pixel:    ds    1
  284. scalar:        dc    128/2                        ; scalar for (u,v) fractions
  285.         ds    1
  286.  
  287. texture:    ds    128*128/2
  288.  
  289.         org    y:0
  290.         dc    $003F80                        ; texture v_mask
  291.  
  292.         ds    1                        ; v_xstep
  293.         ds    1                        ; v_ystep
  294.         ds    1                        ; v_start
  295.         ds    1                        ; v_x
  296.         ds    1                        ; v_y
  297.  
  298. texturesize:    dc    128*128
  299.         dc    $000080                        ; <<8 scalar for pixel multiplex
  300.         ds    1
  301.  
  302.         ds    128*128/2                    ; texture
  303.