API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 5th, 2017
159
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
ASM (NASM) 19.72 KB | None | 0 0
raw download clone embed print report
  1. ******************************************************************************
  2. *
  3. *       void D_DrawSpans16 (espan_t *pspan)
  4. *
  5. *       standard scan drawing function (16 pixel subdivision)
  6. *
  7. ******************************************************************************
  8.  
  9.         cnop    0,4
  10. _D_DrawSpans16
  11.         rs.l    1
  12. .pspan      rs.l    1
  13.         move.l  .pspan(sp),a0
  14.  
  15. @D_DrawSpans16
  16.  
  17. *****   stackframe
  18.  
  19.         rsreset
  20. .saved4         rs.l    1
  21. .saved5         rs.l    1
  22. .savea6         rs.l    1
  23. .szstpu         rs.s    1
  24. .szstpv         rs.s    1
  25. .szorg          rs.s    1
  26. .tzstpu         rs.s    1
  27. .tzstpv         rs.s    1
  28. .tzorg          rs.s    1
  29. .zistpu         rs.s    1
  30. .zistpv         rs.s    1
  31. .ziorg          rs.s    1
  32. .fpuregs        rs.x    6
  33. .intregs        rs.l    11
  34.         rs.l    1
  35. .pspan          rs.l    1
  36.  
  37. ******  Prologue. Global variables are put into registers or onto the stackframe
  38.  
  39.         movem.l d2-d7/a2-a6,-(sp)
  40.         fmovem.x        fp2-fp7,-(sp)
  41.         move.l  _bbextentt,a2
  42.         move.l  _tadjust,a3
  43.         move.l  _bbextents,a4
  44.         move.l  _sadjust,a5
  45.         move.l  _d_ziorigin,-(sp)
  46.         move.l  _d_zistepv,-(sp)
  47.         move.l  _d_zistepu,-(sp)
  48.         move.l  _d_tdivzorigin,-(sp)
  49.         move.l  _d_tdivzstepv,-(sp)
  50.         move.l  _d_tdivzstepu,-(sp)
  51.         move.l  _d_sdivzorigin,-(sp)
  52.         move.l  _d_sdivzstepv,-(sp)
  53.         move.l  _d_sdivzstepu,-(sp)
  54.         sub.l   #.szstpu,sp
  55.  
  56.  
  57. ******  First loop. In every iteration one complete span is drawn
  58.  
  59. *        pbase = (unsigned char *)cacheblock;
  60. *
  61. *        sdivz16stepu = d_sdivzstepu * 16;
  62. *        tdivz16stepu = d_tdivzstepu * 16;
  63. *        zi16stepu = d_zistepu * 16;
  64. *
  65. *        do
  66. *        {
  67. *                pdest = (unsigned char *)((byte *)d_viewbuffer +
  68. *                                (screenwidth * pspan->v) + pspan->u);
  69. *
  70. *                count = pspan->count;
  71. *
  72. *        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
  73. *                du = (float)pspan->u;
  74. *                dv = (float)pspan->v;
  75. *
  76. *                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
  77. *                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
  78. *                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
  79. *                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  80. *
  81.  
  82.         move.l  _cacheblock,a1          ;pbase = (unsigned char *)cacheblock
  83.         fmove.s #16,fp7
  84.         fmove.s .szstpu(sp),fp3
  85.         fmul    fp7,fp3                 ;sdivz16stepu = d_sdivzstepu * 16
  86.         fmove.s .tzstpu(sp),fp4
  87.         fmul    fp7,fp4                 ;tdivz16stepu = d_tdivzstepu * 16
  88.         fmove.s .zistpu(sp),fp5
  89.         fmul    fp7,fp5                 ;zi16stepu = d_zistepu * 16
  90.         move.l  a0,a6               ;get function parameter
  91. .loop
  92.         move.l  a6,.savea6(sp)          ;save actual ptr to pspan
  93.         move.l  _d_viewbuffer,a0
  94.         move.l  _screenwidth,d0
  95.         move.l  (a6)+,d1
  96.         fmove.l d1,fp2                  ;du = (float)pspan->u
  97.         move.l  (a6)+,d2
  98.         fmove.l d2,fp7                  ;dv = (float)pspan->v
  99.         move.l  (a6)+,d4
  100.         muls    d2,d0                   ;d0 = screenwidth * pspan->v
  101.         add.l   d1,d0
  102.         add.l   d0,a0                   ;pdest = d_viewbuffer + pspan->u + d0
  103.         lea     .szstpu(sp),a6          ;a6 -> stackframe
  104.         fmove.s (a6)+,fp0
  105.         fmul    fp2,fp0                 ;fp0 = du * d_sdivzstepu
  106.         fmove.s (a6)+,fp1
  107.         fmul    fp7,fp1                 ;fp1 = dv * d_sdivzstepv
  108.         fadd    fp1,fp0
  109.         fadd.s  (a6)+,fp0               ;sdivz = d_sdivzorigin + fp0 + fp1
  110.         fmove.s (a6)+,fp1
  111.         fmul    fp2,fp1                 ;fp1 = du * d_tdivzstepu
  112.         fmove.s (a6)+,fp6
  113.         fmul    fp7,fp6                 ;fp6 = dv * d_tdivzstepv
  114.         fadd    fp6,fp1
  115.         fadd.s  (a6)+,fp1               ;tdivz = d_tdivzorigin + fp1 + fp6
  116.         fmul.s  (a6)+,fp2               ;fp2 = du * d_zistepu
  117.         fmul.s  (a6)+,fp7               ;fp7 = dv * d_zistepv
  118.         fadd    fp7,fp2
  119.         fadd.s  (a6)+,fp2               ;zi = d_ziorigin + fp2 + fp7
  120.         fmove.s #65536,fp6
  121.         fdiv    fp2,fp6                 ;z = (float)0x10000 / zi
  122.  
  123. *                s = (int)(sdivz * z) + sadjust;
  124. *                if (s > bbextents)
  125. *                        s = bbextents;
  126. *                else if (s < 0)
  127. *                        s = 0;
  128. *
  129. *                t = (int)(tdivz * z) + tadjust;
  130. *                if (t > bbextentt)
  131. *                        t = bbextentt;
  132. *                else if (t < 0)
  133. *                        t = 0;
  134.  
  135.  
  136.         fmove   fp6,fp7
  137.         fmul    fp0,fp7                 ;fp7 = sdivz * z
  138.         fmove.l fp7,d6                  ;convert to integer
  139.         add.l   a5,d6                   ;s = d6 + sadjust
  140.         cmp.l   a4,d6                   ;if (s > bbextents)
  141.         bgt.b   .down
  142.         tst.l   d6                      ;if (s < 0)
  143.         bge.b   .keep
  144. .up
  145.         moveq   #0,d6                   ;s = 0
  146.         bra.b   .keep
  147. .down
  148.         move.l  a4,d6                   ;s = bbextents
  149. .keep
  150.         fmul    fp1,fp6                 ;fp6 = tdivz * z
  151.         fmove.l fp6,d7                  ;convert to integer
  152.         add.l   a3,d7                   ;t = d7 + tadjust
  153.         cmp.l   a2,d7                   ;if (t > bbextentt)
  154.         bgt.b   .down2
  155.         tst.l   d7                      ;if (t < 0)
  156.         bge.b   .keep2
  157. .up2
  158.         moveq   #0,d7                   ;t = 0
  159.         bra.b   .keep2
  160. .down2
  161.         move.l  a2,d7                   ;t = bbextentt
  162. .keep2
  163.         move.l  d4,d1
  164.  
  165. ******  Second loop. In every iteration one part of the whole span is drawn
  166. ******  d2 gets the value (spancount-1)! [NOT spancount]
  167.  
  168. ******  d1 = count
  169.  
  170. *                do
  171. *                {
  172. *                // calculate s and t at the far end of the span
  173. *                        if (count >= 16)
  174. *                                spancount = 16;
  175. *                        else
  176. *                                spancount = count;
  177. *
  178. *                        count -= spancount;
  179. *
  180. *                        if (count)
  181. *                        {
  182.  
  183. .loop2
  184.         moveq   #16-1,d2                ;spancount = 16
  185.         cmp.l   #16,d1                  ;if (count >= 16)
  186.         bgt.b   .cont
  187.         move.l  d1,d2                   ;spancount = count
  188.         subq.l  #1,d2
  189.         moveq   #0,d1                   ;count -= spancount
  190.         bra.w   .finalpart
  191. .cont
  192.         sub.l   #16,d1                  ;count -= spancount;
  193.  
  194. ******  Evaluation of the values for the inner loop. This version is used for
  195. ******  span size = 16
  196.  
  197. ******  a2  : bbextentt
  198. ******  a3  : tadjust
  199. ******  a4  : bbextents
  200. ******  a5  : sadjust
  201. ******  fp0 : sdivz
  202. ******  fp1 : tdivz
  203. ******  fp2 : zi
  204. ******  fp3 : sdivz16stepu
  205. ******  fp4 : tdivz16stepu
  206. ******  fp5 : zi16stepu
  207.  
  208. *                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
  209. *                        // calculate s and t steps across span by shifting
  210. *                                sdivz += sdivz16stepu;
  211. *                                tdivz += tdivz16stepu;
  212. *                                zi += zi16stepu;
  213. *                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  214. *                                snext = (int)(sdivz * z) + sadjust;
  215. *                                if (snext > bbextents)
  216. *                                        snext = bbextents;
  217. *                                else if (snext < 16)
  218. *                                        snext = 16;      // prevent round-off error on <0 steps from
  219. *                                                                //  from causing overstepping & running off the
  220. *                                                                //  edge of the texture
  221. *                                tnext = (int)(tdivz * z) + tadjust;
  222. *                                if (tnext > bbextentt)
  223. *                                        tnext = bbextentt;
  224. *                                else if (tnext < 16)
  225. *                                        tnext = 16;      // guard against round-off error on <0 steps
  226. *                                sstep = (snext - s) >> 4;
  227. *                                tstep = (tnext - t) >> 4;
  228. *                        }
  229.  
  230.         fadd    fp3,fp0                 ;sdivz += sdivz16stepu
  231.         fadd    fp4,fp1                 ;tdivz += tdivz16stepu
  232.         fadd    fp5,fp2                 ;zi += zi16stepu
  233.         fmove.s #65536,fp7
  234.         fdiv    fp2,fp7                 ;z = (float)0x10000 / zi;
  235.         fmove   fp7,fp6
  236.         fmul    fp0,fp6                 ;fp2 = sdivz * z
  237.         fmove.l fp6,d4                  ;convert to integer
  238.         add.l   a5,d4                   ;snext = d4 + sadjut
  239.         cmp.l   a4,d4                   ;if (snext > bbextents)
  240.         bgt.b   .down3
  241.         cmp.l   #16,d4                  ;if (snext < 16)
  242.         bge.b   .keep3
  243. .up3
  244.         moveq   #16,d4                  ;snext = 16
  245.         bra.b   .keep3
  246. .down3
  247.         move.l  a4,d4                   ;snext = bbextents
  248. .keep3
  249.         fmul    fp1,fp7                 ;fp7 = tdivz * z
  250.         fmove.l fp7,d5                  ;convert to integer
  251.         add.l   a3,d5                   ;tnext = d5 + tadjust
  252.         cmp.l   a2,d5                   ;if (tnext > bbextentt)
  253.         bgt.b   .down4
  254.         cmp.l   #16,d5                  ;if (tnext < 16)
  255.         bge.b   .keep4
  256. .up4
  257.         moveq   #16,d5                  ;tnext = 16
  258.         bra.b   .keep4
  259. .down4
  260.         move.l  a2,d5                   ;tnext = bbextentt
  261. .keep4
  262.         move.l  d4,.saved4(sp)          ;save snext
  263.         move.l  d5,.saved5(sp)          ;save tnext
  264.         sub.l   d6,d4                   ;d4 = snext - s
  265.         sub.l   d7,d5                   ;d5 = tnext - t
  266.         asr.l   #4,d4                   ;sstep = d4 >> 4
  267.         asr.l   #4,d5                   ;tstep = d5 >> 4
  268.         bra.w   .mainloop
  269.  
  270.  
  271. ******  Evaluation of the values for the inner loop. This version is used for
  272. ******  span size < 16
  273.  
  274. ******  The original algorithm has two ugly divisions at the end of this part.
  275. ******  These are removed by the following optimization:
  276. ******  First, the divisors 1,2 and 4 are handled specially to gain speed. The
  277. ******  other divisors are handled using a reciprocal table.
  278.  
  279. ******  a2  : bbextentt
  280. ******  a3  : tadjust
  281. ******  a4  : bbextents
  282. ******  a5  : sadjust
  283. ******  fp0 : sdivz
  284. ******  fp1 : tdivz
  285. ******  fp2 : zi
  286.  
  287. *                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
  288. *                        // can't step off polygon), clamp, calculate s and t steps across
  289. *                        // span by division, biasing steps low so we don't run off the
  290. *                        // texture
  291. *                                spancountminus1 = (float)(spancount - 1);
  292. *                                sdivz += d_sdivzstepu * spancountminus1;
  293. *                                tdivz += d_tdivzstepu * spancountminus1;
  294. *                                zi += d_zistepu * spancountminus1;
  295. *                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  296. *                                snext = (int)(sdivz * z) + sadjust;
  297. *                                if (snext > bbextents)
  298. *                                        snext = bbextents;
  299. *                                else if (snext < 16)
  300. *                                        snext = 16;      // prevent round-off error on <0 steps from
  301. *                                                                //  from causing overstepping & running off the
  302. *                                                                //  edge of the texture
  303. *
  304. *                                tnext = (int)(tdivz * z) + tadjust;
  305. *                                if (tnext > bbextentt)
  306. *                                        tnext = bbextentt;
  307. *                                else if (tnext < 16)
  308. *                                        tnext = 16;      // guard against round-off error on <0 steps
  309. *
  310. *                                if (spancount > 1)
  311. *                                {
  312. *                                        sstep = (snext - s) / (spancount - 1);
  313. *                                        tstep = (tnext - t) / (spancount - 1);
  314. *                                }
  315. *                        }
  316.  
  317. .finalpart
  318.         fmove.l d2,fp7                  ;spancountminus1 = (float)(spancount-1)
  319.         fmove   fp7,fp6
  320.         fmul.s  .szstpu(sp),fp6         ;fp6 = d_sdivzstepu * spancountminus1
  321.         fadd    fp6,fp0                 ;sdivz += fp6
  322.         fmove   fp7,fp6
  323.         fmul.s  .tzstpu(sp),fp6         ;fp6 = d_tdivzstepu * spancountminus1
  324.         fadd    fp6,fp1                 ;tdivz += fp6
  325.         fmul.s  .zistpu(sp),fp7         ;fp7 = d_zistepu * spancountminus1
  326.         fadd    fp7,fp2                 ;zi += fp7
  327.         fmove.s #65536,fp7
  328.         fdiv    fp2,fp7                 ;z = (float)0x10000 / zi;
  329.         fmove   fp7,fp6
  330.         fmul    fp0,fp6                 ;fp6 = sdivz * z
  331.         fmove.l fp6,d4                  ;convert to integer
  332.         add.l   a5,d4                   ;snext = d4 + sadjust
  333.         cmp.l   a4,d4                   ;if (snext > bbextents)
  334.         bgt.b   .down5
  335.         cmp.l   #16,d4                  ;if (snext < 16)
  336.         bge.b   .keep5
  337. .up5
  338.         moveq   #16,d4                  ;snext = 16
  339.         bra.b   .keep5
  340. .down5
  341.         move.l  a4,d4                   ;snext = bbextents
  342. .keep5
  343.         fmul    fp1,fp7                 ;fp7 = tdivz * z
  344.         fmove.l fp7,d5                  ;convert to integer
  345.         add.l   a3,d5                   ;tnext = d5 + tadjust
  346.         cmp.l   a2,d5                   ;if (tnext > bbextentt)
  347.         bgt.b   .down6
  348.         cmp.l   #16,d5                  ;if (tnext < 16)
  349.         bge.b   .keep6
  350. .up6
  351.         moveq   #16,d5                  ;tnext = 16
  352.         bra.b   .keep6
  353. .down6
  354.         move.l  a2,d5                   ;tnext = bbextentt
  355. .keep6
  356.         move.l  d4,.saved4(sp)          ;save snext
  357.         move.l  d5,.saved5(sp)          ;save tnext
  358.         sub.l   d6,d4                   ;d4 = snext - s
  359.         sub.l   d7,d5                   ;d5 = tnext - t
  360.  
  361.         IFEQ    QDIV
  362.         tst.l   d2
  363.         beq.w   .mainloop
  364.         divs.l  d2,d4
  365.         divs.l  d2,d5
  366.         ELSEIF
  367.         cmp     #5,d2                   ;(spancount-1) < 5?
  368.         blt.b   .special                ;yes -> special case
  369.         cmp     #8,d2
  370.         beq.b   .spec_8
  371. .qdiv
  372.         IFNE    NICE_DIV
  373.         lsl.l   #2,d4
  374.         lsl.l   #2,d5
  375.         lea     ReciprocTable,a6
  376.         move    0(a6,d2.w*2),d0
  377.         move.l  d4,d3
  378.         mulu    d0,d3
  379.         clr     d3
  380.         swap    d3
  381.         swap    d4
  382.         muls    d0,d4
  383.         add.l   d3,d4
  384.         move.l  d5,d3
  385.         mulu    d0,d3
  386.         clr     d3
  387.         swap    d3
  388.         swap    d5
  389.         muls    d0,d5
  390.         add.l   d3,d5
  391.         bra.b   .mainloop
  392.         ELSEIF
  393.         asr.l   #7,d4                   ;d4 >> 7
  394.         asr.l   #7,d5                   ;d5 >> 7
  395.         lea     ReciprocTable,a6        ;a6 -> reciprocal table
  396.         move    0(a6,d2.w*2),d0         ;d0 = (1/(spancount-1))<<16
  397.         muls    d0,d4                   ;d4 = d4 / (spancount-1)
  398.         asr.l   #7,d4                   ;sstep = d4 >> 7
  399.         muls    d0,d5                   ;d5 = d5 / (spancount-1)
  400.         asr.l   #7,d5                   ;tstep = d5 >> 7
  401.         bra.b   .mainloop
  402.         ENDC
  403. .special
  404.         cmp     #1,d2                   ;switch (spancount-1)
  405.         ble.b   .mainloop               ;0,1 -> no scaling needed
  406.         cmp     #3,d2                   ;3 -> standard qdiv
  407.         beq.b   .qdiv
  408.         blt.b   .spec_2
  409.         asr.l   #2,d4                   ;4 -> scale by shifting right
  410.         asr.l   #2,d5
  411.         bra.b   .mainloop
  412. .spec_8
  413.         asr.l   #3,d4                   ;8 -> scale by shifting right
  414.         asr.l   #3,d5
  415.         bra.b   .mainloop
  416. .spec_2
  417.         asr.l   #1,d4                   ;2 -> scale by shifting right
  418.         asr.l   #1,d5
  419.         ENDC
  420.  
  421. ******  Main drawing loop. Here lies the speed.
  422. ******  Very optimized (removed multiplication from inner loop)
  423.  
  424. ******  d2 : spancount
  425. ******  d4 : sstep
  426. ******  d5 : tstep
  427. ******  d6 : s
  428. ******  d7 : t
  429. ******  a0 : pdest
  430. ******  a1 : pbase
  431.  
  432. *                        do
  433. *                        {
  434. *                                *pdest++ = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
  435. *                                s += sstep;
  436. *                                t += tstep;
  437. *                        } while (--spancount > 0);
  438.  
  439. .mainloop
  440.         move.l  d1,-(sp)
  441.         lea     .PixTable,a6            ;a6 -> Functable
  442.         move.l  _cachewidth,d3          ;read cachewidth
  443.         move.l  0(a6,d2.w*4),a6         ;get pointer to function
  444.         swap    d7
  445.         swap    d4
  446.         move.l  d7,d1
  447.         swap    d5
  448.         muls    d3,d7                   ;d7 = t integer part * cachewidth
  449.         move    d5,d2
  450.         clr     d1                      ;d1 = t fractional part
  451.         muls    d3,d2                   ;tstep integer part * cachewidth
  452.         move    d4,d0                   ;d0 = sstep integer part
  453.         clr     d5                      ;d5 = tstep fractional part
  454.         clr     d4                      ;d4 = sstep fractional part
  455.         swap    d6                      ;d6 = s swapped
  456.         jmp     (a6)
  457. .Pix16
  458.         lea     0(a1,d6.w),a6
  459.         move.b  0(a6,d7.l),(a0)+
  460.         add.l   d4,d6                   ;increment s fractional part
  461.         addx.w  d0,d6                   ;increment s integer part
  462.         add.l   d2,d7                   ;increment t integer part
  463.         add.l   d5,d1                   ;increment t fractional part
  464.         bcc.b   .Pix15                   ;check if carry
  465.         add.l   d3,d7                   ;add cachewidth to t
  466. .Pix15
  467.         lea     0(a1,d6.w),a6           ;and so long...
  468.         move.b  0(a6,d7.l),(a0)+
  469.         add.l   d4,d6
  470.         addx.w  d0,d6
  471.         add.l   d2,d7
  472.         add.l   d5,d1
  473.         bcc.b   .Pix14
  474.         add.l   d3,d7
  475. .Pix14
  476.         lea     0(a1,d6.w),a6
  477.         move.b  0(a6,d7.l),(a0)+
  478.         add.l   d4,d6
  479.         addx.w  d0,d6
  480.         add.l   d2,d7
  481.         add.l   d5,d1
  482.         bcc.b   .Pix13
  483.         add.l   d3,d7
  484. .Pix13
  485.         lea     0(a1,d6.w),a6
  486.         move.b  0(a6,d7.l),(a0)+
  487.         add.l   d4,d6
  488.         addx.w  d0,d6
  489.         add.l   d2,d7
  490.         add.l   d5,d1
  491.         bcc.b   .Pix12
  492.         add.l   d3,d7
  493. .Pix12
  494.         lea     0(a1,d6.w),a6
  495.         move.b  0(a6,d7.l),(a0)+
  496.         add.l   d4,d6
  497.         addx.w  d0,d6
  498.         add.l   d2,d7
  499.         add.l   d5,d1
  500.         bcc.b   .Pix11
  501.         add.l   d3,d7
  502. .Pix11
  503.         lea     0(a1,d6.w),a6
  504.         move.b  0(a6,d7.l),(a0)+
  505.         add.l   d4,d6
  506.         addx.w  d0,d6
  507.         add.l   d2,d7
  508.         add.l   d5,d1
  509.         bcc.b   .Pix10
  510.         add.l   d3,d7
  511. .Pix10
  512.         lea     0(a1,d6.w),a6
  513.         move.b  0(a6,d7.l),(a0)+
  514.         add.l   d4,d6
  515.         addx.w  d0,d6
  516.         add.l   d2,d7
  517.         add.l   d5,d1
  518.         bcc.b   .Pix9
  519.         add.l   d3,d7
  520. .Pix9
  521.         lea     0(a1,d6.w),a6
  522.         move.b  0(a6,d7.l),(a0)+
  523.         add.l   d4,d6
  524.         addx.w  d0,d6
  525.         add.l   d2,d7
  526.         add.l   d5,d1
  527.         bcc.b   .Pix8
  528.         add.l   d3,d7
  529. .Pix8
  530.         lea     0(a1,d6.w),a6
  531.         move.b  0(a6,d7.l),(a0)+
  532.         add.l   d4,d6
  533.         addx.w  d0,d6
  534.         add.l   d2,d7
  535.         add.l   d5,d1
  536.         bcc.b   .Pix7
  537.         add.l   d3,d7
  538. .Pix7
  539.         lea     0(a1,d6.w),a6
  540.         move.b  0(a6,d7.l),(a0)+
  541.         add.l   d4,d6
  542.         addx.w  d0,d6
  543.         add.l   d2,d7
  544.         add.l   d5,d1
  545.         bcc.b   .Pix6
  546.         add.l   d3,d7
  547. .Pix6
  548.         lea     0(a1,d6.w),a6
  549.         move.b  0(a6,d7.l),(a0)+
  550.         add.l   d4,d6
  551.         addx.w  d0,d6
  552.         add.l   d2,d7
  553.         add.l   d5,d1
  554.         bcc.b   .Pix5
  555.         add.l   d3,d7
  556. .Pix5
  557.         lea     0(a1,d6.w),a6
  558.         move.b  0(a6,d7.l),(a0)+
  559.         add.l   d4,d6
  560.         addx.w  d0,d6
  561.         add.l   d2,d7
  562.         add.l   d5,d1
  563.         bcc.b   .Pix4
  564.         add.l   d3,d7
  565. .Pix4
  566.         lea     0(a1,d6.w),a6
  567.         move.b  0(a6,d7.l),(a0)+
  568.         add.l   d4,d6
  569.         addx.w  d0,d6
  570.         add.l   d2,d7
  571.         add.l   d5,d1
  572.         bcc.b   .Pix3
  573.         add.l   d3,d7
  574. .Pix3
  575.         lea     0(a1,d6.w),a6
  576.         move.b  0(a6,d7.l),(a0)+
  577.         add.l   d4,d6
  578.         addx.w  d0,d6
  579.         add.l   d2,d7
  580.         add.l   d5,d1
  581.         bcc.b   .Pix2
  582.         add.l   d3,d7
  583. .Pix2
  584.         lea     0(a1,d6.w),a6
  585.         move.b  0(a6,d7.l),(a0)+
  586.         add.l   d4,d6
  587.         addx.w  d0,d6
  588.         add.l   d2,d7
  589.         add.l   d5,d1
  590.         bcc.b   .Pix1
  591.         add.l   d3,d7
  592. .Pix1
  593.         lea     0(a1,d6.w),a6
  594.         move.b  0(a6,d7.l),(a0)+
  595.         add.l   d4,d6
  596.         addx.w  d0,d6
  597.         add.l   d2,d7
  598.         add.l   d5,d1
  599.         bcc.b   .Pix0
  600.         add.l   d3,d7
  601. .Pix0
  602.  
  603. ******  loop terminations
  604.  
  605.  
  606.         move.l   .saved5+4(sp),d7         ;t = tnext
  607.         move.l   .saved4+4(sp),d6         ;s = snext
  608.  
  609.         move.l  (sp)+,d1
  610. *       tst.l   d1                      ;while (count > 0)
  611.         bgt.w   .loop2
  612.  
  613.         move.l  .savea6(sp),a6          ;while ((pspan = pspan->next) != NULL)
  614.         move.l  SPAN_PNEXT(a6),a6
  615.         tst.l   a6
  616.         bne.w   .loop
  617.         add.l   #.fpuregs,sp
  618.         fmovem.x        (sp)+,fp2-fp7
  619.         movem.l (sp)+,d2-d7/a2-a6
  620.         rts
  621.  
  622. .PixTable
  623.         dc.l    .Pix1
  624.         dc.l    .Pix2
  625.         dc.l    .Pix3
  626.         dc.l    .Pix4
  627.         dc.l    .Pix5
  628.         dc.l    .Pix6
  629.         dc.l    .Pix7
  630.         dc.l    .Pix8
  631.         dc.l    .Pix9
  632.         dc.l    .Pix10
  633.         dc.l    .Pix11
  634.         dc.l    .Pix12
  635.         dc.l    .Pix13
  636.         dc.l    .Pix14
  637.         dc.l    .Pix15
  638.         dc.l    .Pix16
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!