home *** CD-ROM | disk | FTP | other *** search
/ Fujiology Archive / fujiology_archive_v1_0.iso / !FALCON / LINEOUT / OUT.ZIP / SOURCE.ZIP / RADIAL2.ASM < prev    next >
Assembly Source File  |  2003-08-07  |  10KB  |  546 lines
  1. ; unbanked picture version.. made it! close call though!
  2. ; pic: 124x59 (y)
  3. ; buf: 160x100 = 160x50 (top) (y) + 160x50 (btm) (x)
  4.  
  5. get:    MACRO
  6.     jclr    #0,X:<<$FFE9,*
  7.     movep    X:<<$FFEB,\1
  8.     ENDM
  9.  
  10. send:    MACRO
  11.     jclr    #1,X:<<$FFE9,*
  12.     movep    \1,X:<<$FFEB
  13.     ENDM
  14.  
  15.         org    x:0
  16. xoff:        ds    1
  17. yoff:        ds    1
  18. top_border:    ds    1
  19. topl_border:    ds    1
  20. btmu_border:    ds    1
  21. btm_border:    ds    1
  22. top_lines:    ds    1
  23. btm_lines:    ds    1
  24. picadr:        ds    1
  25. left_border:    ds    1
  26. mid_pixels:    ds    1
  27. right_border:    ds    1
  28. stride:        ds    1                    ; for pic! (w=124)
  29. screenstride:    ds    1                    ; for screenbuffer! (w=160)
  30. pal_offset:    ds    1
  31. steps:        ds    160
  32. ysteps:        ds    100
  33. xbuf:        ds    8000
  34.         ds    256                    ; 0 words (for fading)
  35. pal:        ds    256
  36. end_x_mem:
  37.  
  38.         org    y:0
  39. pic:        ds    124*59
  40. ybuf:        ds    8000
  41. end_y_mem:
  42. ; just enuff mem left.. ayee!
  43.  
  44.     org    p:0
  45.     jmp    <start
  46.  
  47.     org    p:$40
  48. start:    jsr    <getPic
  49. loop:    jsr    <getControl
  50.     jsr    <copyPic
  51.     jsr    <blur
  52.     jsr    <addPic
  53.     jsr    <paintLut
  54.     jmp    <loop
  55.  
  56. ; Copy picture to buffer and blanks the borders.
  57. ; Quite complex shit due to split dst buffers.
  58. copyPic:move            x:<picadr,r4
  59.     move            x:<top_border,b
  60.     clr    a        x:<stride,n4
  61.     tst    b        #ybuf,r0
  62.     jeq    <_topborder_loop
  63.     do    b,_topborder_loop
  64.     move                    a,y:(r0)+
  65. _topborder_loop:
  66.  
  67.     move            x:<top_lines,b
  68.     tst    b
  69.     jeq    <_top_loop
  70.     do    b,_top_loop
  71.  
  72.     clr    a        x:<xoff,b
  73.     tst    b
  74.     jle    <_topleft_loop
  75.     do    b,_topleft_loop
  76.     move                    a,y:(r0)+
  77. _topleft_loop:
  78.  
  79.     move            x:<mid_pixels,b
  80.     tst    b
  81.     jeq    <_toppic_loop
  82.     do    b,_toppic_loop
  83.     move                    y:(r4)+,b
  84.     move                    b,y:(r0)+
  85. _toppic_loop:
  86.  
  87.     move            x:<right_border,b
  88.     tst    b        (r4)+n4
  89.     jeq    <_topright_loop
  90.     do    b,_topright_loop
  91.     move                    a,y:(r0)+
  92. _topright_loop:
  93.  
  94.     nop
  95. _top_loop:
  96.  
  97.     move            x:<topl_border,b
  98.     tst    b
  99.     jeq    <_toplborder_loop
  100.     do    b1,_toplborder_loop
  101.     move                    a,y:(r0)+
  102. _toplborder_loop:
  103.  
  104. ; bottom half..
  105.     clr    a        x:<btmu_border,b
  106.     tst    b        #xbuf,r0
  107.     jeq    <_btmuborder_loop
  108.     do    b,_btmuborder_loop
  109.     move            a,x:(r0)+
  110. _btmuborder_loop:
  111.  
  112.     move            x:<btm_lines,a
  113.     tst    a                y:(r4)+,b
  114.     jeq    <_btm_loop
  115.     do    a,_btm_loop
  116.  
  117.     move            x:<xoff,a
  118.     tst    a
  119.     jle    <_btmleft_loop
  120.     clr    a
  121.     do    x:<xoff,_btmleft_loop
  122.     move            a,x:(r0)+
  123. _btmleft_loop:
  124.  
  125.     move            x:<mid_pixels,a
  126.     tst    a
  127.     jeq    <_btmpic_loop
  128.     do    a,_btmpic_loop
  129.     move            b,x:(r0)+    y:(r4)+,b
  130. _btmpic_loop:
  131.  
  132.     move            x:<right_border,a
  133.     move            (r4)+n4
  134.     tst    a                y:-(r4),b
  135.     jeq    <_btmright_loop
  136.     clr    a
  137.     do    x:<right_border,_btmright_loop
  138.     move            a,x:(r0)+
  139. _btmright_loop:
  140.  
  141.     move            (r4)+
  142. _btm_loop:
  143.  
  144. ; bottom border..
  145.     move            x:<btm_border,b
  146.     tst    b
  147.     jeq    <_btmborder_loop
  148.     do    b,_btmborder_loop
  149.     move            a,x:(r0)+
  150. _btmborder_loop:
  151.     rts
  152.  
  153. ; Add picture to buffer keeping the borders in mind.
  154. ; Quite complex shit due to split dst buffers.
  155. ; Major headache bonus due to amped intensities + load/store.
  156. addPic:    move            x:<picadr,r4
  157.     move            #ybuf,r0
  158.     move            x:<top_border,n0
  159.     move            x:<stride,n4
  160.     move            (r0)+n0
  161.     move            x:<left_border,n0
  162.     move            x:<top_lines,b
  163.     move            #>4,y0
  164.     tst    b        (r0)+n0
  165.     jeq    <_top_loop
  166.     do    b,_top_loop
  167.  
  168.     move            x:<mid_pixels,b
  169.     tst    b                y:(r4)+,x0
  170.     jeq    <_toppic_loop
  171.     do    b,_toppic_loop
  172.     move                    y:(r0),a0
  173.     mac    y0,x0,a                y:(r4)+,x0
  174.     move                    a0,y:(r0)+
  175. _toppic_loop:
  176.  
  177.     move            x:<screenstride,n0
  178.     move            (r4)+n4
  179.     move            (r0)+n0
  180.     move            (r4)-
  181. _top_loop:
  182.  
  183. ; btm
  184.     move            x:<btmu_border,n0
  185.     move            #xbuf,r0
  186.     move            x:<btm_lines,a
  187.     tst    a        (r0)+n0
  188.     move            x:<left_border,n0
  189.     nop
  190.     move            (r0)+n0
  191.     jeq    <_btm_loop
  192.     do    a,_btm_loop
  193.  
  194.     move            x:<mid_pixels,a
  195.     tst    a                y:(r4)+,x0
  196.     jeq    <_btmpic_loop
  197.     do    a,_btmpic_loop
  198.     move            x:(r0),a0
  199.     mac    y0,x0,a                y:(r4)+,x0
  200.     move            a0,x:(r0)+
  201. _btmpic_loop:
  202.  
  203.     move            x:<screenstride,n0
  204.     move            (r4)+n4
  205.     move            (r0)+n0
  206.     move            (r4)-
  207. _btm_loop:
  208.     rts
  209.  
  210. ; Radial blur the buffer up.
  211. ; Does five layers, more is senseless.
  212. blur:    move    #2*16777216/3,x0
  213.     jsr    <addZoomedLayer
  214.     move    #4*16777216/5,x0
  215.     jsr    <addZoomedLayer
  216.     move    #8*16777216/9,x0
  217.     jsr    <addZoomedLayer
  218.     move    #16*16777216/17,x0
  219.     jsr    <addZoomedLayer
  220.     move    #32*16777216/33,x0
  221.     jsr    <addZoomedLayer
  222.     rts
  223.  
  224. ; Now feedback a zoomed layer to the buffer..
  225. ; INPUT:
  226. ; x0= scale
  227. addZoomedLayer:
  228.     move            x0,a
  229.     lsr    a        #160,y0
  230.     tfr    y0,a        a1,x1
  231.     mac    -x1,y0,a
  232.     lsr    a        #<steps,r0
  233. ; precalc x steps
  234.     clr    b        #>$F00000,a0
  235.     move            x0,b0
  236.     do    #160,_preloop
  237.     add    b,a        a,x:(r0)+
  238. _preloop:
  239.  
  240. ; precalc y steps (top)
  241. ;    move            #ysteps,r0
  242.  
  243. ; put y offset in a1
  244.     move            x0,a
  245.     lsr    a        #100,y0
  246.     tfr    y0,a        a1,x1
  247.     mac    -x1,y0,a
  248.     asr    a        #<50,n0                ; a1= y offset
  249. ; top
  250.     do    #50,_preloop_yt
  251.     add    b,a        a,x:(r0)+
  252. _preloop_yt:
  253. ; btm
  254.     move            (r0)+n0
  255.     do    #50,_preloop_yb
  256.     add    b,a        a,x:-(r0)
  257. _preloop_yb:
  258. ; top
  259.     clr    b        #ysteps,r0
  260.     move            #ybuf,b0
  261.     move            #160/2,y0
  262.     do    #50,_preloop_yt2
  263.     tfr    b,a        x:(r0),x1
  264.     mac    x1,y0,a
  265.     move            a0,x:(r0)+
  266. _preloop_yt2:
  267. ; btm
  268.     move            #xbuf-160*50,b0
  269.     do    #50,_preloop_yb2
  270.     tfr    b,a        x:(r0),x1
  271.     mac    x1,y0,a
  272.     move            a0,x:(r0)+
  273. _preloop_yb2:
  274.  
  275. ; now actually blur it, using the steptables.
  276. ; top
  277.     move            #<80,n0
  278.     move            #ybuf,r2
  279.     move            #ysteps,r3
  280.     move            #<80,n2
  281.  
  282.     do    #50,_toploop    
  283.     move            #<steps,r0
  284.     move            x:(r3)+,r1
  285.     move            x:(r0)+,n1
  286.  
  287.     do    #80,_tleftloop
  288.     move                    y:(r2),a
  289.     move                    y:(r1+n1),x0
  290.     add    x0,a        x:(r0)+,n1
  291.     move                    a,y:(r2)+
  292. _tleftloop:
  293.  
  294.     move            (r0)-
  295.     move            (r0)+n0                ; r0: end of line
  296.     move            (r2)+n2                ; r2: end of line
  297.     move            x:-(r0),n1
  298.  
  299.     do    #80,_trightloop
  300.     move                    y:-(r2),a
  301.     move                    y:(r1+n1),x0
  302.     add    x0,a        x:-(r0),n1
  303.     move                    a,y:(r2)
  304. _trightloop:
  305.  
  306.     move            (r2)+n2                ; r2: end of line
  307. _toploop:
  308.  
  309. ; btm
  310.     move            #xbuf+49*160,r2
  311.     move            #<80,n2
  312.  
  313.     do    #50,_btmloop    
  314.     move            #<steps,r0
  315.     move            x:(r3)+,r1
  316.     move            x:(r0)+,n1
  317.  
  318.     do    #80,_bleftloop
  319.     move            x:(r2),a
  320.     move            x:(r1+n1),x0
  321.     add    x0,a        x:(r0)+,n1
  322.     move            a,x:(r2)+
  323. _bleftloop:
  324.  
  325.     move            (r0)-
  326.     move            (r0)+n0                ; r0: end of line
  327.     move            (r2)+n2                ; r2: end of line
  328.     move            x:-(r0),n1
  329.  
  330.     do    #80,_brightloop
  331.     move            x:-(r2),a
  332.     move            x:(r1+n1),x0
  333.     add    x0,a        x:-(r0),n1
  334.     move            a,x:(r2)
  335. _brightloop:
  336.  
  337.     move            (r2)-n2
  338.     move            (r2)-n2
  339.     move            (r2)-n2
  340. _btmloop:
  341.  
  342.     rts
  343.  
  344.     IFNE    0
  345. ; generic feedback scaler
  346.     move            x:(r0)+,n1
  347.  
  348. ; 8 cycles, do we need it any faster at all?
  349.     move            x:(r2),a
  350.     move            x:(r1+n1),x0
  351.     add    x0,a        x:(r0)+,n1
  352.     move            a,x:(r2)+
  353.  
  354. ; specific feedback scaler: 1.5
  355.     move            #<-2,n2
  356.     move            x:(r2)+,a
  357.  
  358. ; 16 for 3, so.. 4.6667 cycles, godallmighty!
  359.     move            x:(r1)+,x0
  360.     add    x0,a        x:(r2)-,b
  361.     move            x:(r1)+,x0
  362.     add    x0,b        a,x:(r2)+
  363.     move            b,x:(r2)+
  364.     move            x:(r2)+,b
  365.     add    x0,b        x:(r2)+,a
  366.     move            b,x:(r2+n2)
  367.  
  368. ; 1.25, 28/5=5.6 cycles, still quite fast.
  369.     move            x:(r1)+,x0
  370.  
  371.     move            x:(r2),a
  372.     add    x0,a        x:(r1)+,x0
  373.     move            a,x:(r2)+
  374.     move            x:(r2),a
  375.     add    x0,a        x:(r1)+,x0
  376.     move            a,x:(r2)+
  377.     move            x:(r2),a
  378.     add    x0,a        x:(r1)+,x0
  379.     move            a,x:(r2)+
  380.     move            x:(r2)+,b
  381.     add    x0,b        x:(r1)+,x0
  382.     move            x:(r2)-,a
  383.     add    x0,a        b,x:(r2)+
  384.     move            a,x:(r2)+
  385.  
  386. ; here it gets nasty.. it needs to fit into 80. but 9 doesn't very well.
  387. ; so we get nasty tails..
  388.  
  389. ; 1.125, hhmm loop gets quite big here.. would be 6 cycles..
  390. ; so.. we use a 'do'.. (6+8*6+6)/9=60/9=6.66667 cycles
  391.     move            x:(r1)+,x0
  392.  
  393.     do    #8,_loop
  394.     move            x:(r2)+,a
  395.     add    x0,a        x:(r1)+,x0
  396.     move            a,x:(r2)+
  397. _loop:    move            x:(r2)+,a
  398.     add    x0,a
  399.     move            a,x:(r2)+
  400.     ENDC
  401.  
  402. ; Send the pixels to the host.
  403. paintLut:
  404.     move            #>8000,x1
  405.     move            #>$7FFFFF/40,y1
  406.     move            #pal,r2
  407.     move            x:<pal_offset,n2
  408.     move            #xbuf,r1
  409.     move            #ybuf,r0
  410.     move            (r2)-n2
  411.     do    x1,_tloop
  412.     move                    y:(r0)+,x0
  413.     mpyr    y1,x0,a
  414.     move            a1,n2
  415.     send    x:(r2+n2)
  416. _tloop:    do    x1,_bloop
  417.     move            x:(r1)+,x0
  418.     mpyr    y1,x0,a
  419.     move            a1,n2
  420.     send    x:(r2+n2)
  421. _bloop:    rts
  422.  
  423. ;---------------------------------------------------------------------------
  424. ; Can be in external P (beware of overlap!)
  425. ; best place in high x.. < $3000
  426.  
  427. getPic:
  428. ; Clear sub_palette.
  429.     clr    a        #pal-256,r0
  430.     do    #256,_clearloop
  431.     move            a,x:(r0)+
  432. _clearloop:
  433.     
  434. ; Get palette.
  435.     do    #256,_palloop
  436.     get    x:(r0)+
  437. _palloop:
  438.  
  439. ; Get pic.
  440.     move            #<pic,r0
  441.     move            #124*59,x0
  442.     do    x0,_loop
  443.     get    y:(r0)+
  444. _loop:    rts
  445.  
  446. getControl:
  447. ; Get palette offset..
  448.     get    x:pal_offset
  449. ; Get (x,y) offset and calculate border offsets and such.
  450.     get    x:xoff                    ; 0..36
  451.     get    b                    ; 0..41
  452. ; top logo line = max(0,-yoff)
  453.     move            #<0,x1
  454.     neg    b        b,x:<yoff
  455.     tmi    x1,b
  456.     move            b,x0
  457.     move            #<pic,a0
  458.     move            #124/2,y0
  459.     mac    x0,y0,a        x:<yoff,b
  460.     clr    a        a0,x:<picadr
  461. ; top_border = min[50,max(0,yoff)]
  462.     tst    b        #<50,a1
  463.     tmi    x1,b
  464.     cmp    a,b
  465.     tge    a,b
  466.     move            b,x:<top_border
  467. ; topl_border = min[50,max(0,41-yoff-50)]
  468.     clr    a        x:<yoff,b
  469.     neg    b        #<9,a1
  470.     sub    a,b        #<50,a1
  471.     tmi    x1,b
  472.     cmp    a,b
  473.     tge    a,b
  474.     move            b,x:<topl_border
  475. ; top_lines = 50-top_border-topl_border (haha, easy)
  476.     sub    b,a        x:<top_border,b
  477.     sub    b,a        x:<yoff,b
  478.     clr    a        a,x:<top_lines
  479. ; btmu_border = min[50,max(0,yoff-50)]
  480.     move            #<50,a1
  481.     sub    a,b
  482.     tmi    x1,b
  483.     cmp    a,b
  484.     tge    a,b
  485.     move            b,x:<btmu_border
  486. ; btm_border = min[50,max(0,41-yoff)]
  487.     move            x:<yoff,x0
  488.     clr    b        #<41,a1
  489.     sub    x0,a        #<50,b1
  490.     tmi    x1,a
  491.     cmp    b,a
  492.     tge    b,a
  493.     move            a,x:<btm_border
  494. ; btm_lines = 50-btm_border-btmu_border (easy again)
  495.     sub    a,b        x:<btmu_border,a
  496.     sub    a,b
  497.     move            b,x:<btm_lines
  498.  
  499. ; Calculate size of blocks..
  500.     move            #<top_border,r0
  501.     move            #160/2,x1
  502.     move            x:(r0),x0
  503.     move            #<1,n0
  504.     do    #4,_mulloop
  505.     mpy    x0,x1,a        x:(r0+n0),x0
  506.     move            a0,x:(r0)+
  507. _mulloop:
  508.  
  509. ; horizontal segment stuff..
  510.     move            #<0,x1
  511. ; left_border = min[160,max(0,xoff)]
  512.     move            x:<xoff,b
  513.     tst    b        #>160,a
  514.     tmi    x1,b
  515.     cmp    a,b
  516.     tgt    a,b
  517.     move            b,x:<left_border
  518. ; right = min[160,max(0,36-xoff)
  519.     clr    b        x:<xoff,x0
  520.     move            #<36,b1
  521.     sub    x0,b
  522.     tmi    x1,b
  523.     cmp    a,b                        ; b=mid+right
  524.     tgt    a,b
  525.     move            b,x:<right_border
  526. ; mid = 160-left_border-right_border
  527.     sub    b,a        x:<left_border,b
  528.     sub    b,a        x:<xoff,b
  529.     neg    b        a,x:<mid_pixels    
  530. ; left logo offset = max(0,-xoff)
  531.     tmi    x1,b
  532.     move            x:<picadr,a
  533.     add    b,a        #>36,x0
  534.     move            a,x:<picadr
  535. ; stride = max(0,xoff-36) + logo_xoff
  536.     move            x:<xoff,a
  537.     sub    x0,a
  538.     tmi    x1,a
  539.     add    b,a        x:<left_border,b
  540.     move            a,x:<stride
  541. ; screenstride = left_border+right_border
  542.     move            x:<right_border,x0
  543.     add    x0,b
  544.     move            b,x:<screenstride
  545.     rts
  546.